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_fcs.h"
14	#include "bfa_fcbuild.h"
15	#include "bfa_fc.h"
16
17	BFA_TRC_FILE(FCS, PORT);
18
19	/*
20	* ALPA to LIXA bitmap mapping
21	*
22	* ALPA 0x00 (Word 0, Bit 30) is invalid for N_Ports. Also Word 0 Bit 31
23	* is for L_bit (login required) and is filled as ALPA 0x00 here.
24	*/
25	static const u8 loop_alpa_map[] = {
26	0x00, 0x00, 0x01, 0x02, 0x04, 0x08, 0x0F, 0x10, /* Word 0 Bits 31..24 */
27	0x17, 0x18, 0x1B, 0x1D, 0x1E, 0x1F, 0x23, 0x25, /* Word 0 Bits 23..16 */
28	0x26, 0x27, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, /* Word 0 Bits 15..08 */
29	0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x39, 0x3A, /* Word 0 Bits 07..00 */
30
31	0x3C, 0x43, 0x45, 0x46, 0x47, 0x49, 0x4A, 0x4B, /* Word 1 Bits 31..24 */
32	0x4C, 0x4D, 0x4E, 0x51, 0x52, 0x53, 0x54, 0x55, /* Word 1 Bits 23..16 */
33	0x56, 0x59, 0x5A, 0x5C, 0x63, 0x65, 0x66, 0x67, /* Word 1 Bits 15..08 */
34	0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x71, 0x72, /* Word 1 Bits 07..00 */
35
36	0x73, 0x74, 0x75, 0x76, 0x79, 0x7A, 0x7C, 0x80, /* Word 2 Bits 31..24 */
37	0x81, 0x82, 0x84, 0x88, 0x8F, 0x90, 0x97, 0x98, /* Word 2 Bits 23..16 */
38	0x9B, 0x9D, 0x9E, 0x9F, 0xA3, 0xA5, 0xA6, 0xA7, /* Word 2 Bits 15..08 */
39	0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xB1, 0xB2, /* Word 2 Bits 07..00 */
40
41	0xB3, 0xB4, 0xB5, 0xB6, 0xB9, 0xBA, 0xBC, 0xC3, /* Word 3 Bits 31..24 */
42	0xC5, 0xC6, 0xC7, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, /* Word 3 Bits 23..16 */
43	0xCE, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD9, /* Word 3 Bits 15..08 */
44	0xDA, 0xDC, 0xE0, 0xE1, 0xE2, 0xE4, 0xE8, 0xEF, /* Word 3 Bits 07..00 */
45	};
46
47	static void bfa_fcs_lport_send_ls_rjt(struct bfa_fcs_lport_s *port,
48	struct fchs_s *rx_fchs, u8 reason_code,
49	u8 reason_code_expl);
50	static void bfa_fcs_lport_plogi(struct bfa_fcs_lport_s *port,
51	struct fchs_s *rx_fchs, struct fc_logi_s *plogi);
52	static void bfa_fcs_lport_online_actions(struct bfa_fcs_lport_s *port);
53	static void bfa_fcs_lport_offline_actions(struct bfa_fcs_lport_s *port);
54	static void bfa_fcs_lport_unknown_init(struct bfa_fcs_lport_s *port);
55	static void bfa_fcs_lport_unknown_online(struct bfa_fcs_lport_s *port);
56	static void bfa_fcs_lport_unknown_offline(struct bfa_fcs_lport_s *port);
57	static void bfa_fcs_lport_deleted(struct bfa_fcs_lport_s *port);
58	static void bfa_fcs_lport_echo(struct bfa_fcs_lport_s *port,
59	struct fchs_s *rx_fchs,
60	struct fc_echo_s *echo, u16 len);
61	static void bfa_fcs_lport_rnid(struct bfa_fcs_lport_s *port,
62	struct fchs_s *rx_fchs,
63	struct fc_rnid_cmd_s *rnid, u16 len);
64	static void bfa_fs_port_get_gen_topo_data(struct bfa_fcs_lport_s *port,
65	struct fc_rnid_general_topology_data_s *gen_topo_data);
66
67	static void bfa_fcs_lport_fab_init(struct bfa_fcs_lport_s *port);
68	static void bfa_fcs_lport_fab_online(struct bfa_fcs_lport_s *port);
69	static void bfa_fcs_lport_fab_offline(struct bfa_fcs_lport_s *port);
70
71	static void bfa_fcs_lport_n2n_init(struct bfa_fcs_lport_s *port);
72	static void bfa_fcs_lport_n2n_online(struct bfa_fcs_lport_s *port);
73	static void bfa_fcs_lport_n2n_offline(struct bfa_fcs_lport_s *port);
74
75	static void bfa_fcs_lport_loop_init(struct bfa_fcs_lport_s *port);
76	static void bfa_fcs_lport_loop_online(struct bfa_fcs_lport_s *port);
77	static void bfa_fcs_lport_loop_offline(struct bfa_fcs_lport_s *port);
78
79	static struct {
80	void (*init) (struct bfa_fcs_lport_s *port);
81	void (*online) (struct bfa_fcs_lport_s *port);
82	void (*offline) (struct bfa_fcs_lport_s *port);
83	} __port_action[] = {
84	[BFA_FCS_FABRIC_UNKNOWN] = {
85	.init = bfa_fcs_lport_unknown_init,
86	.online = bfa_fcs_lport_unknown_online,
87	.offline = bfa_fcs_lport_unknown_offline
88	},
89	[BFA_FCS_FABRIC_SWITCHED] = {
90	.init = bfa_fcs_lport_fab_init,
91	.online = bfa_fcs_lport_fab_online,
92	.offline = bfa_fcs_lport_fab_offline
93	},
94	[BFA_FCS_FABRIC_N2N] = {
95	.init = bfa_fcs_lport_n2n_init,
96	.online = bfa_fcs_lport_n2n_online,
97	.offline = bfa_fcs_lport_n2n_offline
98	},
99	[BFA_FCS_FABRIC_LOOP] = {
100	.init = bfa_fcs_lport_loop_init,
101	.online = bfa_fcs_lport_loop_online,
102	.offline = bfa_fcs_lport_loop_offline
103	},
104	};
105
106	static void bfa_fcs_lport_sm_uninit(struct bfa_fcs_lport_s *port,
107	enum bfa_fcs_lport_event event);
108	static void bfa_fcs_lport_sm_init(struct bfa_fcs_lport_s *port,
109	enum bfa_fcs_lport_event event);
110	static void bfa_fcs_lport_sm_online(struct bfa_fcs_lport_s *port,
111	enum bfa_fcs_lport_event event);
112	static void bfa_fcs_lport_sm_offline(struct bfa_fcs_lport_s *port,
113	enum bfa_fcs_lport_event event);
114	static void bfa_fcs_lport_sm_deleting(struct bfa_fcs_lport_s *port,
115	enum bfa_fcs_lport_event event);
116	static void bfa_fcs_lport_sm_stopping(struct bfa_fcs_lport_s *port,
117	enum bfa_fcs_lport_event event);
118
119	static void
120	bfa_fcs_lport_sm_uninit(
121	struct bfa_fcs_lport_s *port,
122	enum bfa_fcs_lport_event event)
123	{
124	bfa_trc(port->fcs, port->port_cfg.pwwn);
125	bfa_trc(port->fcs, event);
126
127	switch (event) {
128	case BFA_FCS_PORT_SM_CREATE:
129	bfa_sm_set_state(port, bfa_fcs_lport_sm_init);
130	break;
131
132	default:
133	bfa_sm_fault(port->fcs, event);
134	}
135	}
136
137	static void
138	bfa_fcs_lport_sm_init(struct bfa_fcs_lport_s *port,
139	enum bfa_fcs_lport_event event)
140	{
141	bfa_trc(port->fcs, port->port_cfg.pwwn);
142	bfa_trc(port->fcs, event);
143
144	switch (event) {
145	case BFA_FCS_PORT_SM_ONLINE:
146	bfa_sm_set_state(port, bfa_fcs_lport_sm_online);
147	bfa_fcs_lport_online_actions(port);
148	break;
149
150	case BFA_FCS_PORT_SM_DELETE:
151	bfa_sm_set_state(port, bfa_fcs_lport_sm_uninit);
152	bfa_fcs_lport_deleted(port);
153	break;
154
155	case BFA_FCS_PORT_SM_STOP:
156	/* If vport - send completion call back */
157	if (port->vport)
158	bfa_fcs_vport_stop_comp(vport: port->vport);
159	else
160	bfa_wc_down(wc: &(port->fabric->stop_wc));
161	break;
162
163	case BFA_FCS_PORT_SM_OFFLINE:
164	break;
165
166	default:
167	bfa_sm_fault(port->fcs, event);
168	}
169	}
170
171	static void
172	bfa_fcs_lport_sm_online(
173	struct bfa_fcs_lport_s *port,
174	enum bfa_fcs_lport_event event)
175	{
176	struct bfa_fcs_rport_s *rport;
177	struct list_head *qe, *qen;
178
179	bfa_trc(port->fcs, port->port_cfg.pwwn);
180	bfa_trc(port->fcs, event);
181
182	switch (event) {
183	case BFA_FCS_PORT_SM_OFFLINE:
184	bfa_sm_set_state(port, bfa_fcs_lport_sm_offline);
185	bfa_fcs_lport_offline_actions(port);
186	break;
187
188	case BFA_FCS_PORT_SM_STOP:
189	__port_action[port->fabric->fab_type].offline(port);
190
191	if (port->num_rports == 0) {
192	bfa_sm_set_state(port, bfa_fcs_lport_sm_init);
193	/* If vport - send completion call back */
194	if (port->vport)
195	bfa_fcs_vport_stop_comp(vport: port->vport);
196	else
197	bfa_wc_down(wc: &(port->fabric->stop_wc));
198	} else {
199	bfa_sm_set_state(port, bfa_fcs_lport_sm_stopping);
200	list_for_each_safe(qe, qen, &port->rport_q) {
201	rport = (struct bfa_fcs_rport_s *) qe;
202	bfa_sm_send_event(rport, RPSM_EVENT_DELETE);
203	}
204	}
205	break;
206
207	case BFA_FCS_PORT_SM_DELETE:
208
209	__port_action[port->fabric->fab_type].offline(port);
210
211	if (port->num_rports == 0) {
212	bfa_sm_set_state(port, bfa_fcs_lport_sm_uninit);
213	bfa_fcs_lport_deleted(port);
214	} else {
215	bfa_sm_set_state(port, bfa_fcs_lport_sm_deleting);
216	list_for_each_safe(qe, qen, &port->rport_q) {
217	rport = (struct bfa_fcs_rport_s *) qe;
218	bfa_sm_send_event(rport, RPSM_EVENT_DELETE);
219	}
220	}
221	break;
222
223	case BFA_FCS_PORT_SM_DELRPORT:
224	break;
225
226	default:
227	bfa_sm_fault(port->fcs, event);
228	}
229	}
230
231	static void
232	bfa_fcs_lport_sm_offline(
233	struct bfa_fcs_lport_s *port,
234	enum bfa_fcs_lport_event event)
235	{
236	struct bfa_fcs_rport_s *rport;
237	struct list_head *qe, *qen;
238
239	bfa_trc(port->fcs, port->port_cfg.pwwn);
240	bfa_trc(port->fcs, event);
241
242	switch (event) {
243	case BFA_FCS_PORT_SM_ONLINE:
244	bfa_sm_set_state(port, bfa_fcs_lport_sm_online);
245	bfa_fcs_lport_online_actions(port);
246	break;
247
248	case BFA_FCS_PORT_SM_STOP:
249	if (port->num_rports == 0) {
250	bfa_sm_set_state(port, bfa_fcs_lport_sm_init);
251	/* If vport - send completion call back */
252	if (port->vport)
253	bfa_fcs_vport_stop_comp(vport: port->vport);
254	else
255	bfa_wc_down(wc: &(port->fabric->stop_wc));
256	} else {
257	bfa_sm_set_state(port, bfa_fcs_lport_sm_stopping);
258	list_for_each_safe(qe, qen, &port->rport_q) {
259	rport = (struct bfa_fcs_rport_s *) qe;
260	bfa_sm_send_event(rport, RPSM_EVENT_DELETE);
261	}
262	}
263	break;
264
265	case BFA_FCS_PORT_SM_DELETE:
266	if (port->num_rports == 0) {
267	bfa_sm_set_state(port, bfa_fcs_lport_sm_uninit);
268	bfa_fcs_lport_deleted(port);
269	} else {
270	bfa_sm_set_state(port, bfa_fcs_lport_sm_deleting);
271	list_for_each_safe(qe, qen, &port->rport_q) {
272	rport = (struct bfa_fcs_rport_s *) qe;
273	bfa_sm_send_event(rport, RPSM_EVENT_DELETE);
274	}
275	}
276	break;
277
278	case BFA_FCS_PORT_SM_DELRPORT:
279	case BFA_FCS_PORT_SM_OFFLINE:
280	break;
281
282	default:
283	bfa_sm_fault(port->fcs, event);
284	}
285	}
286
287	static void
288	bfa_fcs_lport_sm_stopping(struct bfa_fcs_lport_s *port,
289	enum bfa_fcs_lport_event event)
290	{
291	bfa_trc(port->fcs, port->port_cfg.pwwn);
292	bfa_trc(port->fcs, event);
293
294	switch (event) {
295	case BFA_FCS_PORT_SM_DELRPORT:
296	if (port->num_rports == 0) {
297	bfa_sm_set_state(port, bfa_fcs_lport_sm_init);
298	/* If vport - send completion call back */
299	if (port->vport)
300	bfa_fcs_vport_stop_comp(vport: port->vport);
301	else
302	bfa_wc_down(wc: &(port->fabric->stop_wc));
303	}
304	break;
305
306	default:
307	bfa_sm_fault(port->fcs, event);
308	}
309	}
310
311	static void
312	bfa_fcs_lport_sm_deleting(
313	struct bfa_fcs_lport_s *port,
314	enum bfa_fcs_lport_event event)
315	{
316	bfa_trc(port->fcs, port->port_cfg.pwwn);
317	bfa_trc(port->fcs, event);
318
319	switch (event) {
320	case BFA_FCS_PORT_SM_DELRPORT:
321	if (port->num_rports == 0) {
322	bfa_sm_set_state(port, bfa_fcs_lport_sm_uninit);
323	bfa_fcs_lport_deleted(port);
324	}
325	break;
326
327	default:
328	bfa_sm_fault(port->fcs, event);
329	}
330	}
331
332	/*
333	* fcs_port_pvt
334	*/
335
336	/*
337	* Send AEN notification
338	*/
339	static void
340	bfa_fcs_lport_aen_post(struct bfa_fcs_lport_s *port,
341	enum bfa_lport_aen_event event)
342	{
343	struct bfad_s *bfad = (struct bfad_s *)port->fabric->fcs->bfad;
344	struct bfa_aen_entry_s *aen_entry;
345
346	bfad_get_aen_entry(bfad, aen_entry);
347	if (!aen_entry)
348	return;
349
350	aen_entry->aen_data.lport.vf_id = port->fabric->vf_id;
351	aen_entry->aen_data.lport.roles = port->port_cfg.roles;
352	aen_entry->aen_data.lport.ppwwn = bfa_fcs_lport_get_pwwn(
353	bfa_fcs_get_base_port(port->fcs));
354	aen_entry->aen_data.lport.lpwwn = bfa_fcs_lport_get_pwwn(port);
355
356	/* Send the AEN notification */
357	bfad_im_post_vendor_event(entry: aen_entry, drv: bfad, cnt: ++port->fcs->fcs_aen_seq,
358	cat: BFA_AEN_CAT_LPORT, evt: event);
359	}
360
361	/*
362	* Send a LS reject
363	*/
364	static void
365	bfa_fcs_lport_send_ls_rjt(struct bfa_fcs_lport_s *port, struct fchs_s *rx_fchs,
366	u8 reason_code, u8 reason_code_expl)
367	{
368	struct fchs_s fchs;
369	struct bfa_fcxp_s *fcxp;
370	struct bfa_rport_s *bfa_rport = NULL;
371	int len;
372
373	bfa_trc(port->fcs, rx_fchs->d_id);
374	bfa_trc(port->fcs, rx_fchs->s_id);
375
376	fcxp = bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE);
377	if (!fcxp)
378	return;
379
380	len = fc_ls_rjt_build(fchs: &fchs, ls_rjt: bfa_fcxp_get_reqbuf(fcxp),
381	d_id: rx_fchs->s_id, bfa_fcs_lport_get_fcid(port),
382	ox_id: rx_fchs->ox_id, reason_code, reason_code_expl);
383
384	bfa_fcxp_send(fcxp, rport: bfa_rport, vf_id: port->fabric->vf_id, lp_tag: port->lp_tag,
385	cts: BFA_FALSE, cos: FC_CLASS_3, reqlen: len, fchs: &fchs, NULL, NULL,
386	rsp_maxlen: FC_MAX_PDUSZ, rsp_timeout: 0);
387	}
388
389	/*
390	* Send a FCCT Reject
391	*/
392	static void
393	bfa_fcs_lport_send_fcgs_rjt(struct bfa_fcs_lport_s *port,
394	struct fchs_s *rx_fchs, u8 reason_code, u8 reason_code_expl)
395	{
396	struct fchs_s fchs;
397	struct bfa_fcxp_s *fcxp;
398	struct bfa_rport_s *bfa_rport = NULL;
399	int len;
400	struct ct_hdr_s *rx_cthdr = (struct ct_hdr_s *)(rx_fchs + 1);
401	struct ct_hdr_s *ct_hdr;
402
403	bfa_trc(port->fcs, rx_fchs->d_id);
404	bfa_trc(port->fcs, rx_fchs->s_id);
405
406	fcxp = bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE);
407	if (!fcxp)
408	return;
409
410	ct_hdr = bfa_fcxp_get_reqbuf(fcxp);
411	ct_hdr->gs_type = rx_cthdr->gs_type;
412	ct_hdr->gs_sub_type = rx_cthdr->gs_sub_type;
413
414	len = fc_gs_rjt_build(fchs: &fchs, cthdr: ct_hdr, d_id: rx_fchs->s_id,
415	bfa_fcs_lport_get_fcid(port),
416	ox_id: rx_fchs->ox_id, reason_code, reason_code_expl);
417
418	bfa_fcxp_send(fcxp, rport: bfa_rport, vf_id: port->fabric->vf_id, lp_tag: port->lp_tag,
419	cts: BFA_FALSE, cos: FC_CLASS_3, reqlen: len, fchs: &fchs, NULL, NULL,
420	rsp_maxlen: FC_MAX_PDUSZ, rsp_timeout: 0);
421	}
422
423	/*
424	* Process incoming plogi from a remote port.
425	*/
426	static void
427	bfa_fcs_lport_plogi(struct bfa_fcs_lport_s *port,
428	struct fchs_s *rx_fchs, struct fc_logi_s *plogi)
429	{
430	struct bfa_fcs_rport_s *rport;
431
432	bfa_trc(port->fcs, rx_fchs->d_id);
433	bfa_trc(port->fcs, rx_fchs->s_id);
434
435	/*
436	* If min cfg mode is enabled, drop any incoming PLOGIs
437	*/
438	if (__fcs_min_cfg(port->fcs)) {
439	bfa_trc(port->fcs, rx_fchs->s_id);
440	return;
441	}
442
443	if (fc_plogi_parse(fchs: rx_fchs) != FC_PARSE_OK) {
444	bfa_trc(port->fcs, rx_fchs->s_id);
445	/*
446	* send a LS reject
447	*/
448	bfa_fcs_lport_send_ls_rjt(port, rx_fchs,
449	reason_code: FC_LS_RJT_RSN_PROTOCOL_ERROR,
450	reason_code_expl: FC_LS_RJT_EXP_SPARMS_ERR_OPTIONS);
451	return;
452	}
453
454	/*
455	* Direct Attach P2P mode : verify address assigned by the r-port.
456	*/
457	if ((!bfa_fcs_fabric_is_switched(port->fabric)) &&
458	(memcmp(p: (void *)&bfa_fcs_lport_get_pwwn(port),
459	q: (void *)&plogi->port_name, size: sizeof(wwn_t)) < 0)) {
460	if (BFA_FCS_PID_IS_WKA(rx_fchs->d_id)) {
461	/* Address assigned to us cannot be a WKA */
462	bfa_fcs_lport_send_ls_rjt(port, rx_fchs,
463	reason_code: FC_LS_RJT_RSN_PROTOCOL_ERROR,
464	reason_code_expl: FC_LS_RJT_EXP_INVALID_NPORT_ID);
465	return;
466	}
467	port->pid = rx_fchs->d_id;
468	bfa_lps_set_n2n_pid(lps: port->fabric->lps, n2n_pid: rx_fchs->d_id);
469	}
470
471	/*
472	* First, check if we know the device by pwwn.
473	*/
474	rport = bfa_fcs_lport_get_rport_by_pwwn(port, pwwn: plogi->port_name);
475	if (rport) {
476	/*
477	* Direct Attach P2P mode : handle address assigned by r-port.
478	*/
479	if ((!bfa_fcs_fabric_is_switched(port->fabric)) &&
480	(memcmp(p: (void *)&bfa_fcs_lport_get_pwwn(port),
481	q: (void *)&plogi->port_name, size: sizeof(wwn_t)) < 0)) {
482	port->pid = rx_fchs->d_id;
483	bfa_lps_set_n2n_pid(lps: port->fabric->lps, n2n_pid: rx_fchs->d_id);
484	rport->pid = rx_fchs->s_id;
485	}
486	bfa_fcs_rport_plogi(rport, fchs: rx_fchs, plogi);
487	return;
488	}
489
490	/*
491	* Next, lookup rport by PID.
492	*/
493	rport = bfa_fcs_lport_get_rport_by_pid(port, pid: rx_fchs->s_id);
494	if (!rport) {
495	/*
496	* Inbound PLOGI from a new device.
497	*/
498	bfa_fcs_rport_plogi_create(port, rx_fchs, plogi);
499	return;
500	}
501
502	/*
503	* Rport is known only by PID.
504	*/
505	if (rport->pwwn) {
506	/*
507	* This is a different device with the same pid. Old device
508	* disappeared. Send implicit LOGO to old device.
509	*/
510	WARN_ON(rport->pwwn == plogi->port_name);
511	bfa_sm_send_event(rport, RPSM_EVENT_LOGO_IMP);
512
513	/*
514	* Inbound PLOGI from a new device (with old PID).
515	*/
516	bfa_fcs_rport_plogi_create(port, rx_fchs, plogi);
517	return;
518	}
519
520	/*
521	* PLOGI crossing each other.
522	*/
523	WARN_ON(rport->pwwn != WWN_NULL);
524	bfa_fcs_rport_plogi(rport, fchs: rx_fchs, plogi);
525	}
526
527	/*
528	* Process incoming ECHO.
529	* Since it does not require a login, it is processed here.
530	*/
531	static void
532	bfa_fcs_lport_echo(struct bfa_fcs_lport_s *port, struct fchs_s *rx_fchs,
533	struct fc_echo_s *echo, u16 rx_len)
534	{
535	struct fchs_s fchs;
536	struct bfa_fcxp_s *fcxp;
537	struct bfa_rport_s *bfa_rport = NULL;
538	int len, pyld_len;
539
540	bfa_trc(port->fcs, rx_fchs->s_id);
541	bfa_trc(port->fcs, rx_fchs->d_id);
542
543	fcxp = bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE);
544	if (!fcxp)
545	return;
546
547	len = fc_ls_acc_build(fchs: &fchs, els_cmd: bfa_fcxp_get_reqbuf(fcxp),
548	d_id: rx_fchs->s_id, bfa_fcs_lport_get_fcid(port),
549	ox_id: rx_fchs->ox_id);
550
551	/*
552	* Copy the payload (if any) from the echo frame
553	*/
554	pyld_len = rx_len - sizeof(struct fchs_s);
555	bfa_trc(port->fcs, rx_len);
556	bfa_trc(port->fcs, pyld_len);
557
558	if (pyld_len > len)
559	memcpy(((u8 *) bfa_fcxp_get_reqbuf(fcxp)) +
560	sizeof(struct fc_echo_s), (echo + 1),
561	(pyld_len - sizeof(struct fc_echo_s)));
562
563	bfa_fcxp_send(fcxp, rport: bfa_rport, vf_id: port->fabric->vf_id, lp_tag: port->lp_tag,
564	cts: BFA_FALSE, cos: FC_CLASS_3, reqlen: pyld_len, fchs: &fchs, NULL, NULL,
565	rsp_maxlen: FC_MAX_PDUSZ, rsp_timeout: 0);
566	}
567
568	/*
569	* Process incoming RNID.
570	* Since it does not require a login, it is processed here.
571	*/
572	static void
573	bfa_fcs_lport_rnid(struct bfa_fcs_lport_s *port, struct fchs_s *rx_fchs,
574	struct fc_rnid_cmd_s *rnid, u16 rx_len)
575	{
576	struct fc_rnid_common_id_data_s common_id_data;
577	struct fc_rnid_general_topology_data_s gen_topo_data;
578	struct fchs_s fchs;
579	struct bfa_fcxp_s *fcxp;
580	struct bfa_rport_s *bfa_rport = NULL;
581	u16 len;
582	u32 data_format;
583
584	bfa_trc(port->fcs, rx_fchs->s_id);
585	bfa_trc(port->fcs, rx_fchs->d_id);
586	bfa_trc(port->fcs, rx_len);
587
588	fcxp = bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE);
589	if (!fcxp)
590	return;
591
592	/*
593	* Check Node Indentification Data Format
594	* We only support General Topology Discovery Format.
595	* For any other requested Data Formats, we return Common Node Id Data
596	* only, as per FC-LS.
597	*/
598	bfa_trc(port->fcs, rnid->node_id_data_format);
599	if (rnid->node_id_data_format == RNID_NODEID_DATA_FORMAT_DISCOVERY) {
600	data_format = RNID_NODEID_DATA_FORMAT_DISCOVERY;
601	/*
602	* Get General topology data for this port
603	*/
604	bfa_fs_port_get_gen_topo_data(port, gen_topo_data: &gen_topo_data);
605	} else {
606	data_format = RNID_NODEID_DATA_FORMAT_COMMON;
607	}
608
609	/*
610	* Copy the Node Id Info
611	*/
612	common_id_data.port_name = bfa_fcs_lport_get_pwwn(port);
613	common_id_data.node_name = bfa_fcs_lport_get_nwwn(port);
614
615	len = fc_rnid_acc_build(fchs: &fchs, rnid_acc: bfa_fcxp_get_reqbuf(fcxp),
616	d_id: rx_fchs->s_id, bfa_fcs_lport_get_fcid(port),
617	ox_id: rx_fchs->ox_id, data_format, common_id_data: &common_id_data,
618	gen_topo_data: &gen_topo_data);
619
620	bfa_fcxp_send(fcxp, rport: bfa_rport, vf_id: port->fabric->vf_id, lp_tag: port->lp_tag,
621	cts: BFA_FALSE, cos: FC_CLASS_3, reqlen: len, fchs: &fchs, NULL, NULL,
622	rsp_maxlen: FC_MAX_PDUSZ, rsp_timeout: 0);
623	}
624
625	/*
626	* Fill out General Topolpgy Discovery Data for RNID ELS.
627	*/
628	static void
629	bfa_fs_port_get_gen_topo_data(struct bfa_fcs_lport_s *port,
630	struct fc_rnid_general_topology_data_s *gen_topo_data)
631	{
632	memset(gen_topo_data, 0,
633	sizeof(struct fc_rnid_general_topology_data_s));
634
635	gen_topo_data->asso_type = cpu_to_be32(RNID_ASSOCIATED_TYPE_HOST);
636	gen_topo_data->phy_port_num = 0; /* @todo */
637	gen_topo_data->num_attached_nodes = cpu_to_be32(1);
638	}
639
640	static void
641	bfa_fcs_lport_online_actions(struct bfa_fcs_lport_s *port)
642	{
643	struct bfad_s *bfad = (struct bfad_s *)port->fcs->bfad;
644	char lpwwn_buf[BFA_STRING_32];
645
646	bfa_trc(port->fcs, port->fabric->oper_type);
647
648	__port_action[port->fabric->fab_type].init(port);
649	__port_action[port->fabric->fab_type].online(port);
650
651	wwn2str(wwn_str: lpwwn_buf, bfa_fcs_lport_get_pwwn(port));
652	BFA_LOG(KERN_WARNING, bfad, bfa_log_level,
653	"Logical port online: WWN = %s Role = %s\n",
654	lpwwn_buf, "Initiator");
655	bfa_fcs_lport_aen_post(port, event: BFA_LPORT_AEN_ONLINE);
656
657	bfad->bfad_flags |= BFAD_PORT_ONLINE;
658	}
659
660	static void
661	bfa_fcs_lport_offline_actions(struct bfa_fcs_lport_s *port)
662	{
663	struct list_head *qe, *qen;
664	struct bfa_fcs_rport_s *rport;
665	struct bfad_s *bfad = (struct bfad_s *)port->fcs->bfad;
666	char lpwwn_buf[BFA_STRING_32];
667
668	bfa_trc(port->fcs, port->fabric->oper_type);
669
670	__port_action[port->fabric->fab_type].offline(port);
671
672	wwn2str(wwn_str: lpwwn_buf, bfa_fcs_lport_get_pwwn(port));
673	if (bfa_sm_cmp_state(port->fabric,
674	bfa_fcs_fabric_sm_online) == BFA_TRUE) {
675	BFA_LOG(KERN_WARNING, bfad, bfa_log_level,
676	"Logical port lost fabric connectivity: WWN = %s Role = %s\n",
677	lpwwn_buf, "Initiator");
678	bfa_fcs_lport_aen_post(port, event: BFA_LPORT_AEN_DISCONNECT);
679	} else {
680	BFA_LOG(KERN_WARNING, bfad, bfa_log_level,
681	"Logical port taken offline: WWN = %s Role = %s\n",
682	lpwwn_buf, "Initiator");
683	bfa_fcs_lport_aen_post(port, event: BFA_LPORT_AEN_OFFLINE);
684	}
685
686	list_for_each_safe(qe, qen, &port->rport_q) {
687	rport = (struct bfa_fcs_rport_s *) qe;
688	bfa_sm_send_event(rport, RPSM_EVENT_LOGO_IMP);
689	}
690	}
691
692	static void
693	bfa_fcs_lport_unknown_init(struct bfa_fcs_lport_s *port)
694	{
695	WARN_ON(1);
696	}
697
698	static void
699	bfa_fcs_lport_unknown_online(struct bfa_fcs_lport_s *port)
700	{
701	WARN_ON(1);
702	}
703
704	static void
705	bfa_fcs_lport_unknown_offline(struct bfa_fcs_lport_s *port)
706	{
707	WARN_ON(1);
708	}
709
710	static void
711	bfa_fcs_lport_abts_acc(struct bfa_fcs_lport_s *port, struct fchs_s *rx_fchs)
712	{
713	struct fchs_s fchs;
714	struct bfa_fcxp_s *fcxp;
715	int len;
716
717	bfa_trc(port->fcs, rx_fchs->d_id);
718	bfa_trc(port->fcs, rx_fchs->s_id);
719
720	fcxp = bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE);
721	if (!fcxp)
722	return;
723
724	len = fc_ba_acc_build(fchs: &fchs, ba_acc: bfa_fcxp_get_reqbuf(fcxp),
725	d_id: rx_fchs->s_id, bfa_fcs_lport_get_fcid(port),
726	ox_id: rx_fchs->ox_id, rx_id: 0);
727
728	bfa_fcxp_send(fcxp, NULL, vf_id: port->fabric->vf_id, lp_tag: port->lp_tag,
729	cts: BFA_FALSE, cos: FC_CLASS_3, reqlen: len, fchs: &fchs, NULL, NULL,
730	rsp_maxlen: FC_MAX_PDUSZ, rsp_timeout: 0);
731	}
732	static void
733	bfa_fcs_lport_deleted(struct bfa_fcs_lport_s *port)
734	{
735	struct bfad_s *bfad = (struct bfad_s *)port->fcs->bfad;
736	char lpwwn_buf[BFA_STRING_32];
737
738	wwn2str(wwn_str: lpwwn_buf, bfa_fcs_lport_get_pwwn(port));
739	BFA_LOG(KERN_INFO, bfad, bfa_log_level,
740	"Logical port deleted: WWN = %s Role = %s\n",
741	lpwwn_buf, "Initiator");
742	bfa_fcs_lport_aen_post(port, event: BFA_LPORT_AEN_DELETE);
743
744	/* Base port will be deleted by the OS driver */
745	if (port->vport)
746	bfa_fcs_vport_delete_comp(vport: port->vport);
747	else
748	bfa_wc_down(wc: &port->fabric->wc);
749	}
750
751
752	/*
753	* Unsolicited frame receive handling.
754	*/
755	void
756	bfa_fcs_lport_uf_recv(struct bfa_fcs_lport_s *lport,
757	struct fchs_s *fchs, u16 len)
758	{
759	u32 pid = fchs->s_id;
760	struct bfa_fcs_rport_s *rport = NULL;
761	struct fc_els_cmd_s *els_cmd = (struct fc_els_cmd_s *) (fchs + 1);
762
763	bfa_stats(lport, uf_recvs);
764	bfa_trc(lport->fcs, fchs->type);
765
766	if (!bfa_fcs_lport_is_online(port: lport)) {
767	/*
768	* In direct attach topology, it is possible to get a PLOGI
769	* before the lport is online due to port feature
770	* (QoS/Trunk/FEC/CR), so send a rjt
771	*/
772	if ((fchs->type == FC_TYPE_ELS) &&
773	(els_cmd->els_code == FC_ELS_PLOGI)) {
774	bfa_fcs_lport_send_ls_rjt(port: lport, rx_fchs: fchs,
775	reason_code: FC_LS_RJT_RSN_UNABLE_TO_PERF_CMD,
776	reason_code_expl: FC_LS_RJT_EXP_NO_ADDL_INFO);
777	bfa_stats(lport, plogi_rcvd);
778	} else
779	bfa_stats(lport, uf_recv_drops);
780
781	return;
782	}
783
784	/*
785	* First, handle ELSs that donot require a login.
786	*/
787	/*
788	* Handle PLOGI first
789	*/
790	if ((fchs->type == FC_TYPE_ELS) &&
791	(els_cmd->els_code == FC_ELS_PLOGI)) {
792	bfa_fcs_lport_plogi(port: lport, rx_fchs: fchs, plogi: (struct fc_logi_s *) els_cmd);
793	return;
794	}
795
796	/*
797	* Handle ECHO separately.
798	*/
799	if ((fchs->type == FC_TYPE_ELS) && (els_cmd->els_code == FC_ELS_ECHO)) {
800	bfa_fcs_lport_echo(port: lport, rx_fchs: fchs,
801	echo: (struct fc_echo_s *)els_cmd, rx_len: len);
802	return;
803	}
804
805	/*
806	* Handle RNID separately.
807	*/
808	if ((fchs->type == FC_TYPE_ELS) && (els_cmd->els_code == FC_ELS_RNID)) {
809	bfa_fcs_lport_rnid(port: lport, rx_fchs: fchs,
810	rnid: (struct fc_rnid_cmd_s *) els_cmd, rx_len: len);
811	return;
812	}
813
814	if (fchs->type == FC_TYPE_BLS) {
815	if ((fchs->routing == FC_RTG_BASIC_LINK) &&
816	(fchs->cat_info == FC_CAT_ABTS))
817	bfa_fcs_lport_abts_acc(port: lport, rx_fchs: fchs);
818	return;
819	}
820
821	if (fchs->type == FC_TYPE_SERVICES) {
822	/*
823	* Unhandled FC-GS frames. Send a FC-CT Reject
824	*/
825	bfa_fcs_lport_send_fcgs_rjt(port: lport, rx_fchs: fchs, reason_code: CT_RSN_NOT_SUPP,
826	reason_code_expl: CT_NS_EXP_NOADDITIONAL);
827	return;
828	}
829
830	/*
831	* look for a matching remote port ID
832	*/
833	rport = bfa_fcs_lport_get_rport_by_pid(port: lport, pid);
834	if (rport) {
835	bfa_trc(rport->fcs, fchs->s_id);
836	bfa_trc(rport->fcs, fchs->d_id);
837	bfa_trc(rport->fcs, fchs->type);
838
839	bfa_fcs_rport_uf_recv(rport, fchs, len);
840	return;
841	}
842
843	/*
844	* Only handles ELS frames for now.
845	*/
846	if (fchs->type != FC_TYPE_ELS) {
847	bfa_trc(lport->fcs, fchs->s_id);
848	bfa_trc(lport->fcs, fchs->d_id);
849	/* ignore type FC_TYPE_FC_FSS */
850	if (fchs->type != FC_TYPE_FC_FSS)
851	bfa_sm_fault(lport->fcs, fchs->type);
852	return;
853	}
854
855	bfa_trc(lport->fcs, els_cmd->els_code);
856	if (els_cmd->els_code == FC_ELS_RSCN) {
857	bfa_fcs_lport_scn_process_rscn(port: lport, rx_frame: fchs, len);
858	return;
859	}
860
861	if (els_cmd->els_code == FC_ELS_LOGO) {
862	/*
863	* @todo Handle LOGO frames received.
864	*/
865	return;
866	}
867
868	if (els_cmd->els_code == FC_ELS_PRLI) {
869	/*
870	* @todo Handle PRLI frames received.
871	*/
872	return;
873	}
874
875	/*
876	* Unhandled ELS frames. Send a LS_RJT.
877	*/
878	bfa_fcs_lport_send_ls_rjt(port: lport, rx_fchs: fchs, reason_code: FC_LS_RJT_RSN_CMD_NOT_SUPP,
879	reason_code_expl: FC_LS_RJT_EXP_NO_ADDL_INFO);
880
881	}
882
883	/*
884	* PID based Lookup for a R-Port in the Port R-Port Queue
885	*/
886	struct bfa_fcs_rport_s *
887	bfa_fcs_lport_get_rport_by_pid(struct bfa_fcs_lport_s *port, u32 pid)
888	{
889	struct bfa_fcs_rport_s *rport;
890	struct list_head *qe;
891
892	list_for_each(qe, &port->rport_q) {
893	rport = (struct bfa_fcs_rport_s *) qe;
894	if (rport->pid == pid)
895	return rport;
896	}
897
898	bfa_trc(port->fcs, pid);
899	return NULL;
900	}
901
902	/*
903	* OLD_PID based Lookup for a R-Port in the Port R-Port Queue
904	*/
905	struct bfa_fcs_rport_s *
906	bfa_fcs_lport_get_rport_by_old_pid(struct bfa_fcs_lport_s *port, u32 pid)
907	{
908	struct bfa_fcs_rport_s *rport;
909	struct list_head *qe;
910
911	list_for_each(qe, &port->rport_q) {
912	rport = (struct bfa_fcs_rport_s *) qe;
913	if (rport->old_pid == pid)
914	return rport;
915	}
916
917	bfa_trc(port->fcs, pid);
918	return NULL;
919	}
920
921	/*
922	* PWWN based Lookup for a R-Port in the Port R-Port Queue
923	*/
924	struct bfa_fcs_rport_s *
925	bfa_fcs_lport_get_rport_by_pwwn(struct bfa_fcs_lport_s *port, wwn_t pwwn)
926	{
927	struct bfa_fcs_rport_s *rport;
928	struct list_head *qe;
929
930	list_for_each(qe, &port->rport_q) {
931	rport = (struct bfa_fcs_rport_s *) qe;
932	if (wwn_is_equal(rport->pwwn, pwwn))
933	return rport;
934	}
935
936	bfa_trc(port->fcs, pwwn);
937	return NULL;
938	}
939
940	/*
941	* NWWN based Lookup for a R-Port in the Port R-Port Queue
942	*/
943	struct bfa_fcs_rport_s *
944	bfa_fcs_lport_get_rport_by_nwwn(struct bfa_fcs_lport_s *port, wwn_t nwwn)
945	{
946	struct bfa_fcs_rport_s *rport;
947	struct list_head *qe;
948
949	list_for_each(qe, &port->rport_q) {
950	rport = (struct bfa_fcs_rport_s *) qe;
951	if (wwn_is_equal(rport->nwwn, nwwn))
952	return rport;
953	}
954
955	bfa_trc(port->fcs, nwwn);
956	return NULL;
957	}
958
959	/*
960	* PWWN & PID based Lookup for a R-Port in the Port R-Port Queue
961	*/
962	struct bfa_fcs_rport_s *
963	bfa_fcs_lport_get_rport_by_qualifier(struct bfa_fcs_lport_s *port,
964	wwn_t pwwn, u32 pid)
965	{
966	struct bfa_fcs_rport_s *rport;
967	struct list_head *qe;
968
969	list_for_each(qe, &port->rport_q) {
970	rport = (struct bfa_fcs_rport_s *) qe;
971	if (wwn_is_equal(rport->pwwn, pwwn) && rport->pid == pid)
972	return rport;
973	}
974
975	bfa_trc(port->fcs, pwwn);
976	return NULL;
977	}
978
979	/*
980	* Called by rport module when new rports are discovered.
981	*/
982	void
983	bfa_fcs_lport_add_rport(
984	struct bfa_fcs_lport_s *port,
985	struct bfa_fcs_rport_s *rport)
986	{
987	list_add_tail(new: &rport->qe, head: &port->rport_q);
988	port->num_rports++;
989	}
990
991	/*
992	* Called by rport module to when rports are deleted.
993	*/
994	void
995	bfa_fcs_lport_del_rport(
996	struct bfa_fcs_lport_s *port,
997	struct bfa_fcs_rport_s *rport)
998	{
999	WARN_ON(!bfa_q_is_on_q(&port->rport_q, rport));
1000	list_del(entry: &rport->qe);
1001	port->num_rports--;
1002
1003	bfa_sm_send_event(port, BFA_FCS_PORT_SM_DELRPORT);
1004	}
1005
1006	/*
1007	* Called by fabric for base port when fabric login is complete.
1008	* Called by vport for virtual ports when FDISC is complete.
1009	*/
1010	void
1011	bfa_fcs_lport_online(struct bfa_fcs_lport_s *port)
1012	{
1013	bfa_sm_send_event(port, BFA_FCS_PORT_SM_ONLINE);
1014	}
1015
1016	/*
1017	* Called by fabric for base port when fabric goes offline.
1018	* Called by vport for virtual ports when virtual port becomes offline.
1019	*/
1020	void
1021	bfa_fcs_lport_offline(struct bfa_fcs_lport_s *port)
1022	{
1023	bfa_sm_send_event(port, BFA_FCS_PORT_SM_OFFLINE);
1024	}
1025
1026	/*
1027	* Called by fabric for base port and by vport for virtual ports
1028	* when target mode driver is unloaded.
1029	*/
1030	void
1031	bfa_fcs_lport_stop(struct bfa_fcs_lport_s *port)
1032	{
1033	bfa_sm_send_event(port, BFA_FCS_PORT_SM_STOP);
1034	}
1035
1036	/*
1037	* Called by fabric to delete base lport and associated resources.
1038	*
1039	* Called by vport to delete lport and associated resources. Should call
1040	* bfa_fcs_vport_delete_comp() for vports on completion.
1041	*/
1042	void
1043	bfa_fcs_lport_delete(struct bfa_fcs_lport_s *port)
1044	{
1045	bfa_sm_send_event(port, BFA_FCS_PORT_SM_DELETE);
1046	}
1047
1048	/*
1049	* Return TRUE if port is online, else return FALSE
1050	*/
1051	bfa_boolean_t
1052	bfa_fcs_lport_is_online(struct bfa_fcs_lport_s *port)
1053	{
1054	return bfa_sm_cmp_state(port, bfa_fcs_lport_sm_online);
1055	}
1056
1057	/*
1058	* Attach time initialization of logical ports.
1059	*/
1060	void
1061	bfa_fcs_lport_attach(struct bfa_fcs_lport_s *lport, struct bfa_fcs_s *fcs,
1062	u16 vf_id, struct bfa_fcs_vport_s *vport)
1063	{
1064	lport->fcs = fcs;
1065	lport->fabric = bfa_fcs_vf_lookup(fcs, vf_id);
1066	lport->vport = vport;
1067	lport->lp_tag = (vport) ? vport->lps->bfa_tag :
1068	lport->fabric->lps->bfa_tag;
1069
1070	INIT_LIST_HEAD(list: &lport->rport_q);
1071	lport->num_rports = 0;
1072	}
1073
1074	/*
1075	* Logical port initialization of base or virtual port.
1076	* Called by fabric for base port or by vport for virtual ports.
1077	*/
1078
1079	void
1080	bfa_fcs_lport_init(struct bfa_fcs_lport_s *lport,
1081	struct bfa_lport_cfg_s *port_cfg)
1082	{
1083	struct bfa_fcs_vport_s *vport = lport->vport;
1084	struct bfad_s *bfad = (struct bfad_s *)lport->fcs->bfad;
1085	char lpwwn_buf[BFA_STRING_32];
1086
1087	lport->port_cfg = *port_cfg;
1088
1089	lport->bfad_port = bfa_fcb_lport_new(bfad: lport->fcs->bfad, port: lport,
1090	roles: lport->port_cfg.roles,
1091	vf_drv: lport->fabric->vf_drv,
1092	vp_drv: vport ? vport->vport_drv : NULL);
1093
1094	wwn2str(wwn_str: lpwwn_buf, bfa_fcs_lport_get_pwwn(lport));
1095	BFA_LOG(KERN_INFO, bfad, bfa_log_level,
1096	"New logical port created: WWN = %s Role = %s\n",
1097	lpwwn_buf, "Initiator");
1098	bfa_fcs_lport_aen_post(port: lport, event: BFA_LPORT_AEN_NEW);
1099
1100	bfa_sm_set_state(lport, bfa_fcs_lport_sm_uninit);
1101	bfa_sm_send_event(lport, BFA_FCS_PORT_SM_CREATE);
1102	}
1103
1104	void
1105	bfa_fcs_lport_set_symname(struct bfa_fcs_lport_s *port,
1106	char *symname)
1107	{
1108	strcpy(p: port->port_cfg.sym_name.symname, q: symname);
1109
1110	if (bfa_sm_cmp_state(port, bfa_fcs_lport_sm_online))
1111	bfa_fcs_lport_ns_util_send_rspn_id(
1112	BFA_FCS_GET_NS_FROM_PORT(port), NULL);
1113	}
1114
1115	/*
1116	* fcs_lport_api
1117	*/
1118
1119	void
1120	bfa_fcs_lport_get_attr(
1121	struct bfa_fcs_lport_s *port,
1122	struct bfa_lport_attr_s *port_attr)
1123	{
1124	if (bfa_sm_cmp_state(port, bfa_fcs_lport_sm_online))
1125	port_attr->pid = port->pid;
1126	else
1127	port_attr->pid = 0;
1128
1129	port_attr->port_cfg = port->port_cfg;
1130
1131	if (port->fabric) {
1132	port_attr->port_type = port->fabric->oper_type;
1133	port_attr->loopback = bfa_sm_cmp_state(port->fabric,
1134	bfa_fcs_fabric_sm_loopback);
1135	port_attr->authfail =
1136	bfa_sm_cmp_state(port->fabric,
1137	bfa_fcs_fabric_sm_auth_failed);
1138	port_attr->fabric_name = bfa_fcs_lport_get_fabric_name(port);
1139	memcpy(port_attr->fabric_ip_addr,
1140	bfa_fcs_lport_get_fabric_ipaddr(port),
1141	BFA_FCS_FABRIC_IPADDR_SZ);
1142
1143	if (port->vport != NULL) {
1144	port_attr->port_type = BFA_PORT_TYPE_VPORT;
1145	port_attr->fpma_mac =
1146	port->vport->lps->lp_mac;
1147	} else {
1148	port_attr->fpma_mac =
1149	port->fabric->lps->lp_mac;
1150	}
1151	} else {
1152	port_attr->port_type = BFA_PORT_TYPE_UNKNOWN;
1153	port_attr->state = BFA_LPORT_UNINIT;
1154	}
1155	}
1156
1157	/*
1158	* bfa_fcs_lport_fab port fab functions
1159	*/
1160
1161	/*
1162	* Called by port to initialize fabric services of the base port.
1163	*/
1164	static void
1165	bfa_fcs_lport_fab_init(struct bfa_fcs_lport_s *port)
1166	{
1167	bfa_fcs_lport_ns_init(vport: port);
1168	bfa_fcs_lport_scn_init(vport: port);
1169	bfa_fcs_lport_ms_init(port);
1170	}
1171
1172	/*
1173	* Called by port to notify transition to online state.
1174	*/
1175	static void
1176	bfa_fcs_lport_fab_online(struct bfa_fcs_lport_s *port)
1177	{
1178	bfa_fcs_lport_ns_online(vport: port);
1179	bfa_fcs_lport_fab_scn_online(vport: port);
1180	}
1181
1182	/*
1183	* Called by port to notify transition to offline state.
1184	*/
1185	static void
1186	bfa_fcs_lport_fab_offline(struct bfa_fcs_lport_s *port)
1187	{
1188	bfa_fcs_lport_ns_offline(vport: port);
1189	bfa_fcs_lport_scn_offline(vport: port);
1190	bfa_fcs_lport_ms_offline(port);
1191	}
1192
1193	/*
1194	* bfa_fcs_lport_n2n functions
1195	*/
1196
1197	/*
1198	* Called by fcs/port to initialize N2N topology.
1199	*/
1200	static void
1201	bfa_fcs_lport_n2n_init(struct bfa_fcs_lport_s *port)
1202	{
1203	}
1204
1205	/*
1206	* Called by fcs/port to notify transition to online state.
1207	*/
1208	static void
1209	bfa_fcs_lport_n2n_online(struct bfa_fcs_lport_s *port)
1210	{
1211	struct bfa_fcs_lport_n2n_s *n2n_port = &port->port_topo.pn2n;
1212	struct bfa_lport_cfg_s *pcfg = &port->port_cfg;
1213	struct bfa_fcs_rport_s *rport;
1214
1215	bfa_trc(port->fcs, pcfg->pwwn);
1216
1217	/*
1218	* If our PWWN is > than that of the r-port, we have to initiate PLOGI
1219	* and assign an Address. if not, we need to wait for its PLOGI.
1220	*
1221	* If our PWWN is < than that of the remote port, it will send a PLOGI
1222	* with the PIDs assigned. The rport state machine take care of this
1223	* incoming PLOGI.
1224	*/
1225	if (memcmp
1226	(p: (void *)&pcfg->pwwn, q: (void *)&n2n_port->rem_port_wwn,
1227	size: sizeof(wwn_t)) > 0) {
1228	port->pid = N2N_LOCAL_PID;
1229	bfa_lps_set_n2n_pid(lps: port->fabric->lps, N2N_LOCAL_PID);
1230	/*
1231	* First, check if we know the device by pwwn.
1232	*/
1233	rport = bfa_fcs_lport_get_rport_by_pwwn(port,
1234	pwwn: n2n_port->rem_port_wwn);
1235	if (rport) {
1236	bfa_trc(port->fcs, rport->pid);
1237	bfa_trc(port->fcs, rport->pwwn);
1238	rport->pid = N2N_REMOTE_PID;
1239	bfa_sm_send_event(rport, RPSM_EVENT_PLOGI_SEND);
1240	return;
1241	}
1242
1243	/*
1244	* In n2n there can be only one rport. Delete the old one
1245	* whose pid should be zero, because it is offline.
1246	*/
1247	if (port->num_rports > 0) {
1248	rport = bfa_fcs_lport_get_rport_by_pid(port, pid: 0);
1249	WARN_ON(rport == NULL);
1250	if (rport) {
1251	bfa_trc(port->fcs, rport->pwwn);
1252	bfa_sm_send_event(rport, RPSM_EVENT_DELETE);
1253	}
1254	}
1255	bfa_fcs_rport_create(port, N2N_REMOTE_PID);
1256	}
1257	}
1258
1259	/*
1260	* Called by fcs/port to notify transition to offline state.
1261	*/
1262	static void
1263	bfa_fcs_lport_n2n_offline(struct bfa_fcs_lport_s *port)
1264	{
1265	struct bfa_fcs_lport_n2n_s *n2n_port = &port->port_topo.pn2n;
1266
1267	bfa_trc(port->fcs, port->pid);
1268	port->pid = 0;
1269	n2n_port->rem_port_wwn = 0;
1270	n2n_port->reply_oxid = 0;
1271	}
1272
1273	static void
1274	bfa_fcport_get_loop_attr(struct bfa_fcs_lport_s *port)
1275	{
1276	int i = 0, j = 0, bit = 0, alpa_bit = 0;
1277	u8 k = 0;
1278	struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(port->fcs->bfa);
1279
1280	port->port_topo.ploop.alpabm_valid = fcport->alpabm_valid;
1281	port->pid = fcport->myalpa;
1282	port->pid = bfa_hton3b(port->pid);
1283
1284	for (i = 0; i < (FC_ALPA_MAX / 8); i++) {
1285	for (j = 0, alpa_bit = 0; j < 8; j++, alpa_bit++) {
1286	bfa_trc(port->fcs->bfa, fcport->alpabm.alpa_bm[i]);
1287	bit = (fcport->alpabm.alpa_bm[i] & (1 << (7 - j)));
1288	if (bit) {
1289	port->port_topo.ploop.alpa_pos_map[k] =
1290	loop_alpa_map[(i * 8) + alpa_bit];
1291	k++;
1292	bfa_trc(port->fcs->bfa, k);
1293	bfa_trc(port->fcs->bfa,
1294	port->port_topo.ploop.alpa_pos_map[k]);
1295	}
1296	}
1297	}
1298	port->port_topo.ploop.num_alpa = k;
1299	}
1300
1301	/*
1302	* Called by fcs/port to initialize Loop topology.
1303	*/
1304	static void
1305	bfa_fcs_lport_loop_init(struct bfa_fcs_lport_s *port)
1306	{
1307	}
1308
1309	/*
1310	* Called by fcs/port to notify transition to online state.
1311	*/
1312	static void
1313	bfa_fcs_lport_loop_online(struct bfa_fcs_lport_s *port)
1314	{
1315	u8 num_alpa = 0, alpabm_valid = 0;
1316	struct bfa_fcs_rport_s *rport;
1317	u8 *alpa_map = NULL;
1318	int i = 0;
1319	u32 pid;
1320
1321	bfa_fcport_get_loop_attr(port);
1322
1323	num_alpa = port->port_topo.ploop.num_alpa;
1324	alpabm_valid = port->port_topo.ploop.alpabm_valid;
1325	alpa_map = port->port_topo.ploop.alpa_pos_map;
1326
1327	bfa_trc(port->fcs->bfa, port->pid);
1328	bfa_trc(port->fcs->bfa, num_alpa);
1329	if (alpabm_valid == 1) {
1330	for (i = 0; i < num_alpa; i++) {
1331	bfa_trc(port->fcs->bfa, alpa_map[i]);
1332	if (alpa_map[i] != bfa_hton3b(port->pid)) {
1333	pid = alpa_map[i];
1334	bfa_trc(port->fcs->bfa, pid);
1335	rport = bfa_fcs_lport_get_rport_by_pid(port,
1336	bfa_hton3b(pid));
1337	if (!rport)
1338	rport = bfa_fcs_rport_create(port,
1339	bfa_hton3b(pid));
1340	}
1341	}
1342	} else {
1343	for (i = 0; i < MAX_ALPA_COUNT; i++) {
1344	if (alpa_map[i] != port->pid) {
1345	pid = loop_alpa_map[i];
1346	bfa_trc(port->fcs->bfa, pid);
1347	rport = bfa_fcs_lport_get_rport_by_pid(port,
1348	bfa_hton3b(pid));
1349	if (!rport)
1350	rport = bfa_fcs_rport_create(port,
1351	bfa_hton3b(pid));
1352	}
1353	}
1354	}
1355	}
1356
1357	/*
1358	* Called by fcs/port to notify transition to offline state.
1359	*/
1360	static void
1361	bfa_fcs_lport_loop_offline(struct bfa_fcs_lport_s *port)
1362	{
1363	}
1364
1365	#define BFA_FCS_FDMI_CMD_MAX_RETRIES 2
1366
1367	/*
1368	* forward declarations
1369	*/
1370	static void bfa_fcs_lport_fdmi_send_rhba(void *fdmi_cbarg,
1371	struct bfa_fcxp_s *fcxp_alloced);
1372	static void bfa_fcs_lport_fdmi_send_rprt(void *fdmi_cbarg,
1373	struct bfa_fcxp_s *fcxp_alloced);
1374	static void bfa_fcs_lport_fdmi_send_rpa(void *fdmi_cbarg,
1375	struct bfa_fcxp_s *fcxp_alloced);
1376	static void bfa_fcs_lport_fdmi_rhba_response(void *fcsarg,
1377	struct bfa_fcxp_s *fcxp,
1378	void *cbarg,
1379	bfa_status_t req_status,
1380	u32 rsp_len,
1381	u32 resid_len,
1382	struct fchs_s *rsp_fchs);
1383	static void bfa_fcs_lport_fdmi_rprt_response(void *fcsarg,
1384	struct bfa_fcxp_s *fcxp,
1385	void *cbarg,
1386	bfa_status_t req_status,
1387	u32 rsp_len,
1388	u32 resid_len,
1389	struct fchs_s *rsp_fchs);
1390	static void bfa_fcs_lport_fdmi_rpa_response(void *fcsarg,
1391	struct bfa_fcxp_s *fcxp,
1392	void *cbarg,
1393	bfa_status_t req_status,
1394	u32 rsp_len,
1395	u32 resid_len,
1396	struct fchs_s *rsp_fchs);
1397	static void bfa_fcs_lport_fdmi_timeout(void *arg);
1398	static int bfa_fcs_lport_fdmi_build_rhba_pyld(struct bfa_fcs_lport_fdmi_s *fdmi,
1399	u8 *pyld);
1400	static u16 bfa_fcs_lport_fdmi_build_rprt_pyld(struct bfa_fcs_lport_fdmi_s *fdmi,
1401	u8 *pyld);
1402	static u16 bfa_fcs_lport_fdmi_build_rpa_pyld(struct bfa_fcs_lport_fdmi_s *fdmi,
1403	u8 *pyld);
1404	static u16 bfa_fcs_lport_fdmi_build_portattr_block(struct bfa_fcs_lport_fdmi_s *
1405	fdmi, u8 *pyld);
1406	static void bfa_fcs_fdmi_get_hbaattr(struct bfa_fcs_lport_fdmi_s *fdmi,
1407	struct bfa_fcs_fdmi_hba_attr_s *hba_attr);
1408	static void bfa_fcs_fdmi_get_portattr(struct bfa_fcs_lport_fdmi_s *fdmi,
1409	struct bfa_fcs_fdmi_port_attr_s *port_attr);
1410	u32 bfa_fcs_fdmi_convert_speed(enum bfa_port_speed pport_speed);
1411
1412	/*
1413	* fcs_fdmi_sm FCS FDMI state machine
1414	*/
1415
1416	static void bfa_fcs_lport_fdmi_sm_offline(struct bfa_fcs_lport_fdmi_s *fdmi,
1417	enum port_fdmi_event event);
1418	static void bfa_fcs_lport_fdmi_sm_sending_rhba(
1419	struct bfa_fcs_lport_fdmi_s *fdmi,
1420	enum port_fdmi_event event);
1421	static void bfa_fcs_lport_fdmi_sm_rhba(struct bfa_fcs_lport_fdmi_s *fdmi,
1422	enum port_fdmi_event event);
1423	static void bfa_fcs_lport_fdmi_sm_rhba_retry(
1424	struct bfa_fcs_lport_fdmi_s *fdmi,
1425	enum port_fdmi_event event);
1426	static void bfa_fcs_lport_fdmi_sm_sending_rprt(
1427	struct bfa_fcs_lport_fdmi_s *fdmi,
1428	enum port_fdmi_event event);
1429	static void bfa_fcs_lport_fdmi_sm_rprt(struct bfa_fcs_lport_fdmi_s *fdmi,
1430	enum port_fdmi_event event);
1431	static void bfa_fcs_lport_fdmi_sm_rprt_retry(
1432	struct bfa_fcs_lport_fdmi_s *fdmi,
1433	enum port_fdmi_event event);
1434	static void bfa_fcs_lport_fdmi_sm_sending_rpa(
1435	struct bfa_fcs_lport_fdmi_s *fdmi,
1436	enum port_fdmi_event event);
1437	static void bfa_fcs_lport_fdmi_sm_rpa(struct bfa_fcs_lport_fdmi_s *fdmi,
1438	enum port_fdmi_event event);
1439	static void bfa_fcs_lport_fdmi_sm_rpa_retry(
1440	struct bfa_fcs_lport_fdmi_s *fdmi,
1441	enum port_fdmi_event event);
1442	static void bfa_fcs_lport_fdmi_sm_online(struct bfa_fcs_lport_fdmi_s *fdmi,
1443	enum port_fdmi_event event);
1444	static void bfa_fcs_lport_fdmi_sm_disabled(
1445	struct bfa_fcs_lport_fdmi_s *fdmi,
1446	enum port_fdmi_event event);
1447	/*
1448	* Start in offline state - awaiting MS to send start.
1449	*/
1450	static void
1451	bfa_fcs_lport_fdmi_sm_offline(struct bfa_fcs_lport_fdmi_s *fdmi,
1452	enum port_fdmi_event event)
1453	{
1454	struct bfa_fcs_lport_s *port = fdmi->ms->port;
1455
1456	bfa_trc(port->fcs, port->port_cfg.pwwn);
1457	bfa_trc(port->fcs, event);
1458
1459	fdmi->retry_cnt = 0;
1460
1461	switch (event) {
1462	case FDMISM_EVENT_PORT_ONLINE:
1463	if (port->vport) {
1464	/*
1465	* For Vports, register a new port.
1466	*/
1467	bfa_sm_set_state(fdmi,
1468	bfa_fcs_lport_fdmi_sm_sending_rprt);
1469	bfa_fcs_lport_fdmi_send_rprt(fdmi_cbarg: fdmi, NULL);
1470	} else {
1471	/*
1472	* For a base port, we should first register the HBA
1473	* attribute. The HBA attribute also contains the base
1474	* port registration.
1475	*/
1476	bfa_sm_set_state(fdmi,
1477	bfa_fcs_lport_fdmi_sm_sending_rhba);
1478	bfa_fcs_lport_fdmi_send_rhba(fdmi_cbarg: fdmi, NULL);
1479	}
1480	break;
1481
1482	case FDMISM_EVENT_PORT_OFFLINE:
1483	break;
1484
1485	default:
1486	bfa_sm_fault(port->fcs, event);
1487	}
1488	}
1489
1490	static void
1491	bfa_fcs_lport_fdmi_sm_sending_rhba(struct bfa_fcs_lport_fdmi_s *fdmi,
1492	enum port_fdmi_event event)
1493	{
1494	struct bfa_fcs_lport_s *port = fdmi->ms->port;
1495
1496	bfa_trc(port->fcs, port->port_cfg.pwwn);
1497	bfa_trc(port->fcs, event);
1498
1499	switch (event) {
1500	case FDMISM_EVENT_RHBA_SENT:
1501	bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_rhba);
1502	break;
1503
1504	case FDMISM_EVENT_PORT_OFFLINE:
1505	bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline);
1506	bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(port),
1507	wqe: &fdmi->fcxp_wqe);
1508	break;
1509
1510	default:
1511	bfa_sm_fault(port->fcs, event);
1512	}
1513	}
1514
1515	static void
1516	bfa_fcs_lport_fdmi_sm_rhba(struct bfa_fcs_lport_fdmi_s *fdmi,
1517	enum port_fdmi_event event)
1518	{
1519	struct bfa_fcs_lport_s *port = fdmi->ms->port;
1520
1521	bfa_trc(port->fcs, port->port_cfg.pwwn);
1522	bfa_trc(port->fcs, event);
1523
1524	switch (event) {
1525	case FDMISM_EVENT_RSP_ERROR:
1526	/*
1527	* if max retries have not been reached, start timer for a
1528	* delayed retry
1529	*/
1530	if (fdmi->retry_cnt++ < BFA_FCS_FDMI_CMD_MAX_RETRIES) {
1531	bfa_sm_set_state(fdmi,
1532	bfa_fcs_lport_fdmi_sm_rhba_retry);
1533	bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(port),
1534	&fdmi->timer,
1535	bfa_fcs_lport_fdmi_timeout, fdmi,
1536	BFA_FCS_RETRY_TIMEOUT);
1537	} else {
1538	/*
1539	* set state to offline
1540	*/
1541	bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline);
1542	}
1543	break;
1544
1545	case FDMISM_EVENT_RSP_OK:
1546	/*
1547	* Initiate Register Port Attributes
1548	*/
1549	bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_sending_rpa);
1550	fdmi->retry_cnt = 0;
1551	bfa_fcs_lport_fdmi_send_rpa(fdmi_cbarg: fdmi, NULL);
1552	break;
1553
1554	case FDMISM_EVENT_PORT_OFFLINE:
1555	bfa_fcxp_discard(fcxp: fdmi->fcxp);
1556	bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline);
1557	break;
1558
1559	default:
1560	bfa_sm_fault(port->fcs, event);
1561	}
1562	}
1563
1564	static void
1565	bfa_fcs_lport_fdmi_sm_rhba_retry(struct bfa_fcs_lport_fdmi_s *fdmi,
1566	enum port_fdmi_event event)
1567	{
1568	struct bfa_fcs_lport_s *port = fdmi->ms->port;
1569
1570	bfa_trc(port->fcs, port->port_cfg.pwwn);
1571	bfa_trc(port->fcs, event);
1572
1573	switch (event) {
1574	case FDMISM_EVENT_TIMEOUT:
1575	/*
1576	* Retry Timer Expired. Re-send
1577	*/
1578	bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_sending_rhba);
1579	bfa_fcs_lport_fdmi_send_rhba(fdmi_cbarg: fdmi, NULL);
1580	break;
1581
1582	case FDMISM_EVENT_PORT_OFFLINE:
1583	bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline);
1584	bfa_timer_stop(timer: &fdmi->timer);
1585	break;
1586
1587	default:
1588	bfa_sm_fault(port->fcs, event);
1589	}
1590	}
1591
1592	/*
1593	* RPRT : Register Port
1594	*/
1595	static void
1596	bfa_fcs_lport_fdmi_sm_sending_rprt(struct bfa_fcs_lport_fdmi_s *fdmi,
1597	enum port_fdmi_event event)
1598	{
1599	struct bfa_fcs_lport_s *port = fdmi->ms->port;
1600
1601	bfa_trc(port->fcs, port->port_cfg.pwwn);
1602	bfa_trc(port->fcs, event);
1603
1604	switch (event) {
1605	case FDMISM_EVENT_RPRT_SENT:
1606	bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_rprt);
1607	break;
1608
1609	case FDMISM_EVENT_PORT_OFFLINE:
1610	bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline);
1611	bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(port),
1612	wqe: &fdmi->fcxp_wqe);
1613	break;
1614
1615	default:
1616	bfa_sm_fault(port->fcs, event);
1617	}
1618	}
1619
1620	static void
1621	bfa_fcs_lport_fdmi_sm_rprt(struct bfa_fcs_lport_fdmi_s *fdmi,
1622	enum port_fdmi_event event)
1623	{
1624	struct bfa_fcs_lport_s *port = fdmi->ms->port;
1625
1626	bfa_trc(port->fcs, port->port_cfg.pwwn);
1627	bfa_trc(port->fcs, event);
1628
1629	switch (event) {
1630	case FDMISM_EVENT_RSP_ERROR:
1631	/*
1632	* if max retries have not been reached, start timer for a
1633	* delayed retry
1634	*/
1635	if (fdmi->retry_cnt++ < BFA_FCS_FDMI_CMD_MAX_RETRIES) {
1636	bfa_sm_set_state(fdmi,
1637	bfa_fcs_lport_fdmi_sm_rprt_retry);
1638	bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(port),
1639	&fdmi->timer,
1640	bfa_fcs_lport_fdmi_timeout, fdmi,
1641	BFA_FCS_RETRY_TIMEOUT);
1642
1643	} else {
1644	/*
1645	* set state to offline
1646	*/
1647	bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline);
1648	fdmi->retry_cnt = 0;
1649	}
1650	break;
1651
1652	case FDMISM_EVENT_RSP_OK:
1653	fdmi->retry_cnt = 0;
1654	bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_online);
1655	break;
1656
1657	case FDMISM_EVENT_PORT_OFFLINE:
1658	bfa_fcxp_discard(fcxp: fdmi->fcxp);
1659	bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline);
1660	break;
1661
1662	default:
1663	bfa_sm_fault(port->fcs, event);
1664	}
1665	}
1666
1667	static void
1668	bfa_fcs_lport_fdmi_sm_rprt_retry(struct bfa_fcs_lport_fdmi_s *fdmi,
1669	enum port_fdmi_event event)
1670	{
1671	struct bfa_fcs_lport_s *port = fdmi->ms->port;
1672
1673	bfa_trc(port->fcs, port->port_cfg.pwwn);
1674	bfa_trc(port->fcs, event);
1675
1676	switch (event) {
1677	case FDMISM_EVENT_TIMEOUT:
1678	/*
1679	* Retry Timer Expired. Re-send
1680	*/
1681	bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_sending_rprt);
1682	bfa_fcs_lport_fdmi_send_rprt(fdmi_cbarg: fdmi, NULL);
1683	break;
1684
1685	case FDMISM_EVENT_PORT_OFFLINE:
1686	bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline);
1687	bfa_timer_stop(timer: &fdmi->timer);
1688	break;
1689
1690	default:
1691	bfa_sm_fault(port->fcs, event);
1692	}
1693	}
1694
1695	/*
1696	* Register Port Attributes
1697	*/
1698	static void
1699	bfa_fcs_lport_fdmi_sm_sending_rpa(struct bfa_fcs_lport_fdmi_s *fdmi,
1700	enum port_fdmi_event event)
1701	{
1702	struct bfa_fcs_lport_s *port = fdmi->ms->port;
1703
1704	bfa_trc(port->fcs, port->port_cfg.pwwn);
1705	bfa_trc(port->fcs, event);
1706
1707	switch (event) {
1708	case FDMISM_EVENT_RPA_SENT:
1709	bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_rpa);
1710	break;
1711
1712	case FDMISM_EVENT_PORT_OFFLINE:
1713	bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline);
1714	bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(port),
1715	wqe: &fdmi->fcxp_wqe);
1716	break;
1717
1718	default:
1719	bfa_sm_fault(port->fcs, event);
1720	}
1721	}
1722
1723	static void
1724	bfa_fcs_lport_fdmi_sm_rpa(struct bfa_fcs_lport_fdmi_s *fdmi,
1725	enum port_fdmi_event event)
1726	{
1727	struct bfa_fcs_lport_s *port = fdmi->ms->port;
1728
1729	bfa_trc(port->fcs, port->port_cfg.pwwn);
1730	bfa_trc(port->fcs, event);
1731
1732	switch (event) {
1733	case FDMISM_EVENT_RSP_ERROR:
1734	/*
1735	* if max retries have not been reached, start timer for a
1736	* delayed retry
1737	*/
1738	if (fdmi->retry_cnt++ < BFA_FCS_FDMI_CMD_MAX_RETRIES) {
1739	bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_rpa_retry);
1740	bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(port),
1741	&fdmi->timer,
1742	bfa_fcs_lport_fdmi_timeout, fdmi,
1743	BFA_FCS_RETRY_TIMEOUT);
1744	} else {
1745	/*
1746	* set state to offline
1747	*/
1748	bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline);
1749	fdmi->retry_cnt = 0;
1750	}
1751	break;
1752
1753	case FDMISM_EVENT_RSP_OK:
1754	bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_online);
1755	fdmi->retry_cnt = 0;
1756	break;
1757
1758	case FDMISM_EVENT_PORT_OFFLINE:
1759	bfa_fcxp_discard(fcxp: fdmi->fcxp);
1760	bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline);
1761	break;
1762
1763	default:
1764	bfa_sm_fault(port->fcs, event);
1765	}
1766	}
1767
1768	static void
1769	bfa_fcs_lport_fdmi_sm_rpa_retry(struct bfa_fcs_lport_fdmi_s *fdmi,
1770	enum port_fdmi_event event)
1771	{
1772	struct bfa_fcs_lport_s *port = fdmi->ms->port;
1773
1774	bfa_trc(port->fcs, port->port_cfg.pwwn);
1775	bfa_trc(port->fcs, event);
1776
1777	switch (event) {
1778	case FDMISM_EVENT_TIMEOUT:
1779	/*
1780	* Retry Timer Expired. Re-send
1781	*/
1782	bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_sending_rpa);
1783	bfa_fcs_lport_fdmi_send_rpa(fdmi_cbarg: fdmi, NULL);
1784	break;
1785
1786	case FDMISM_EVENT_PORT_OFFLINE:
1787	bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline);
1788	bfa_timer_stop(timer: &fdmi->timer);
1789	break;
1790
1791	default:
1792	bfa_sm_fault(port->fcs, event);
1793	}
1794	}
1795
1796	static void
1797	bfa_fcs_lport_fdmi_sm_online(struct bfa_fcs_lport_fdmi_s *fdmi,
1798	enum port_fdmi_event event)
1799	{
1800	struct bfa_fcs_lport_s *port = fdmi->ms->port;
1801
1802	bfa_trc(port->fcs, port->port_cfg.pwwn);
1803	bfa_trc(port->fcs, event);
1804
1805	switch (event) {
1806	case FDMISM_EVENT_PORT_OFFLINE:
1807	bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline);
1808	break;
1809
1810	default:
1811	bfa_sm_fault(port->fcs, event);
1812	}
1813	}
1814	/*
1815	* FDMI is disabled state.
1816	*/
1817	static void
1818	bfa_fcs_lport_fdmi_sm_disabled(struct bfa_fcs_lport_fdmi_s *fdmi,
1819	enum port_fdmi_event event)
1820	{
1821	struct bfa_fcs_lport_s *port = fdmi->ms->port;
1822
1823	bfa_trc(port->fcs, port->port_cfg.pwwn);
1824	bfa_trc(port->fcs, event);
1825
1826	/* No op State. It can only be enabled at Driver Init. */
1827	}
1828
1829	/*
1830	* RHBA : Register HBA Attributes.
1831	*/
1832	static void
1833	bfa_fcs_lport_fdmi_send_rhba(void *fdmi_cbarg, struct bfa_fcxp_s *fcxp_alloced)
1834	{
1835	struct bfa_fcs_lport_fdmi_s *fdmi = fdmi_cbarg;
1836	struct bfa_fcs_lport_s *port = fdmi->ms->port;
1837	struct fchs_s fchs;
1838	int len, attr_len;
1839	struct bfa_fcxp_s *fcxp;
1840	u8 *pyld;
1841
1842	bfa_trc(port->fcs, port->port_cfg.pwwn);
1843
1844	fcxp = fcxp_alloced ? fcxp_alloced :
1845	bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
1846	if (!fcxp) {
1847	bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &fdmi->fcxp_wqe,
1848	bfa_fcs_lport_fdmi_send_rhba, fdmi, BFA_TRUE);
1849	return;
1850	}
1851	fdmi->fcxp = fcxp;
1852
1853	pyld = bfa_fcxp_get_reqbuf(fcxp);
1854	memset(pyld, 0, FC_MAX_PDUSZ);
1855
1856	len = fc_fdmi_reqhdr_build(fchs: &fchs, pyld, bfa_fcs_lport_get_fcid(port),
1857	FDMI_RHBA);
1858
1859	attr_len =
1860	bfa_fcs_lport_fdmi_build_rhba_pyld(fdmi,
1861	pyld: (u8 *) ((struct ct_hdr_s *) pyld
1862	+ 1));
1863	if (attr_len < 0)
1864	return;
1865
1866	bfa_fcxp_send(fcxp, NULL, vf_id: port->fabric->vf_id, lp_tag: port->lp_tag, cts: BFA_FALSE,
1867	cos: FC_CLASS_3, reqlen: (len + attr_len), fchs: &fchs,
1868	cbfn: bfa_fcs_lport_fdmi_rhba_response, cbarg: (void *)fdmi,
1869	rsp_maxlen: FC_MAX_PDUSZ, FC_FCCT_TOV);
1870
1871	bfa_sm_send_event(fdmi, FDMISM_EVENT_RHBA_SENT);
1872	}
1873
1874	static int
1875	bfa_fcs_lport_fdmi_build_rhba_pyld(struct bfa_fcs_lport_fdmi_s *fdmi, u8 *pyld)
1876	{
1877	struct bfa_fcs_lport_s *port = fdmi->ms->port;
1878	struct bfa_fcs_fdmi_hba_attr_s *fcs_hba_attr;
1879	struct fdmi_rhba_s *rhba = (struct fdmi_rhba_s *) pyld;
1880	struct fdmi_attr_s *attr;
1881	int len;
1882	u8 *curr_ptr;
1883	u16 templen, count;
1884
1885	fcs_hba_attr = kzalloc(size: sizeof(*fcs_hba_attr), GFP_KERNEL);
1886	if (!fcs_hba_attr)
1887	return -ENOMEM;
1888
1889	/*
1890	* get hba attributes
1891	*/
1892	bfa_fcs_fdmi_get_hbaattr(fdmi, hba_attr: fcs_hba_attr);
1893
1894	rhba->hba_id = bfa_fcs_lport_get_pwwn(port);
1895	rhba->port_list.num_ports = cpu_to_be32(1);
1896	rhba->port_list.port_entry = bfa_fcs_lport_get_pwwn(port);
1897
1898	len = sizeof(rhba->hba_id) + sizeof(rhba->port_list);
1899
1900	count = 0;
1901	len += sizeof(rhba->hba_attr_blk.attr_count);
1902
1903	/*
1904	* fill out the invididual entries of the HBA attrib Block
1905	*/
1906	curr_ptr = (u8 *) &rhba->hba_attr_blk.hba_attr;
1907
1908	/*
1909	* Node Name
1910	*/
1911	attr = (struct fdmi_attr_s *) curr_ptr;
1912	attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_NODENAME);
1913	templen = sizeof(wwn_t);
1914	memcpy(attr->value, &bfa_fcs_lport_get_nwwn(port), templen);
1915	curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
1916	len += templen;
1917	count++;
1918	attr->len = cpu_to_be16(templen + sizeof(attr->type) +
1919	sizeof(templen));
1920
1921	/*
1922	* Manufacturer
1923	*/
1924	attr = (struct fdmi_attr_s *) curr_ptr;
1925	attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_MANUFACTURER);
1926	templen = (u16) strlen(fcs_hba_attr->manufacturer);
1927	memcpy(attr->value, fcs_hba_attr->manufacturer, templen);
1928	templen = fc_roundup(templen, sizeof(u32));
1929	curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
1930	len += templen;
1931	count++;
1932	attr->len = cpu_to_be16(templen + sizeof(attr->type) +
1933	sizeof(templen));
1934
1935	/*
1936	* Serial Number
1937	*/
1938	attr = (struct fdmi_attr_s *) curr_ptr;
1939	attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_SERIALNUM);
1940	templen = (u16) strlen(fcs_hba_attr->serial_num);
1941	memcpy(attr->value, fcs_hba_attr->serial_num, templen);
1942	templen = fc_roundup(templen, sizeof(u32));
1943	curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
1944	len += templen;
1945	count++;
1946	attr->len = cpu_to_be16(templen + sizeof(attr->type) +
1947	sizeof(templen));
1948
1949	/*
1950	* Model
1951	*/
1952	attr = (struct fdmi_attr_s *) curr_ptr;
1953	attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_MODEL);
1954	templen = (u16) strlen(fcs_hba_attr->model);
1955	memcpy(attr->value, fcs_hba_attr->model, templen);
1956	templen = fc_roundup(templen, sizeof(u32));
1957	curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
1958	len += templen;
1959	count++;
1960	attr->len = cpu_to_be16(templen + sizeof(attr->type) +
1961	sizeof(templen));
1962
1963	/*
1964	* Model Desc
1965	*/
1966	attr = (struct fdmi_attr_s *) curr_ptr;
1967	attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_MODEL_DESC);
1968	templen = (u16) strlen(fcs_hba_attr->model_desc);
1969	memcpy(attr->value, fcs_hba_attr->model_desc, templen);
1970	templen = fc_roundup(templen, sizeof(u32));
1971	curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
1972	len += templen;
1973	count++;
1974	attr->len = cpu_to_be16(templen + sizeof(attr->type) +
1975	sizeof(templen));
1976
1977	/*
1978	* H/W Version
1979	*/
1980	if (fcs_hba_attr->hw_version[0] != '\0') {
1981	attr = (struct fdmi_attr_s *) curr_ptr;
1982	attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_HW_VERSION);
1983	templen = (u16) strlen(fcs_hba_attr->hw_version);
1984	memcpy(attr->value, fcs_hba_attr->hw_version, templen);
1985	templen = fc_roundup(templen, sizeof(u32));
1986	curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
1987	len += templen;
1988	count++;
1989	attr->len = cpu_to_be16(templen + sizeof(attr->type) +
1990	sizeof(templen));
1991	}
1992
1993	/*
1994	* Driver Version
1995	*/
1996	attr = (struct fdmi_attr_s *) curr_ptr;
1997	attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_DRIVER_VERSION);
1998	templen = (u16) strlen(fcs_hba_attr->driver_version);
1999	memcpy(attr->value, fcs_hba_attr->driver_version, templen);
2000	templen = fc_roundup(templen, sizeof(u32));
2001	curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
2002	len += templen;
2003	count++;
2004	attr->len = cpu_to_be16(templen + sizeof(attr->type) +
2005	sizeof(templen));
2006
2007	/*
2008	* Option Rom Version
2009	*/
2010	if (fcs_hba_attr->option_rom_ver[0] != '\0') {
2011	attr = (struct fdmi_attr_s *) curr_ptr;
2012	attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_ROM_VERSION);
2013	templen = (u16) strlen(fcs_hba_attr->option_rom_ver);
2014	memcpy(attr->value, fcs_hba_attr->option_rom_ver, templen);
2015	templen = fc_roundup(templen, sizeof(u32));
2016	curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
2017	len += templen;
2018	count++;
2019	attr->len = cpu_to_be16(templen + sizeof(attr->type) +
2020	sizeof(templen));
2021	}
2022
2023	attr = (struct fdmi_attr_s *) curr_ptr;
2024	attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_FW_VERSION);
2025	templen = (u16) strlen(fcs_hba_attr->fw_version);
2026	memcpy(attr->value, fcs_hba_attr->fw_version, templen);
2027	templen = fc_roundup(templen, sizeof(u32));
2028	curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
2029	len += templen;
2030	count++;
2031	attr->len = cpu_to_be16(templen + sizeof(attr->type) +
2032	sizeof(templen));
2033
2034	/*
2035	* OS Name
2036	*/
2037	if (fcs_hba_attr->os_name[0] != '\0') {
2038	attr = (struct fdmi_attr_s *) curr_ptr;
2039	attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_OS_NAME);
2040	templen = (u16) strlen(fcs_hba_attr->os_name);
2041	memcpy(attr->value, fcs_hba_attr->os_name, templen);
2042	templen = fc_roundup(templen, sizeof(u32));
2043	curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
2044	len += templen;
2045	count++;
2046	attr->len = cpu_to_be16(templen + sizeof(attr->type) +
2047	sizeof(templen));
2048	}
2049
2050	/*
2051	* MAX_CT_PAYLOAD
2052	*/
2053	attr = (struct fdmi_attr_s *) curr_ptr;
2054	attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_MAX_CT);
2055	templen = sizeof(fcs_hba_attr->max_ct_pyld);
2056	memcpy(attr->value, &fcs_hba_attr->max_ct_pyld, templen);
2057	templen = fc_roundup(templen, sizeof(u32));
2058	curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
2059	len += templen;
2060	count++;
2061	attr->len = cpu_to_be16(templen + sizeof(attr->type) +
2062	sizeof(templen));
2063	/*
2064	* Send extended attributes ( FOS 7.1 support )
2065	*/
2066	if (fdmi->retry_cnt == 0) {
2067	attr = (struct fdmi_attr_s *) curr_ptr;
2068	attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_NODE_SYM_NAME);
2069	templen = sizeof(fcs_hba_attr->node_sym_name);
2070	memcpy(attr->value, &fcs_hba_attr->node_sym_name, templen);
2071	templen = fc_roundup(templen, sizeof(u32));
2072	curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
2073	len += templen;
2074	count++;
2075	attr->len = cpu_to_be16(templen + sizeof(attr->type) +
2076	sizeof(templen));
2077
2078	attr = (struct fdmi_attr_s *) curr_ptr;
2079	attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_VENDOR_ID);
2080	templen = sizeof(fcs_hba_attr->vendor_info);
2081	memcpy(attr->value, &fcs_hba_attr->vendor_info, templen);
2082	templen = fc_roundup(templen, sizeof(u32));
2083	curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
2084	len += templen;
2085	count++;
2086	attr->len = cpu_to_be16(templen + sizeof(attr->type) +
2087	sizeof(templen));
2088
2089	attr = (struct fdmi_attr_s *) curr_ptr;
2090	attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_NUM_PORTS);
2091	templen = sizeof(fcs_hba_attr->num_ports);
2092	memcpy(attr->value, &fcs_hba_attr->num_ports, templen);
2093	templen = fc_roundup(templen, sizeof(u32));
2094	curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
2095	len += templen;
2096	count++;
2097	attr->len = cpu_to_be16(templen + sizeof(attr->type) +
2098	sizeof(templen));
2099
2100	attr = (struct fdmi_attr_s *) curr_ptr;
2101	attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_FABRIC_NAME);
2102	templen = sizeof(fcs_hba_attr->fabric_name);
2103	memcpy(attr->value, &fcs_hba_attr->fabric_name, templen);
2104	templen = fc_roundup(templen, sizeof(u32));
2105	curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
2106	len += templen;
2107	count++;
2108	attr->len = cpu_to_be16(templen + sizeof(attr->type) +
2109	sizeof(templen));
2110
2111	attr = (struct fdmi_attr_s *) curr_ptr;
2112	attr->type = cpu_to_be16(FDMI_HBA_ATTRIB_BIOS_VER);
2113	templen = sizeof(fcs_hba_attr->bios_ver);
2114	memcpy(attr->value, &fcs_hba_attr->bios_ver, templen);
2115	templen = fc_roundup(attr->len, sizeof(u32));
2116	curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
2117	len += templen;
2118	count++;
2119	attr->len = cpu_to_be16(templen + sizeof(attr->type) +
2120	sizeof(templen));
2121	}
2122
2123	/*
2124	* Update size of payload
2125	*/
2126	len += ((sizeof(attr->type) + sizeof(attr->len)) * count);
2127
2128	rhba->hba_attr_blk.attr_count = cpu_to_be32(count);
2129
2130	kfree(objp: fcs_hba_attr);
2131
2132	return len;
2133	}
2134
2135	static void
2136	bfa_fcs_lport_fdmi_rhba_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
2137	void *cbarg, bfa_status_t req_status,
2138	u32 rsp_len, u32 resid_len,
2139	struct fchs_s *rsp_fchs)
2140	{
2141	struct bfa_fcs_lport_fdmi_s *fdmi =
2142	(struct bfa_fcs_lport_fdmi_s *) cbarg;
2143	struct bfa_fcs_lport_s *port = fdmi->ms->port;
2144	struct ct_hdr_s *cthdr = NULL;
2145
2146	bfa_trc(port->fcs, port->port_cfg.pwwn);
2147
2148	/*
2149	* Sanity Checks
2150	*/
2151	if (req_status != BFA_STATUS_OK) {
2152	bfa_trc(port->fcs, req_status);
2153	bfa_sm_send_event(fdmi, FDMISM_EVENT_RSP_ERROR);
2154	return;
2155	}
2156
2157	cthdr = (struct ct_hdr_s *) BFA_FCXP_RSP_PLD(fcxp);
2158	cthdr->cmd_rsp_code = be16_to_cpu(cthdr->cmd_rsp_code);
2159
2160	if (cthdr->cmd_rsp_code == CT_RSP_ACCEPT) {
2161	bfa_sm_send_event(fdmi, FDMISM_EVENT_RSP_OK);
2162	return;
2163	}
2164
2165	bfa_trc(port->fcs, cthdr->reason_code);
2166	bfa_trc(port->fcs, cthdr->exp_code);
2167	bfa_sm_send_event(fdmi, FDMISM_EVENT_RSP_ERROR);
2168	}
2169
2170	/*
2171	* RPRT : Register Port
2172	*/
2173	static void
2174	bfa_fcs_lport_fdmi_send_rprt(void *fdmi_cbarg, struct bfa_fcxp_s *fcxp_alloced)
2175	{
2176	struct bfa_fcs_lport_fdmi_s *fdmi = fdmi_cbarg;
2177	struct bfa_fcs_lport_s *port = fdmi->ms->port;
2178	struct fchs_s fchs;
2179	u16 len, attr_len;
2180	struct bfa_fcxp_s *fcxp;
2181	u8 *pyld;
2182
2183	bfa_trc(port->fcs, port->port_cfg.pwwn);
2184
2185	fcxp = fcxp_alloced ? fcxp_alloced :
2186	bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
2187	if (!fcxp) {
2188	bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &fdmi->fcxp_wqe,
2189	bfa_fcs_lport_fdmi_send_rprt, fdmi, BFA_TRUE);
2190	return;
2191	}
2192	fdmi->fcxp = fcxp;
2193
2194	pyld = bfa_fcxp_get_reqbuf(fcxp);
2195	memset(pyld, 0, FC_MAX_PDUSZ);
2196
2197	len = fc_fdmi_reqhdr_build(fchs: &fchs, pyld, bfa_fcs_lport_get_fcid(port),
2198	FDMI_RPRT);
2199
2200	attr_len =
2201	bfa_fcs_lport_fdmi_build_rprt_pyld(fdmi,
2202	pyld: (u8 *) ((struct ct_hdr_s *) pyld
2203	+ 1));
2204
2205	bfa_fcxp_send(fcxp, NULL, vf_id: port->fabric->vf_id, lp_tag: port->lp_tag, cts: BFA_FALSE,
2206	cos: FC_CLASS_3, reqlen: len + attr_len, fchs: &fchs,
2207	cbfn: bfa_fcs_lport_fdmi_rprt_response, cbarg: (void *)fdmi,
2208	rsp_maxlen: FC_MAX_PDUSZ, FC_FCCT_TOV);
2209
2210	bfa_sm_send_event(fdmi, FDMISM_EVENT_RPRT_SENT);
2211	}
2212
2213	/*
2214	* This routine builds Port Attribute Block that used in RPA, RPRT commands.
2215	*/
2216	static u16
2217	bfa_fcs_lport_fdmi_build_portattr_block(struct bfa_fcs_lport_fdmi_s *fdmi,
2218	u8 *pyld)
2219	{
2220	struct bfa_fcs_fdmi_port_attr_s fcs_port_attr;
2221	struct fdmi_port_attr_s *port_attrib = (struct fdmi_port_attr_s *) pyld;
2222	struct fdmi_attr_s *attr;
2223	u8 *curr_ptr;
2224	u16 len;
2225	u8 count = 0;
2226	u16 templen;
2227
2228	/*
2229	* get port attributes
2230	*/
2231	bfa_fcs_fdmi_get_portattr(fdmi, port_attr: &fcs_port_attr);
2232
2233	len = sizeof(port_attrib->attr_count);
2234
2235	/*
2236	* fill out the invididual entries
2237	*/
2238	curr_ptr = (u8 *) &port_attrib->port_attr;
2239
2240	/*
2241	* FC4 Types
2242	*/
2243	attr = (struct fdmi_attr_s *) curr_ptr;
2244	attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_FC4_TYPES);
2245	templen = sizeof(fcs_port_attr.supp_fc4_types);
2246	memcpy(attr->value, fcs_port_attr.supp_fc4_types, templen);
2247	curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
2248	len += templen;
2249	++count;
2250	attr->len =
2251	cpu_to_be16(templen + sizeof(attr->type) +
2252	sizeof(templen));
2253
2254	/*
2255	* Supported Speed
2256	*/
2257	attr = (struct fdmi_attr_s *) curr_ptr;
2258	attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_SUPP_SPEED);
2259	templen = sizeof(fcs_port_attr.supp_speed);
2260	memcpy(attr->value, &fcs_port_attr.supp_speed, templen);
2261	curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
2262	len += templen;
2263	++count;
2264	attr->len =
2265	cpu_to_be16(templen + sizeof(attr->type) +
2266	sizeof(templen));
2267
2268	/*
2269	* current Port Speed
2270	*/
2271	attr = (struct fdmi_attr_s *) curr_ptr;
2272	attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_PORT_SPEED);
2273	templen = sizeof(fcs_port_attr.curr_speed);
2274	memcpy(attr->value, &fcs_port_attr.curr_speed, templen);
2275	curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
2276	len += templen;
2277	++count;
2278	attr->len = cpu_to_be16(templen + sizeof(attr->type) +
2279	sizeof(templen));
2280
2281	/*
2282	* max frame size
2283	*/
2284	attr = (struct fdmi_attr_s *) curr_ptr;
2285	attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_FRAME_SIZE);
2286	templen = sizeof(fcs_port_attr.max_frm_size);
2287	memcpy(attr->value, &fcs_port_attr.max_frm_size, templen);
2288	curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
2289	len += templen;
2290	++count;
2291	attr->len = cpu_to_be16(templen + sizeof(attr->type) +
2292	sizeof(templen));
2293
2294	/*
2295	* OS Device Name
2296	*/
2297	if (fcs_port_attr.os_device_name[0] != '\0') {
2298	attr = (struct fdmi_attr_s *) curr_ptr;
2299	attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_DEV_NAME);
2300	templen = (u16) strlen(fcs_port_attr.os_device_name);
2301	memcpy(attr->value, fcs_port_attr.os_device_name, templen);
2302	templen = fc_roundup(templen, sizeof(u32));
2303	curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
2304	len += templen;
2305	++count;
2306	attr->len = cpu_to_be16(templen + sizeof(attr->type) +
2307	sizeof(templen));
2308	}
2309	/*
2310	* Host Name
2311	*/
2312	if (fcs_port_attr.host_name[0] != '\0') {
2313	attr = (struct fdmi_attr_s *) curr_ptr;
2314	attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_HOST_NAME);
2315	templen = (u16) strlen(fcs_port_attr.host_name);
2316	memcpy(attr->value, fcs_port_attr.host_name, templen);
2317	templen = fc_roundup(templen, sizeof(u32));
2318	curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
2319	len += templen;
2320	++count;
2321	attr->len = cpu_to_be16(templen + sizeof(attr->type) +
2322	sizeof(templen));
2323	}
2324
2325	if (fdmi->retry_cnt == 0) {
2326	attr = (struct fdmi_attr_s *) curr_ptr;
2327	attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_NODE_NAME);
2328	templen = sizeof(fcs_port_attr.node_name);
2329	memcpy(attr->value, &fcs_port_attr.node_name, templen);
2330	templen = fc_roundup(templen, sizeof(u32));
2331	curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
2332	len += templen;
2333	++count;
2334	attr->len = cpu_to_be16(templen + sizeof(attr->type) +
2335	sizeof(templen));
2336
2337	attr = (struct fdmi_attr_s *) curr_ptr;
2338	attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_PORT_NAME);
2339	templen = sizeof(fcs_port_attr.port_name);
2340	memcpy(attr->value, &fcs_port_attr.port_name, templen);
2341	templen = fc_roundup(templen, sizeof(u32));
2342	curr_ptr += sizeof(attr->type) + sizeof(attr->len) + templen;
2343	len += templen;
2344	++count;
2345	attr->len = cpu_to_be16(templen + sizeof(attr->type) +
2346	sizeof(templen));
2347
2348	if (fcs_port_attr.port_sym_name.symname[0] != '\0') {
2349	attr = (struct fdmi_attr_s *) curr_ptr;
2350	attr->type =
2351	cpu_to_be16(FDMI_PORT_ATTRIB_PORT_SYM_NAME);
2352	templen = sizeof(fcs_port_attr.port_sym_name);
2353	memcpy(attr->value,
2354	&fcs_port_attr.port_sym_name, templen);
2355	templen = fc_roundup(templen, sizeof(u32));
2356	curr_ptr += sizeof(attr->type) +
2357	sizeof(templen) + templen;
2358	len += templen;
2359	++count;
2360	attr->len = cpu_to_be16(templen +
2361	sizeof(attr->type) + sizeof(templen));
2362	}
2363
2364	attr = (struct fdmi_attr_s *) curr_ptr;
2365	attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_PORT_TYPE);
2366	templen = sizeof(fcs_port_attr.port_type);
2367	memcpy(attr->value, &fcs_port_attr.port_type, templen);
2368	templen = fc_roundup(templen, sizeof(u32));
2369	curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
2370	len += templen;
2371	++count;
2372	attr->len = cpu_to_be16(templen + sizeof(attr->type) +
2373	sizeof(templen));
2374
2375	attr = (struct fdmi_attr_s *) curr_ptr;
2376	attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_SUPP_COS);
2377	templen = sizeof(fcs_port_attr.scos);
2378	memcpy(attr->value, &fcs_port_attr.scos, templen);
2379	templen = fc_roundup(templen, sizeof(u32));
2380	curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
2381	len += templen;
2382	++count;
2383	attr->len = cpu_to_be16(templen + sizeof(attr->type) +
2384	sizeof(templen));
2385
2386	attr = (struct fdmi_attr_s *) curr_ptr;
2387	attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_PORT_FAB_NAME);
2388	templen = sizeof(fcs_port_attr.port_fabric_name);
2389	memcpy(attr->value, &fcs_port_attr.port_fabric_name, templen);
2390	templen = fc_roundup(templen, sizeof(u32));
2391	curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
2392	len += templen;
2393	++count;
2394	attr->len = cpu_to_be16(templen + sizeof(attr->type) +
2395	sizeof(templen));
2396
2397	attr = (struct fdmi_attr_s *) curr_ptr;
2398	attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_PORT_FC4_TYPE);
2399	templen = sizeof(fcs_port_attr.port_act_fc4_type);
2400	memcpy(attr->value, fcs_port_attr.port_act_fc4_type,
2401	templen);
2402	templen = fc_roundup(templen, sizeof(u32));
2403	curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
2404	len += templen;
2405	++count;
2406	attr->len = cpu_to_be16(templen + sizeof(attr->type) +
2407	sizeof(templen));
2408
2409	attr = (struct fdmi_attr_s *) curr_ptr;
2410	attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_PORT_STATE);
2411	templen = sizeof(fcs_port_attr.port_state);
2412	memcpy(attr->value, &fcs_port_attr.port_state, templen);
2413	templen = fc_roundup(templen, sizeof(u32));
2414	curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
2415	len += templen;
2416	++count;
2417	attr->len = cpu_to_be16(templen + sizeof(attr->type) +
2418	sizeof(templen));
2419
2420	attr = (struct fdmi_attr_s *) curr_ptr;
2421	attr->type = cpu_to_be16(FDMI_PORT_ATTRIB_PORT_NUM_RPRT);
2422	templen = sizeof(fcs_port_attr.num_ports);
2423	memcpy(attr->value, &fcs_port_attr.num_ports, templen);
2424	templen = fc_roundup(templen, sizeof(u32));
2425	curr_ptr += sizeof(attr->type) + sizeof(templen) + templen;
2426	len += templen;
2427	++count;
2428	attr->len = cpu_to_be16(templen + sizeof(attr->type) +
2429	sizeof(templen));
2430	}
2431
2432	/*
2433	* Update size of payload
2434	*/
2435	port_attrib->attr_count = cpu_to_be32(count);
2436	len += ((sizeof(attr->type) + sizeof(attr->len)) * count);
2437	return len;
2438	}
2439
2440	static u16
2441	bfa_fcs_lport_fdmi_build_rprt_pyld(struct bfa_fcs_lport_fdmi_s *fdmi, u8 *pyld)
2442	{
2443	struct bfa_fcs_lport_s *port = fdmi->ms->port;
2444	struct fdmi_rprt_s *rprt = (struct fdmi_rprt_s *) pyld;
2445	u16 len;
2446
2447	rprt->hba_id = bfa_fcs_lport_get_pwwn(bfa_fcs_get_base_port(port->fcs));
2448	rprt->port_name = bfa_fcs_lport_get_pwwn(port);
2449
2450	len = bfa_fcs_lport_fdmi_build_portattr_block(fdmi,
2451	pyld: (u8 *) &rprt->port_attr_blk);
2452
2453	len += sizeof(rprt->hba_id) + sizeof(rprt->port_name);
2454
2455	return len;
2456	}
2457
2458	static void
2459	bfa_fcs_lport_fdmi_rprt_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
2460	void *cbarg, bfa_status_t req_status,
2461	u32 rsp_len, u32 resid_len,
2462	struct fchs_s *rsp_fchs)
2463	{
2464	struct bfa_fcs_lport_fdmi_s *fdmi =
2465	(struct bfa_fcs_lport_fdmi_s *) cbarg;
2466	struct bfa_fcs_lport_s *port = fdmi->ms->port;
2467	struct ct_hdr_s *cthdr = NULL;
2468
2469	bfa_trc(port->fcs, port->port_cfg.pwwn);
2470
2471	/*
2472	* Sanity Checks
2473	*/
2474	if (req_status != BFA_STATUS_OK) {
2475	bfa_trc(port->fcs, req_status);
2476	bfa_sm_send_event(fdmi, FDMISM_EVENT_RSP_ERROR);
2477	return;
2478	}
2479
2480	cthdr = (struct ct_hdr_s *) BFA_FCXP_RSP_PLD(fcxp);
2481	cthdr->cmd_rsp_code = be16_to_cpu(cthdr->cmd_rsp_code);
2482
2483	if (cthdr->cmd_rsp_code == CT_RSP_ACCEPT) {
2484	bfa_sm_send_event(fdmi, FDMISM_EVENT_RSP_OK);
2485	return;
2486	}
2487
2488	bfa_trc(port->fcs, cthdr->reason_code);
2489	bfa_trc(port->fcs, cthdr->exp_code);
2490	bfa_sm_send_event(fdmi, FDMISM_EVENT_RSP_ERROR);
2491	}
2492
2493	/*
2494	* RPA : Register Port Attributes.
2495	*/
2496	static void
2497	bfa_fcs_lport_fdmi_send_rpa(void *fdmi_cbarg, struct bfa_fcxp_s *fcxp_alloced)
2498	{
2499	struct bfa_fcs_lport_fdmi_s *fdmi = fdmi_cbarg;
2500	struct bfa_fcs_lport_s *port = fdmi->ms->port;
2501	struct fchs_s fchs;
2502	u16 len, attr_len;
2503	struct bfa_fcxp_s *fcxp;
2504	u8 *pyld;
2505
2506	bfa_trc(port->fcs, port->port_cfg.pwwn);
2507
2508	fcxp = fcxp_alloced ? fcxp_alloced :
2509	bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
2510	if (!fcxp) {
2511	bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &fdmi->fcxp_wqe,
2512	bfa_fcs_lport_fdmi_send_rpa, fdmi, BFA_TRUE);
2513	return;
2514	}
2515	fdmi->fcxp = fcxp;
2516
2517	pyld = bfa_fcxp_get_reqbuf(fcxp);
2518	memset(pyld, 0, FC_MAX_PDUSZ);
2519
2520	len = fc_fdmi_reqhdr_build(fchs: &fchs, pyld, bfa_fcs_lport_get_fcid(port),
2521	FDMI_RPA);
2522
2523	attr_len = bfa_fcs_lport_fdmi_build_rpa_pyld(fdmi,
2524	pyld: (u8 *) ((struct ct_hdr_s *) pyld + 1));
2525
2526	bfa_fcxp_send(fcxp, NULL, vf_id: port->fabric->vf_id, lp_tag: port->lp_tag, cts: BFA_FALSE,
2527	cos: FC_CLASS_3, reqlen: len + attr_len, fchs: &fchs,
2528	cbfn: bfa_fcs_lport_fdmi_rpa_response, cbarg: (void *)fdmi,
2529	rsp_maxlen: FC_MAX_PDUSZ, FC_FCCT_TOV);
2530
2531	bfa_sm_send_event(fdmi, FDMISM_EVENT_RPA_SENT);
2532	}
2533
2534	static u16
2535	bfa_fcs_lport_fdmi_build_rpa_pyld(struct bfa_fcs_lport_fdmi_s *fdmi, u8 *pyld)
2536	{
2537	struct bfa_fcs_lport_s *port = fdmi->ms->port;
2538	struct fdmi_rpa_s *rpa = (struct fdmi_rpa_s *) pyld;
2539	u16 len;
2540
2541	rpa->port_name = bfa_fcs_lport_get_pwwn(port);
2542
2543	len = bfa_fcs_lport_fdmi_build_portattr_block(fdmi,
2544	pyld: (u8 *) &rpa->port_attr_blk);
2545
2546	len += sizeof(rpa->port_name);
2547
2548	return len;
2549	}
2550
2551	static void
2552	bfa_fcs_lport_fdmi_rpa_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
2553	void *cbarg, bfa_status_t req_status, u32 rsp_len,
2554	u32 resid_len, struct fchs_s *rsp_fchs)
2555	{
2556	struct bfa_fcs_lport_fdmi_s *fdmi =
2557	(struct bfa_fcs_lport_fdmi_s *) cbarg;
2558	struct bfa_fcs_lport_s *port = fdmi->ms->port;
2559	struct ct_hdr_s *cthdr = NULL;
2560
2561	bfa_trc(port->fcs, port->port_cfg.pwwn);
2562
2563	/*
2564	* Sanity Checks
2565	*/
2566	if (req_status != BFA_STATUS_OK) {
2567	bfa_trc(port->fcs, req_status);
2568	bfa_sm_send_event(fdmi, FDMISM_EVENT_RSP_ERROR);
2569	return;
2570	}
2571
2572	cthdr = (struct ct_hdr_s *) BFA_FCXP_RSP_PLD(fcxp);
2573	cthdr->cmd_rsp_code = be16_to_cpu(cthdr->cmd_rsp_code);
2574
2575	if (cthdr->cmd_rsp_code == CT_RSP_ACCEPT) {
2576	bfa_sm_send_event(fdmi, FDMISM_EVENT_RSP_OK);
2577	return;
2578	}
2579
2580	bfa_trc(port->fcs, cthdr->reason_code);
2581	bfa_trc(port->fcs, cthdr->exp_code);
2582	bfa_sm_send_event(fdmi, FDMISM_EVENT_RSP_ERROR);
2583	}
2584
2585	static void
2586	bfa_fcs_lport_fdmi_timeout(void *arg)
2587	{
2588	struct bfa_fcs_lport_fdmi_s *fdmi = (struct bfa_fcs_lport_fdmi_s *) arg;
2589
2590	bfa_sm_send_event(fdmi, FDMISM_EVENT_TIMEOUT);
2591	}
2592
2593	static void
2594	bfa_fcs_fdmi_get_hbaattr(struct bfa_fcs_lport_fdmi_s *fdmi,
2595	struct bfa_fcs_fdmi_hba_attr_s *hba_attr)
2596	{
2597	struct bfa_fcs_lport_s *port = fdmi->ms->port;
2598	struct bfa_fcs_driver_info_s *driver_info = &port->fcs->driver_info;
2599	struct bfa_fcs_fdmi_port_attr_s fcs_port_attr;
2600
2601	memset(hba_attr, 0, sizeof(struct bfa_fcs_fdmi_hba_attr_s));
2602
2603	bfa_ioc_get_adapter_manufacturer(ioc: &port->fcs->bfa->ioc,
2604	manufacturer: hba_attr->manufacturer);
2605	bfa_ioc_get_adapter_serial_num(ioc: &port->fcs->bfa->ioc,
2606	serial_num: hba_attr->serial_num);
2607	bfa_ioc_get_adapter_model(ioc: &port->fcs->bfa->ioc,
2608	model: hba_attr->model);
2609	bfa_ioc_get_adapter_model(ioc: &port->fcs->bfa->ioc,
2610	model: hba_attr->model_desc);
2611	bfa_ioc_get_pci_chip_rev(ioc: &port->fcs->bfa->ioc,
2612	chip_rev: hba_attr->hw_version);
2613	bfa_ioc_get_adapter_optrom_ver(ioc: &port->fcs->bfa->ioc,
2614	optrom_ver: hba_attr->option_rom_ver);
2615	bfa_ioc_get_adapter_fw_ver(ioc: &port->fcs->bfa->ioc,
2616	fw_ver: hba_attr->fw_version);
2617
2618	strscpy(hba_attr->driver_version, (char *)driver_info->version,
2619	sizeof(hba_attr->driver_version));
2620
2621	strscpy(hba_attr->os_name, driver_info->host_os_name,
2622	sizeof(hba_attr->os_name));
2623
2624	/*
2625	* If there is a patch level, append it
2626	* to the os name along with a separator
2627	*/
2628	if (driver_info->host_os_patch[0] != '\0') {
2629	strlcat(p: hba_attr->os_name, BFA_FCS_PORT_SYMBNAME_SEPARATOR,
2630	avail: sizeof(hba_attr->os_name));
2631	strlcat(p: hba_attr->os_name, q: driver_info->host_os_patch,
2632	avail: sizeof(hba_attr->os_name));
2633	}
2634
2635	/* Retrieve the max frame size from the port attr */
2636	bfa_fcs_fdmi_get_portattr(fdmi, port_attr: &fcs_port_attr);
2637	hba_attr->max_ct_pyld = fcs_port_attr.max_frm_size;
2638
2639	strscpy(hba_attr->node_sym_name.symname,
2640	port->port_cfg.node_sym_name.symname, BFA_SYMNAME_MAXLEN);
2641	strcpy(p: hba_attr->vendor_info, q: "QLogic");
2642	hba_attr->num_ports =
2643	cpu_to_be32(bfa_ioc_get_nports(&port->fcs->bfa->ioc));
2644	hba_attr->fabric_name = port->fabric->lps->pr_nwwn;
2645	strscpy(hba_attr->bios_ver, hba_attr->option_rom_ver, BFA_VERSION_LEN);
2646
2647	}
2648
2649	static void
2650	bfa_fcs_fdmi_get_portattr(struct bfa_fcs_lport_fdmi_s *fdmi,
2651	struct bfa_fcs_fdmi_port_attr_s *port_attr)
2652	{
2653	struct bfa_fcs_lport_s *port = fdmi->ms->port;
2654	struct bfa_fcs_driver_info_s *driver_info = &port->fcs->driver_info;
2655	struct bfa_port_attr_s pport_attr;
2656	struct bfa_lport_attr_s lport_attr;
2657
2658	memset(port_attr, 0, sizeof(struct bfa_fcs_fdmi_port_attr_s));
2659
2660	/*
2661	* get pport attributes from hal
2662	*/
2663	bfa_fcport_get_attr(bfa: port->fcs->bfa, attr: &pport_attr);
2664
2665	/*
2666	* get FC4 type Bitmask
2667	*/
2668	fc_get_fc4type_bitmask(fc4_type: FC_TYPE_FCP, bit_mask: port_attr->supp_fc4_types);
2669
2670	/*
2671	* Supported Speeds
2672	*/
2673	switch (pport_attr.speed_supported) {
2674	case BFA_PORT_SPEED_16GBPS:
2675	port_attr->supp_speed =
2676	cpu_to_be32(BFA_FCS_FDMI_SUPP_SPEEDS_16G);
2677	break;
2678
2679	case BFA_PORT_SPEED_10GBPS:
2680	port_attr->supp_speed =
2681	cpu_to_be32(BFA_FCS_FDMI_SUPP_SPEEDS_10G);
2682	break;
2683
2684	case BFA_PORT_SPEED_8GBPS:
2685	port_attr->supp_speed =
2686	cpu_to_be32(BFA_FCS_FDMI_SUPP_SPEEDS_8G);
2687	break;
2688
2689	case BFA_PORT_SPEED_4GBPS:
2690	port_attr->supp_speed =
2691	cpu_to_be32(BFA_FCS_FDMI_SUPP_SPEEDS_4G);
2692	break;
2693
2694	default:
2695	bfa_sm_fault(port->fcs, pport_attr.speed_supported);
2696	}
2697
2698	/*
2699	* Current Speed
2700	*/
2701	port_attr->curr_speed = cpu_to_be32(
2702	bfa_fcs_fdmi_convert_speed(pport_attr.speed));
2703
2704	/*
2705	* Max PDU Size.
2706	*/
2707	port_attr->max_frm_size = cpu_to_be32(pport_attr.pport_cfg.maxfrsize);
2708
2709	/*
2710	* OS device Name
2711	*/
2712	strscpy(port_attr->os_device_name, driver_info->os_device_name,
2713	sizeof(port_attr->os_device_name));
2714
2715	/*
2716	* Host name
2717	*/
2718	strscpy(port_attr->host_name, driver_info->host_machine_name,
2719	sizeof(port_attr->host_name));
2720
2721	port_attr->node_name = bfa_fcs_lport_get_nwwn(port);
2722	port_attr->port_name = bfa_fcs_lport_get_pwwn(port);
2723
2724	strscpy(port_attr->port_sym_name.symname,
2725	bfa_fcs_lport_get_psym_name(port).symname, BFA_SYMNAME_MAXLEN);
2726	bfa_fcs_lport_get_attr(port, port_attr: &lport_attr);
2727	port_attr->port_type = cpu_to_be32(lport_attr.port_type);
2728	port_attr->scos = pport_attr.cos_supported;
2729	port_attr->port_fabric_name = port->fabric->lps->pr_nwwn;
2730	fc_get_fc4type_bitmask(fc4_type: FC_TYPE_FCP, bit_mask: port_attr->port_act_fc4_type);
2731	port_attr->port_state = cpu_to_be32(pport_attr.port_state);
2732	port_attr->num_ports = cpu_to_be32(port->num_rports);
2733	}
2734
2735	/*
2736	* Convert BFA speed to FDMI format.
2737	*/
2738	u32
2739	bfa_fcs_fdmi_convert_speed(bfa_port_speed_t pport_speed)
2740	{
2741	u32 ret;
2742
2743	switch (pport_speed) {
2744	case BFA_PORT_SPEED_1GBPS:
2745	case BFA_PORT_SPEED_2GBPS:
2746	ret = pport_speed;
2747	break;
2748
2749	case BFA_PORT_SPEED_4GBPS:
2750	ret = FDMI_TRANS_SPEED_4G;
2751	break;
2752
2753	case BFA_PORT_SPEED_8GBPS:
2754	ret = FDMI_TRANS_SPEED_8G;
2755	break;
2756
2757	case BFA_PORT_SPEED_10GBPS:
2758	ret = FDMI_TRANS_SPEED_10G;
2759	break;
2760
2761	case BFA_PORT_SPEED_16GBPS:
2762	ret = FDMI_TRANS_SPEED_16G;
2763	break;
2764
2765	default:
2766	ret = FDMI_TRANS_SPEED_UNKNOWN;
2767	}
2768	return ret;
2769	}
2770
2771	void
2772	bfa_fcs_lport_fdmi_init(struct bfa_fcs_lport_ms_s *ms)
2773	{
2774	struct bfa_fcs_lport_fdmi_s *fdmi = &ms->fdmi;
2775
2776	fdmi->ms = ms;
2777	if (ms->port->fcs->fdmi_enabled)
2778	bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_offline);
2779	else
2780	bfa_sm_set_state(fdmi, bfa_fcs_lport_fdmi_sm_disabled);
2781	}
2782
2783	void
2784	bfa_fcs_lport_fdmi_offline(struct bfa_fcs_lport_ms_s *ms)
2785	{
2786	struct bfa_fcs_lport_fdmi_s *fdmi = &ms->fdmi;
2787
2788	fdmi->ms = ms;
2789	bfa_sm_send_event(fdmi, FDMISM_EVENT_PORT_OFFLINE);
2790	}
2791
2792	void
2793	bfa_fcs_lport_fdmi_online(struct bfa_fcs_lport_ms_s *ms)
2794	{
2795	struct bfa_fcs_lport_fdmi_s *fdmi = &ms->fdmi;
2796
2797	fdmi->ms = ms;
2798	bfa_sm_send_event(fdmi, FDMISM_EVENT_PORT_ONLINE);
2799	}
2800
2801	#define BFA_FCS_MS_CMD_MAX_RETRIES 2
2802
2803	/*
2804	* forward declarations
2805	*/
2806	static void bfa_fcs_lport_ms_send_plogi(void *ms_cbarg,
2807	struct bfa_fcxp_s *fcxp_alloced);
2808	static void bfa_fcs_lport_ms_timeout(void *arg);
2809	static void bfa_fcs_lport_ms_plogi_response(void *fcsarg,
2810	struct bfa_fcxp_s *fcxp,
2811	void *cbarg,
2812	bfa_status_t req_status,
2813	u32 rsp_len,
2814	u32 resid_len,
2815	struct fchs_s *rsp_fchs);
2816
2817	static void bfa_fcs_lport_ms_send_gmal(void *ms_cbarg,
2818	struct bfa_fcxp_s *fcxp_alloced);
2819	static void bfa_fcs_lport_ms_gmal_response(void *fcsarg,
2820	struct bfa_fcxp_s *fcxp,
2821	void *cbarg,
2822	bfa_status_t req_status,
2823	u32 rsp_len,
2824	u32 resid_len,
2825	struct fchs_s *rsp_fchs);
2826	static void bfa_fcs_lport_ms_send_gfn(void *ms_cbarg,
2827	struct bfa_fcxp_s *fcxp_alloced);
2828	static void bfa_fcs_lport_ms_gfn_response(void *fcsarg,
2829	struct bfa_fcxp_s *fcxp,
2830	void *cbarg,
2831	bfa_status_t req_status,
2832	u32 rsp_len,
2833	u32 resid_len,
2834	struct fchs_s *rsp_fchs);
2835	/*
2836	* fcs_ms_sm FCS MS state machine
2837	*/
2838
2839	static void bfa_fcs_lport_ms_sm_offline(struct bfa_fcs_lport_ms_s *ms,
2840	enum port_ms_event event);
2841	static void bfa_fcs_lport_ms_sm_plogi_sending(struct bfa_fcs_lport_ms_s *ms,
2842	enum port_ms_event event);
2843	static void bfa_fcs_lport_ms_sm_plogi(struct bfa_fcs_lport_ms_s *ms,
2844	enum port_ms_event event);
2845	static void bfa_fcs_lport_ms_sm_plogi_retry(struct bfa_fcs_lport_ms_s *ms,
2846	enum port_ms_event event);
2847	static void bfa_fcs_lport_ms_sm_gmal_sending(struct bfa_fcs_lport_ms_s *ms,
2848	enum port_ms_event event);
2849	static void bfa_fcs_lport_ms_sm_gmal(struct bfa_fcs_lport_ms_s *ms,
2850	enum port_ms_event event);
2851	static void bfa_fcs_lport_ms_sm_gmal_retry(struct bfa_fcs_lport_ms_s *ms,
2852	enum port_ms_event event);
2853	static void bfa_fcs_lport_ms_sm_gfn_sending(struct bfa_fcs_lport_ms_s *ms,
2854	enum port_ms_event event);
2855	static void bfa_fcs_lport_ms_sm_gfn(struct bfa_fcs_lport_ms_s *ms,
2856	enum port_ms_event event);
2857	static void bfa_fcs_lport_ms_sm_gfn_retry(struct bfa_fcs_lport_ms_s *ms,
2858	enum port_ms_event event);
2859	static void bfa_fcs_lport_ms_sm_online(struct bfa_fcs_lport_ms_s *ms,
2860	enum port_ms_event event);
2861	/*
2862	* Start in offline state - awaiting NS to send start.
2863	*/
2864	static void
2865	bfa_fcs_lport_ms_sm_offline(struct bfa_fcs_lport_ms_s *ms,
2866	enum port_ms_event event)
2867	{
2868	bfa_trc(ms->port->fcs, ms->port->port_cfg.pwwn);
2869	bfa_trc(ms->port->fcs, event);
2870
2871	switch (event) {
2872	case MSSM_EVENT_PORT_ONLINE:
2873	bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_plogi_sending);
2874	bfa_fcs_lport_ms_send_plogi(ms_cbarg: ms, NULL);
2875	break;
2876
2877	case MSSM_EVENT_PORT_OFFLINE:
2878	break;
2879
2880	default:
2881	bfa_sm_fault(ms->port->fcs, event);
2882	}
2883	}
2884
2885	static void
2886	bfa_fcs_lport_ms_sm_plogi_sending(struct bfa_fcs_lport_ms_s *ms,
2887	enum port_ms_event event)
2888	{
2889	bfa_trc(ms->port->fcs, ms->port->port_cfg.pwwn);
2890	bfa_trc(ms->port->fcs, event);
2891
2892	switch (event) {
2893	case MSSM_EVENT_FCXP_SENT:
2894	bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_plogi);
2895	break;
2896
2897	case MSSM_EVENT_PORT_OFFLINE:
2898	bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_offline);
2899	bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ms->port),
2900	wqe: &ms->fcxp_wqe);
2901	break;
2902
2903	default:
2904	bfa_sm_fault(ms->port->fcs, event);
2905	}
2906	}
2907
2908	static void
2909	bfa_fcs_lport_ms_sm_plogi(struct bfa_fcs_lport_ms_s *ms,
2910	enum port_ms_event event)
2911	{
2912	bfa_trc(ms->port->fcs, ms->port->port_cfg.pwwn);
2913	bfa_trc(ms->port->fcs, event);
2914
2915	switch (event) {
2916	case MSSM_EVENT_RSP_ERROR:
2917	/*
2918	* Start timer for a delayed retry
2919	*/
2920	bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_plogi_retry);
2921	ms->port->stats.ms_retries++;
2922	bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ms->port),
2923	&ms->timer, bfa_fcs_lport_ms_timeout, ms,
2924	BFA_FCS_RETRY_TIMEOUT);
2925	break;
2926
2927	case MSSM_EVENT_RSP_OK:
2928	/*
2929	* since plogi is done, now invoke MS related sub-modules
2930	*/
2931	bfa_fcs_lport_fdmi_online(ms);
2932
2933	/*
2934	* if this is a Vport, go to online state.
2935	*/
2936	if (ms->port->vport) {
2937	bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_online);
2938	break;
2939	}
2940
2941	/*
2942	* For a base port we need to get the
2943	* switch's IP address.
2944	*/
2945	bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_gmal_sending);
2946	bfa_fcs_lport_ms_send_gmal(ms_cbarg: ms, NULL);
2947	break;
2948
2949	case MSSM_EVENT_PORT_OFFLINE:
2950	bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_offline);
2951	bfa_fcxp_discard(fcxp: ms->fcxp);
2952	break;
2953
2954	default:
2955	bfa_sm_fault(ms->port->fcs, event);
2956	}
2957	}
2958
2959	static void
2960	bfa_fcs_lport_ms_sm_plogi_retry(struct bfa_fcs_lport_ms_s *ms,
2961	enum port_ms_event event)
2962	{
2963	bfa_trc(ms->port->fcs, ms->port->port_cfg.pwwn);
2964	bfa_trc(ms->port->fcs, event);
2965
2966	switch (event) {
2967	case MSSM_EVENT_TIMEOUT:
2968	/*
2969	* Retry Timer Expired. Re-send
2970	*/
2971	bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_plogi_sending);
2972	bfa_fcs_lport_ms_send_plogi(ms_cbarg: ms, NULL);
2973	break;
2974
2975	case MSSM_EVENT_PORT_OFFLINE:
2976	bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_offline);
2977	bfa_timer_stop(timer: &ms->timer);
2978	break;
2979
2980	default:
2981	bfa_sm_fault(ms->port->fcs, event);
2982	}
2983	}
2984
2985	static void
2986	bfa_fcs_lport_ms_sm_online(struct bfa_fcs_lport_ms_s *ms,
2987	enum port_ms_event event)
2988	{
2989	bfa_trc(ms->port->fcs, ms->port->port_cfg.pwwn);
2990	bfa_trc(ms->port->fcs, event);
2991
2992	switch (event) {
2993	case MSSM_EVENT_PORT_OFFLINE:
2994	bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_offline);
2995	break;
2996
2997	case MSSM_EVENT_PORT_FABRIC_RSCN:
2998	bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_gfn_sending);
2999	ms->retry_cnt = 0;
3000	bfa_fcs_lport_ms_send_gfn(ms_cbarg: ms, NULL);
3001	break;
3002
3003	default:
3004	bfa_sm_fault(ms->port->fcs, event);
3005	}
3006	}
3007
3008	static void
3009	bfa_fcs_lport_ms_sm_gmal_sending(struct bfa_fcs_lport_ms_s *ms,
3010	enum port_ms_event event)
3011	{
3012	bfa_trc(ms->port->fcs, ms->port->port_cfg.pwwn);
3013	bfa_trc(ms->port->fcs, event);
3014
3015	switch (event) {
3016	case MSSM_EVENT_FCXP_SENT:
3017	bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_gmal);
3018	break;
3019
3020	case MSSM_EVENT_PORT_OFFLINE:
3021	bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_offline);
3022	bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ms->port),
3023	wqe: &ms->fcxp_wqe);
3024	break;
3025
3026	default:
3027	bfa_sm_fault(ms->port->fcs, event);
3028	}
3029	}
3030
3031	static void
3032	bfa_fcs_lport_ms_sm_gmal(struct bfa_fcs_lport_ms_s *ms,
3033	enum port_ms_event event)
3034	{
3035	bfa_trc(ms->port->fcs, ms->port->port_cfg.pwwn);
3036	bfa_trc(ms->port->fcs, event);
3037
3038	switch (event) {
3039	case MSSM_EVENT_RSP_ERROR:
3040	/*
3041	* Start timer for a delayed retry
3042	*/
3043	if (ms->retry_cnt++ < BFA_FCS_MS_CMD_MAX_RETRIES) {
3044	bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_gmal_retry);
3045	ms->port->stats.ms_retries++;
3046	bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ms->port),
3047	&ms->timer, bfa_fcs_lport_ms_timeout, ms,
3048	BFA_FCS_RETRY_TIMEOUT);
3049	} else {
3050	bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_gfn_sending);
3051	bfa_fcs_lport_ms_send_gfn(ms_cbarg: ms, NULL);
3052	ms->retry_cnt = 0;
3053	}
3054	break;
3055
3056	case MSSM_EVENT_RSP_OK:
3057	bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_gfn_sending);
3058	bfa_fcs_lport_ms_send_gfn(ms_cbarg: ms, NULL);
3059	break;
3060
3061	case MSSM_EVENT_PORT_OFFLINE:
3062	bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_offline);
3063	bfa_fcxp_discard(fcxp: ms->fcxp);
3064	break;
3065
3066	default:
3067	bfa_sm_fault(ms->port->fcs, event);
3068	}
3069	}
3070
3071	static void
3072	bfa_fcs_lport_ms_sm_gmal_retry(struct bfa_fcs_lport_ms_s *ms,
3073	enum port_ms_event event)
3074	{
3075	bfa_trc(ms->port->fcs, ms->port->port_cfg.pwwn);
3076	bfa_trc(ms->port->fcs, event);
3077
3078	switch (event) {
3079	case MSSM_EVENT_TIMEOUT:
3080	/*
3081	* Retry Timer Expired. Re-send
3082	*/
3083	bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_gmal_sending);
3084	bfa_fcs_lport_ms_send_gmal(ms_cbarg: ms, NULL);
3085	break;
3086
3087	case MSSM_EVENT_PORT_OFFLINE:
3088	bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_offline);
3089	bfa_timer_stop(timer: &ms->timer);
3090	break;
3091
3092	default:
3093	bfa_sm_fault(ms->port->fcs, event);
3094	}
3095	}
3096	/*
3097	* ms_pvt MS local functions
3098	*/
3099
3100	static void
3101	bfa_fcs_lport_ms_send_gmal(void *ms_cbarg, struct bfa_fcxp_s *fcxp_alloced)
3102	{
3103	struct bfa_fcs_lport_ms_s *ms = ms_cbarg;
3104	bfa_fcs_lport_t *port = ms->port;
3105	struct fchs_s fchs;
3106	int len;
3107	struct bfa_fcxp_s *fcxp;
3108
3109	bfa_trc(port->fcs, port->pid);
3110
3111	fcxp = fcxp_alloced ? fcxp_alloced :
3112	bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
3113	if (!fcxp) {
3114	bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ms->fcxp_wqe,
3115	bfa_fcs_lport_ms_send_gmal, ms, BFA_TRUE);
3116	return;
3117	}
3118	ms->fcxp = fcxp;
3119
3120	len = fc_gmal_req_build(fchs: &fchs, pyld: bfa_fcxp_get_reqbuf(fcxp),
3121	bfa_fcs_lport_get_fcid(port),
3122	wwn: port->fabric->lps->pr_nwwn);
3123
3124	bfa_fcxp_send(fcxp, NULL, vf_id: port->fabric->vf_id, lp_tag: port->lp_tag, cts: BFA_FALSE,
3125	cos: FC_CLASS_3, reqlen: len, fchs: &fchs,
3126	cbfn: bfa_fcs_lport_ms_gmal_response, cbarg: (void *)ms,
3127	rsp_maxlen: FC_MAX_PDUSZ, FC_FCCT_TOV);
3128
3129	bfa_sm_send_event(ms, MSSM_EVENT_FCXP_SENT);
3130	}
3131
3132	static void
3133	bfa_fcs_lport_ms_gmal_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
3134	void *cbarg, bfa_status_t req_status,
3135	u32 rsp_len, u32 resid_len,
3136	struct fchs_s *rsp_fchs)
3137	{
3138	struct bfa_fcs_lport_ms_s *ms = (struct bfa_fcs_lport_ms_s *) cbarg;
3139	bfa_fcs_lport_t *port = ms->port;
3140	struct ct_hdr_s *cthdr = NULL;
3141	struct fcgs_gmal_resp_s *gmal_resp;
3142	struct fcgs_gmal_entry_s *gmal_entry;
3143	u32 num_entries;
3144	u8 *rsp_str;
3145
3146	bfa_trc(port->fcs, req_status);
3147	bfa_trc(port->fcs, port->port_cfg.pwwn);
3148
3149	/*
3150	* Sanity Checks
3151	*/
3152	if (req_status != BFA_STATUS_OK) {
3153	bfa_trc(port->fcs, req_status);
3154	bfa_sm_send_event(ms, MSSM_EVENT_RSP_ERROR);
3155	return;
3156	}
3157
3158	cthdr = (struct ct_hdr_s *) BFA_FCXP_RSP_PLD(fcxp);
3159	cthdr->cmd_rsp_code = be16_to_cpu(cthdr->cmd_rsp_code);
3160
3161	if (cthdr->cmd_rsp_code == CT_RSP_ACCEPT) {
3162	gmal_resp = (struct fcgs_gmal_resp_s *)(cthdr + 1);
3163
3164	num_entries = be32_to_cpu(gmal_resp->ms_len);
3165	if (num_entries == 0) {
3166	bfa_sm_send_event(ms, MSSM_EVENT_RSP_ERROR);
3167	return;
3168	}
3169	/*
3170	* The response could contain multiple Entries.
3171	* Entries for SNMP interface, etc.
3172	* We look for the entry with a telnet prefix.
3173	* First "http://" entry refers to IP addr
3174	*/
3175
3176	gmal_entry = (struct fcgs_gmal_entry_s *)gmal_resp->ms_ma;
3177	while (num_entries > 0) {
3178	if (strncmp(gmal_entry->prefix,
3179	CT_GMAL_RESP_PREFIX_HTTP,
3180	sizeof(gmal_entry->prefix)) == 0) {
3181
3182	/*
3183	* if the IP address is terminating with a '/',
3184	* remove it.
3185	* Byte 0 consists of the length of the string.
3186	*/
3187	rsp_str = &(gmal_entry->prefix[0]);
3188	if (rsp_str[gmal_entry->len-1] == '/')
3189	rsp_str[gmal_entry->len-1] = 0;
3190
3191	/* copy IP Address to fabric */
3192	strscpy(bfa_fcs_lport_get_fabric_ipaddr(port),
3193	gmal_entry->ip_addr,
3194	BFA_FCS_FABRIC_IPADDR_SZ);
3195	break;
3196	} else {
3197	--num_entries;
3198	++gmal_entry;
3199	}
3200	}
3201
3202	bfa_sm_send_event(ms, MSSM_EVENT_RSP_OK);
3203	return;
3204	}
3205
3206	bfa_trc(port->fcs, cthdr->reason_code);
3207	bfa_trc(port->fcs, cthdr->exp_code);
3208	bfa_sm_send_event(ms, MSSM_EVENT_RSP_ERROR);
3209	}
3210
3211	static void
3212	bfa_fcs_lport_ms_sm_gfn_sending(struct bfa_fcs_lport_ms_s *ms,
3213	enum port_ms_event event)
3214	{
3215	bfa_trc(ms->port->fcs, ms->port->port_cfg.pwwn);
3216	bfa_trc(ms->port->fcs, event);
3217
3218	switch (event) {
3219	case MSSM_EVENT_FCXP_SENT:
3220	bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_gfn);
3221	break;
3222
3223	case MSSM_EVENT_PORT_OFFLINE:
3224	bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_offline);
3225	bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ms->port),
3226	wqe: &ms->fcxp_wqe);
3227	break;
3228
3229	default:
3230	bfa_sm_fault(ms->port->fcs, event);
3231	}
3232	}
3233
3234	static void
3235	bfa_fcs_lport_ms_sm_gfn(struct bfa_fcs_lport_ms_s *ms,
3236	enum port_ms_event event)
3237	{
3238	bfa_trc(ms->port->fcs, ms->port->port_cfg.pwwn);
3239	bfa_trc(ms->port->fcs, event);
3240
3241	switch (event) {
3242	case MSSM_EVENT_RSP_ERROR:
3243	/*
3244	* Start timer for a delayed retry
3245	*/
3246	if (ms->retry_cnt++ < BFA_FCS_MS_CMD_MAX_RETRIES) {
3247	bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_gfn_retry);
3248	ms->port->stats.ms_retries++;
3249	bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ms->port),
3250	&ms->timer, bfa_fcs_lport_ms_timeout, ms,
3251	BFA_FCS_RETRY_TIMEOUT);
3252	} else {
3253	bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_online);
3254	ms->retry_cnt = 0;
3255	}
3256	break;
3257
3258	case MSSM_EVENT_RSP_OK:
3259	bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_online);
3260	break;
3261
3262	case MSSM_EVENT_PORT_OFFLINE:
3263	bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_offline);
3264	bfa_fcxp_discard(fcxp: ms->fcxp);
3265	break;
3266
3267	default:
3268	bfa_sm_fault(ms->port->fcs, event);
3269	}
3270	}
3271
3272	static void
3273	bfa_fcs_lport_ms_sm_gfn_retry(struct bfa_fcs_lport_ms_s *ms,
3274	enum port_ms_event event)
3275	{
3276	bfa_trc(ms->port->fcs, ms->port->port_cfg.pwwn);
3277	bfa_trc(ms->port->fcs, event);
3278
3279	switch (event) {
3280	case MSSM_EVENT_TIMEOUT:
3281	/*
3282	* Retry Timer Expired. Re-send
3283	*/
3284	bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_gfn_sending);
3285	bfa_fcs_lport_ms_send_gfn(ms_cbarg: ms, NULL);
3286	break;
3287
3288	case MSSM_EVENT_PORT_OFFLINE:
3289	bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_offline);
3290	bfa_timer_stop(timer: &ms->timer);
3291	break;
3292
3293	default:
3294	bfa_sm_fault(ms->port->fcs, event);
3295	}
3296	}
3297	/*
3298	* ms_pvt MS local functions
3299	*/
3300
3301	static void
3302	bfa_fcs_lport_ms_send_gfn(void *ms_cbarg, struct bfa_fcxp_s *fcxp_alloced)
3303	{
3304	struct bfa_fcs_lport_ms_s *ms = ms_cbarg;
3305	bfa_fcs_lport_t *port = ms->port;
3306	struct fchs_s fchs;
3307	int len;
3308	struct bfa_fcxp_s *fcxp;
3309
3310	bfa_trc(port->fcs, port->pid);
3311
3312	fcxp = fcxp_alloced ? fcxp_alloced :
3313	bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
3314	if (!fcxp) {
3315	bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ms->fcxp_wqe,
3316	bfa_fcs_lport_ms_send_gfn, ms, BFA_TRUE);
3317	return;
3318	}
3319	ms->fcxp = fcxp;
3320
3321	len = fc_gfn_req_build(fchs: &fchs, pyld: bfa_fcxp_get_reqbuf(fcxp),
3322	bfa_fcs_lport_get_fcid(port),
3323	wwn: port->fabric->lps->pr_nwwn);
3324
3325	bfa_fcxp_send(fcxp, NULL, vf_id: port->fabric->vf_id, lp_tag: port->lp_tag, cts: BFA_FALSE,
3326	cos: FC_CLASS_3, reqlen: len, fchs: &fchs,
3327	cbfn: bfa_fcs_lport_ms_gfn_response, cbarg: (void *)ms,
3328	rsp_maxlen: FC_MAX_PDUSZ, FC_FCCT_TOV);
3329
3330	bfa_sm_send_event(ms, MSSM_EVENT_FCXP_SENT);
3331	}
3332
3333	static void
3334	bfa_fcs_lport_ms_gfn_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
3335	void *cbarg, bfa_status_t req_status, u32 rsp_len,
3336	u32 resid_len, struct fchs_s *rsp_fchs)
3337	{
3338	struct bfa_fcs_lport_ms_s *ms = (struct bfa_fcs_lport_ms_s *) cbarg;
3339	bfa_fcs_lport_t *port = ms->port;
3340	struct ct_hdr_s *cthdr = NULL;
3341	wwn_t *gfn_resp;
3342
3343	bfa_trc(port->fcs, req_status);
3344	bfa_trc(port->fcs, port->port_cfg.pwwn);
3345
3346	/*
3347	* Sanity Checks
3348	*/
3349	if (req_status != BFA_STATUS_OK) {
3350	bfa_trc(port->fcs, req_status);
3351	bfa_sm_send_event(ms, MSSM_EVENT_RSP_ERROR);
3352	return;
3353	}
3354
3355	cthdr = (struct ct_hdr_s *) BFA_FCXP_RSP_PLD(fcxp);
3356	cthdr->cmd_rsp_code = be16_to_cpu(cthdr->cmd_rsp_code);
3357
3358	if (cthdr->cmd_rsp_code == CT_RSP_ACCEPT) {
3359	gfn_resp = (wwn_t *)(cthdr + 1);
3360	/* check if it has actually changed */
3361	if ((memcmp(p: (void *)&bfa_fcs_lport_get_fabric_name(port),
3362	q: gfn_resp, size: sizeof(wwn_t)) != 0)) {
3363	bfa_fcs_fabric_set_fabric_name(fabric: port->fabric, fabric_name: *gfn_resp);
3364	}
3365	bfa_sm_send_event(ms, MSSM_EVENT_RSP_OK);
3366	return;
3367	}
3368
3369	bfa_trc(port->fcs, cthdr->reason_code);
3370	bfa_trc(port->fcs, cthdr->exp_code);
3371	bfa_sm_send_event(ms, MSSM_EVENT_RSP_ERROR);
3372	}
3373
3374	/*
3375	* ms_pvt MS local functions
3376	*/
3377
3378	static void
3379	bfa_fcs_lport_ms_send_plogi(void *ms_cbarg, struct bfa_fcxp_s *fcxp_alloced)
3380	{
3381	struct bfa_fcs_lport_ms_s *ms = ms_cbarg;
3382	struct bfa_fcs_lport_s *port = ms->port;
3383	struct fchs_s fchs;
3384	int len;
3385	struct bfa_fcxp_s *fcxp;
3386
3387	bfa_trc(port->fcs, port->pid);
3388
3389	fcxp = fcxp_alloced ? fcxp_alloced :
3390	bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
3391	if (!fcxp) {
3392	port->stats.ms_plogi_alloc_wait++;
3393	bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ms->fcxp_wqe,
3394	bfa_fcs_lport_ms_send_plogi, ms, BFA_TRUE);
3395	return;
3396	}
3397	ms->fcxp = fcxp;
3398
3399	len = fc_plogi_build(fchs: &fchs, pld: bfa_fcxp_get_reqbuf(fcxp),
3400	bfa_hton3b(FC_MGMT_SERVER),
3401	bfa_fcs_lport_get_fcid(port), ox_id: 0,
3402	port_name: port->port_cfg.pwwn, node_name: port->port_cfg.nwwn,
3403	pdu_size: bfa_fcport_get_maxfrsize(bfa: port->fcs->bfa),
3404	bb_cr: bfa_fcport_get_rx_bbcredit(bfa: port->fcs->bfa));
3405
3406	bfa_fcxp_send(fcxp, NULL, vf_id: port->fabric->vf_id, lp_tag: port->lp_tag, cts: BFA_FALSE,
3407	cos: FC_CLASS_3, reqlen: len, fchs: &fchs,
3408	cbfn: bfa_fcs_lport_ms_plogi_response, cbarg: (void *)ms,
3409	rsp_maxlen: FC_MAX_PDUSZ, FC_ELS_TOV);
3410
3411	port->stats.ms_plogi_sent++;
3412	bfa_sm_send_event(ms, MSSM_EVENT_FCXP_SENT);
3413	}
3414
3415	static void
3416	bfa_fcs_lport_ms_plogi_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
3417	void *cbarg, bfa_status_t req_status,
3418	u32 rsp_len, u32 resid_len, struct fchs_s *rsp_fchs)
3419	{
3420	struct bfa_fcs_lport_ms_s *ms = (struct bfa_fcs_lport_ms_s *) cbarg;
3421	struct bfa_fcs_lport_s *port = ms->port;
3422	struct fc_els_cmd_s *els_cmd;
3423	struct fc_ls_rjt_s *ls_rjt;
3424
3425	bfa_trc(port->fcs, req_status);
3426	bfa_trc(port->fcs, port->port_cfg.pwwn);
3427
3428	/*
3429	* Sanity Checks
3430	*/
3431	if (req_status != BFA_STATUS_OK) {
3432	port->stats.ms_plogi_rsp_err++;
3433	bfa_trc(port->fcs, req_status);
3434	bfa_sm_send_event(ms, MSSM_EVENT_RSP_ERROR);
3435	return;
3436	}
3437
3438	els_cmd = (struct fc_els_cmd_s *) BFA_FCXP_RSP_PLD(fcxp);
3439
3440	switch (els_cmd->els_code) {
3441
3442	case FC_ELS_ACC:
3443	if (rsp_len < sizeof(struct fc_logi_s)) {
3444	bfa_trc(port->fcs, rsp_len);
3445	port->stats.ms_plogi_acc_err++;
3446	bfa_sm_send_event(ms, MSSM_EVENT_RSP_ERROR);
3447	break;
3448	}
3449	port->stats.ms_plogi_accepts++;
3450	bfa_sm_send_event(ms, MSSM_EVENT_RSP_OK);
3451	break;
3452
3453	case FC_ELS_LS_RJT:
3454	ls_rjt = (struct fc_ls_rjt_s *) BFA_FCXP_RSP_PLD(fcxp);
3455
3456	bfa_trc(port->fcs, ls_rjt->reason_code);
3457	bfa_trc(port->fcs, ls_rjt->reason_code_expl);
3458
3459	port->stats.ms_rejects++;
3460	bfa_sm_send_event(ms, MSSM_EVENT_RSP_ERROR);
3461	break;
3462
3463	default:
3464	port->stats.ms_plogi_unknown_rsp++;
3465	bfa_trc(port->fcs, els_cmd->els_code);
3466	bfa_sm_send_event(ms, MSSM_EVENT_RSP_ERROR);
3467	}
3468	}
3469
3470	static void
3471	bfa_fcs_lport_ms_timeout(void *arg)
3472	{
3473	struct bfa_fcs_lport_ms_s *ms = (struct bfa_fcs_lport_ms_s *) arg;
3474
3475	ms->port->stats.ms_timeouts++;
3476	bfa_sm_send_event(ms, MSSM_EVENT_TIMEOUT);
3477	}
3478
3479
3480	void
3481	bfa_fcs_lport_ms_init(struct bfa_fcs_lport_s *port)
3482	{
3483	struct bfa_fcs_lport_ms_s *ms = BFA_FCS_GET_MS_FROM_PORT(port);
3484
3485	ms->port = port;
3486	bfa_sm_set_state(ms, bfa_fcs_lport_ms_sm_offline);
3487
3488	/*
3489	* Invoke init routines of sub modules.
3490	*/
3491	bfa_fcs_lport_fdmi_init(ms);
3492	}
3493
3494	void
3495	bfa_fcs_lport_ms_offline(struct bfa_fcs_lport_s *port)
3496	{
3497	struct bfa_fcs_lport_ms_s *ms = BFA_FCS_GET_MS_FROM_PORT(port);
3498
3499	ms->port = port;
3500	bfa_sm_send_event(ms, MSSM_EVENT_PORT_OFFLINE);
3501	bfa_fcs_lport_fdmi_offline(ms);
3502	}
3503
3504	void
3505	bfa_fcs_lport_ms_online(struct bfa_fcs_lport_s *port)
3506	{
3507	struct bfa_fcs_lport_ms_s *ms = BFA_FCS_GET_MS_FROM_PORT(port);
3508
3509	ms->port = port;
3510	bfa_sm_send_event(ms, MSSM_EVENT_PORT_ONLINE);
3511	}
3512	void
3513	bfa_fcs_lport_ms_fabric_rscn(struct bfa_fcs_lport_s *port)
3514	{
3515	struct bfa_fcs_lport_ms_s *ms = BFA_FCS_GET_MS_FROM_PORT(port);
3516
3517	/* todo. Handle this only when in Online state */
3518	if (bfa_sm_cmp_state(ms, bfa_fcs_lport_ms_sm_online))
3519	bfa_sm_send_event(ms, MSSM_EVENT_PORT_FABRIC_RSCN);
3520	}
3521
3522	/*
3523	* @page ns_sm_info VPORT NS State Machine
3524	*
3525	* @section ns_sm_interactions VPORT NS State Machine Interactions
3526	*
3527	* @section ns_sm VPORT NS State Machine
3528	* img ns_sm.jpg
3529	*/
3530
3531	/*
3532	* forward declarations
3533	*/
3534	static void bfa_fcs_lport_ns_send_plogi(void *ns_cbarg,
3535	struct bfa_fcxp_s *fcxp_alloced);
3536	static void bfa_fcs_lport_ns_send_rspn_id(void *ns_cbarg,
3537	struct bfa_fcxp_s *fcxp_alloced);
3538	static void bfa_fcs_lport_ns_send_rft_id(void *ns_cbarg,
3539	struct bfa_fcxp_s *fcxp_alloced);
3540	static void bfa_fcs_lport_ns_send_rff_id(void *ns_cbarg,
3541	struct bfa_fcxp_s *fcxp_alloced);
3542	static void bfa_fcs_lport_ns_send_gid_ft(void *ns_cbarg,
3543	struct bfa_fcxp_s *fcxp_alloced);
3544	static void bfa_fcs_lport_ns_send_rnn_id(void *ns_cbarg,
3545	struct bfa_fcxp_s *fcxp_alloced);
3546	static void bfa_fcs_lport_ns_send_rsnn_nn(void *ns_cbarg,
3547	struct bfa_fcxp_s *fcxp_alloced);
3548	static void bfa_fcs_lport_ns_timeout(void *arg);
3549	static void bfa_fcs_lport_ns_plogi_response(void *fcsarg,
3550	struct bfa_fcxp_s *fcxp,
3551	void *cbarg,
3552	bfa_status_t req_status,
3553	u32 rsp_len,
3554	u32 resid_len,
3555	struct fchs_s *rsp_fchs);
3556	static void bfa_fcs_lport_ns_rspn_id_response(void *fcsarg,
3557	struct bfa_fcxp_s *fcxp,
3558	void *cbarg,
3559	bfa_status_t req_status,
3560	u32 rsp_len,
3561	u32 resid_len,
3562	struct fchs_s *rsp_fchs);
3563	static void bfa_fcs_lport_ns_rft_id_response(void *fcsarg,
3564	struct bfa_fcxp_s *fcxp,
3565	void *cbarg,
3566	bfa_status_t req_status,
3567	u32 rsp_len,
3568	u32 resid_len,
3569	struct fchs_s *rsp_fchs);
3570	static void bfa_fcs_lport_ns_rff_id_response(void *fcsarg,
3571	struct bfa_fcxp_s *fcxp,
3572	void *cbarg,
3573	bfa_status_t req_status,
3574	u32 rsp_len,
3575	u32 resid_len,
3576	struct fchs_s *rsp_fchs);
3577	static void bfa_fcs_lport_ns_gid_ft_response(void *fcsarg,
3578	struct bfa_fcxp_s *fcxp,
3579	void *cbarg,
3580	bfa_status_t req_status,
3581	u32 rsp_len,
3582	u32 resid_len,
3583	struct fchs_s *rsp_fchs);
3584	static void bfa_fcs_lport_ns_rnn_id_response(void *fcsarg,
3585	struct bfa_fcxp_s *fcxp,
3586	void *cbarg,
3587	bfa_status_t req_status,
3588	u32 rsp_len,
3589	u32 resid_len,
3590	struct fchs_s *rsp_fchs);
3591	static void bfa_fcs_lport_ns_rsnn_nn_response(void *fcsarg,
3592	struct bfa_fcxp_s *fcxp,
3593	void *cbarg,
3594	bfa_status_t req_status,
3595	u32 rsp_len,
3596	u32 resid_len,
3597	struct fchs_s *rsp_fchs);
3598	static void bfa_fcs_lport_ns_process_gidft_pids(
3599	struct bfa_fcs_lport_s *port,
3600	u32 *pid_buf, u32 n_pids);
3601
3602	static void bfa_fcs_lport_ns_boot_target_disc(bfa_fcs_lport_t *port);
3603	/*
3604	* fcs_ns_sm FCS nameserver interface state machine
3605	*/
3606
3607	static void bfa_fcs_lport_ns_sm_offline(struct bfa_fcs_lport_ns_s *ns,
3608	enum vport_ns_event event);
3609	static void bfa_fcs_lport_ns_sm_plogi_sending(struct bfa_fcs_lport_ns_s *ns,
3610	enum vport_ns_event event);
3611	static void bfa_fcs_lport_ns_sm_plogi(struct bfa_fcs_lport_ns_s *ns,
3612	enum vport_ns_event event);
3613	static void bfa_fcs_lport_ns_sm_plogi_retry(struct bfa_fcs_lport_ns_s *ns,
3614	enum vport_ns_event event);
3615	static void bfa_fcs_lport_ns_sm_sending_rspn_id(
3616	struct bfa_fcs_lport_ns_s *ns,
3617	enum vport_ns_event event);
3618	static void bfa_fcs_lport_ns_sm_rspn_id(struct bfa_fcs_lport_ns_s *ns,
3619	enum vport_ns_event event);
3620	static void bfa_fcs_lport_ns_sm_rspn_id_retry(struct bfa_fcs_lport_ns_s *ns,
3621	enum vport_ns_event event);
3622	static void bfa_fcs_lport_ns_sm_sending_rft_id(
3623	struct bfa_fcs_lport_ns_s *ns,
3624	enum vport_ns_event event);
3625	static void bfa_fcs_lport_ns_sm_rft_id_retry(struct bfa_fcs_lport_ns_s *ns,
3626	enum vport_ns_event event);
3627	static void bfa_fcs_lport_ns_sm_rft_id(struct bfa_fcs_lport_ns_s *ns,
3628	enum vport_ns_event event);
3629	static void bfa_fcs_lport_ns_sm_sending_rff_id(
3630	struct bfa_fcs_lport_ns_s *ns,
3631	enum vport_ns_event event);
3632	static void bfa_fcs_lport_ns_sm_rff_id_retry(struct bfa_fcs_lport_ns_s *ns,
3633	enum vport_ns_event event);
3634	static void bfa_fcs_lport_ns_sm_rff_id(struct bfa_fcs_lport_ns_s *ns,
3635	enum vport_ns_event event);
3636	static void bfa_fcs_lport_ns_sm_sending_gid_ft(
3637	struct bfa_fcs_lport_ns_s *ns,
3638	enum vport_ns_event event);
3639	static void bfa_fcs_lport_ns_sm_gid_ft(struct bfa_fcs_lport_ns_s *ns,
3640	enum vport_ns_event event);
3641	static void bfa_fcs_lport_ns_sm_gid_ft_retry(struct bfa_fcs_lport_ns_s *ns,
3642	enum vport_ns_event event);
3643	static void bfa_fcs_lport_ns_sm_online(struct bfa_fcs_lport_ns_s *ns,
3644	enum vport_ns_event event);
3645	static void bfa_fcs_lport_ns_sm_sending_rnn_id(
3646	struct bfa_fcs_lport_ns_s *ns,
3647	enum vport_ns_event event);
3648	static void bfa_fcs_lport_ns_sm_rnn_id(struct bfa_fcs_lport_ns_s *ns,
3649	enum vport_ns_event event);
3650	static void bfa_fcs_lport_ns_sm_rnn_id_retry(struct bfa_fcs_lport_ns_s *ns,
3651	enum vport_ns_event event);
3652	static void bfa_fcs_lport_ns_sm_sending_rsnn_nn(
3653	struct bfa_fcs_lport_ns_s *ns,
3654	enum vport_ns_event event);
3655	static void bfa_fcs_lport_ns_sm_rsnn_nn(struct bfa_fcs_lport_ns_s *ns,
3656	enum vport_ns_event event);
3657	static void bfa_fcs_lport_ns_sm_rsnn_nn_retry(
3658	struct bfa_fcs_lport_ns_s *ns,
3659	enum vport_ns_event event);
3660	/*
3661	* Start in offline state - awaiting linkup
3662	*/
3663	static void
3664	bfa_fcs_lport_ns_sm_offline(struct bfa_fcs_lport_ns_s *ns,
3665	enum vport_ns_event event)
3666	{
3667	bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
3668	bfa_trc(ns->port->fcs, event);
3669
3670	switch (event) {
3671	case NSSM_EVENT_PORT_ONLINE:
3672	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_plogi_sending);
3673	bfa_fcs_lport_ns_send_plogi(ns_cbarg: ns, NULL);
3674	break;
3675
3676	case NSSM_EVENT_PORT_OFFLINE:
3677	break;
3678
3679	default:
3680	bfa_sm_fault(ns->port->fcs, event);
3681	}
3682	}
3683
3684	static void
3685	bfa_fcs_lport_ns_sm_plogi_sending(struct bfa_fcs_lport_ns_s *ns,
3686	enum vport_ns_event event)
3687	{
3688	bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
3689	bfa_trc(ns->port->fcs, event);
3690
3691	switch (event) {
3692	case NSSM_EVENT_PLOGI_SENT:
3693	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_plogi);
3694	break;
3695
3696	case NSSM_EVENT_PORT_OFFLINE:
3697	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
3698	bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ns->port),
3699	wqe: &ns->fcxp_wqe);
3700	break;
3701
3702	default:
3703	bfa_sm_fault(ns->port->fcs, event);
3704	}
3705	}
3706
3707	static void
3708	bfa_fcs_lport_ns_sm_plogi(struct bfa_fcs_lport_ns_s *ns,
3709	enum vport_ns_event event)
3710	{
3711	bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
3712	bfa_trc(ns->port->fcs, event);
3713
3714	switch (event) {
3715	case NSSM_EVENT_RSP_ERROR:
3716	/*
3717	* Start timer for a delayed retry
3718	*/
3719	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_plogi_retry);
3720	ns->port->stats.ns_retries++;
3721	bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ns->port),
3722	&ns->timer, bfa_fcs_lport_ns_timeout, ns,
3723	BFA_FCS_RETRY_TIMEOUT);
3724	break;
3725
3726	case NSSM_EVENT_RSP_OK:
3727	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_rnn_id);
3728	ns->num_rnnid_retries = 0;
3729	bfa_fcs_lport_ns_send_rnn_id(ns_cbarg: ns, NULL);
3730	break;
3731
3732	case NSSM_EVENT_PORT_OFFLINE:
3733	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
3734	bfa_fcxp_discard(fcxp: ns->fcxp);
3735	break;
3736
3737	default:
3738	bfa_sm_fault(ns->port->fcs, event);
3739	}
3740	}
3741
3742	static void
3743	bfa_fcs_lport_ns_sm_plogi_retry(struct bfa_fcs_lport_ns_s *ns,
3744	enum vport_ns_event event)
3745	{
3746	bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
3747	bfa_trc(ns->port->fcs, event);
3748
3749	switch (event) {
3750	case NSSM_EVENT_TIMEOUT:
3751	/*
3752	* Retry Timer Expired. Re-send
3753	*/
3754	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_plogi_sending);
3755	bfa_fcs_lport_ns_send_plogi(ns_cbarg: ns, NULL);
3756	break;
3757
3758	case NSSM_EVENT_PORT_OFFLINE:
3759	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
3760	bfa_timer_stop(timer: &ns->timer);
3761	break;
3762
3763	default:
3764	bfa_sm_fault(ns->port->fcs, event);
3765	}
3766	}
3767
3768	static void
3769	bfa_fcs_lport_ns_sm_sending_rnn_id(struct bfa_fcs_lport_ns_s *ns,
3770	enum vport_ns_event event)
3771	{
3772	bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
3773	bfa_trc(ns->port->fcs, event);
3774
3775	switch (event) {
3776	case NSSM_EVENT_RNNID_SENT:
3777	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_rnn_id);
3778	break;
3779
3780	case NSSM_EVENT_PORT_OFFLINE:
3781	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
3782	bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ns->port),
3783	wqe: &ns->fcxp_wqe);
3784	break;
3785	default:
3786	bfa_sm_fault(ns->port->fcs, event);
3787	}
3788	}
3789
3790	static void
3791	bfa_fcs_lport_ns_sm_rnn_id(struct bfa_fcs_lport_ns_s *ns,
3792	enum vport_ns_event event)
3793	{
3794	bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
3795	bfa_trc(ns->port->fcs, event);
3796
3797	switch (event) {
3798	case NSSM_EVENT_RSP_OK:
3799	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_rsnn_nn);
3800	ns->num_rnnid_retries = 0;
3801	ns->num_rsnn_nn_retries = 0;
3802	bfa_fcs_lport_ns_send_rsnn_nn(ns_cbarg: ns, NULL);
3803	break;
3804
3805	case NSSM_EVENT_RSP_ERROR:
3806	if (ns->num_rnnid_retries < BFA_FCS_MAX_NS_RETRIES) {
3807	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_rnn_id_retry);
3808	ns->port->stats.ns_retries++;
3809	ns->num_rnnid_retries++;
3810	bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ns->port),
3811	&ns->timer, bfa_fcs_lport_ns_timeout, ns,
3812	BFA_FCS_RETRY_TIMEOUT);
3813	} else {
3814	bfa_sm_set_state(ns,
3815	bfa_fcs_lport_ns_sm_sending_rspn_id);
3816	bfa_fcs_lport_ns_send_rspn_id(ns_cbarg: ns, NULL);
3817	}
3818	break;
3819
3820	case NSSM_EVENT_PORT_OFFLINE:
3821	bfa_fcxp_discard(fcxp: ns->fcxp);
3822	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
3823	break;
3824
3825	default:
3826	bfa_sm_fault(ns->port->fcs, event);
3827	}
3828	}
3829
3830	static void
3831	bfa_fcs_lport_ns_sm_rnn_id_retry(struct bfa_fcs_lport_ns_s *ns,
3832	enum vport_ns_event event)
3833	{
3834	bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
3835	bfa_trc(ns->port->fcs, event);
3836
3837	switch (event) {
3838	case NSSM_EVENT_TIMEOUT:
3839	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_rnn_id);
3840	bfa_fcs_lport_ns_send_rnn_id(ns_cbarg: ns, NULL);
3841	break;
3842
3843	case NSSM_EVENT_PORT_OFFLINE:
3844	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
3845	bfa_timer_stop(timer: &ns->timer);
3846	break;
3847
3848	default:
3849	bfa_sm_fault(ns->port->fcs, event);
3850	}
3851	}
3852
3853	static void
3854	bfa_fcs_lport_ns_sm_sending_rsnn_nn(struct bfa_fcs_lport_ns_s *ns,
3855	enum vport_ns_event event)
3856	{
3857	bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
3858	bfa_trc(ns->port->fcs, event);
3859
3860	switch (event) {
3861	case NSSM_EVENT_RSNN_NN_SENT:
3862	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_rsnn_nn);
3863	break;
3864
3865	case NSSM_EVENT_PORT_OFFLINE:
3866	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
3867	bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ns->port),
3868	wqe: &ns->fcxp_wqe);
3869	break;
3870
3871	default:
3872	bfa_sm_fault(ns->port->fcs, event);
3873	}
3874	}
3875
3876	static void
3877	bfa_fcs_lport_ns_sm_rsnn_nn(struct bfa_fcs_lport_ns_s *ns,
3878	enum vport_ns_event event)
3879	{
3880	bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
3881	bfa_trc(ns->port->fcs, event);
3882
3883	switch (event) {
3884	case NSSM_EVENT_RSP_OK:
3885	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_rspn_id);
3886	ns->num_rsnn_nn_retries = 0;
3887	bfa_fcs_lport_ns_send_rspn_id(ns_cbarg: ns, NULL);
3888	break;
3889
3890	case NSSM_EVENT_RSP_ERROR:
3891	if (ns->num_rsnn_nn_retries < BFA_FCS_MAX_NS_RETRIES) {
3892	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_rsnn_nn_retry);
3893	ns->port->stats.ns_retries++;
3894	ns->num_rsnn_nn_retries++;
3895	bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ns->port),
3896	&ns->timer, bfa_fcs_lport_ns_timeout,
3897	ns, BFA_FCS_RETRY_TIMEOUT);
3898	} else {
3899	bfa_sm_set_state(ns,
3900	bfa_fcs_lport_ns_sm_sending_rspn_id);
3901	bfa_fcs_lport_ns_send_rspn_id(ns_cbarg: ns, NULL);
3902	}
3903	break;
3904
3905	case NSSM_EVENT_PORT_OFFLINE:
3906	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
3907	bfa_fcxp_discard(fcxp: ns->fcxp);
3908	break;
3909
3910	default:
3911	bfa_sm_fault(ns->port->fcs, event);
3912	}
3913	}
3914
3915	static void
3916	bfa_fcs_lport_ns_sm_rsnn_nn_retry(struct bfa_fcs_lport_ns_s *ns,
3917	enum vport_ns_event event)
3918	{
3919	bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
3920	bfa_trc(ns->port->fcs, event);
3921
3922	switch (event) {
3923	case NSSM_EVENT_TIMEOUT:
3924	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_rsnn_nn);
3925	bfa_fcs_lport_ns_send_rsnn_nn(ns_cbarg: ns, NULL);
3926	break;
3927
3928	case NSSM_EVENT_PORT_OFFLINE:
3929	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
3930	bfa_timer_stop(timer: &ns->timer);
3931	break;
3932
3933	default:
3934	bfa_sm_fault(ns->port->fcs, event);
3935	}
3936	}
3937
3938	static void
3939	bfa_fcs_lport_ns_sm_sending_rspn_id(struct bfa_fcs_lport_ns_s *ns,
3940	enum vport_ns_event event)
3941	{
3942	bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
3943	bfa_trc(ns->port->fcs, event);
3944
3945	switch (event) {
3946	case NSSM_EVENT_RSPNID_SENT:
3947	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_rspn_id);
3948	break;
3949
3950	case NSSM_EVENT_PORT_OFFLINE:
3951	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
3952	bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ns->port),
3953	wqe: &ns->fcxp_wqe);
3954	break;
3955
3956	default:
3957	bfa_sm_fault(ns->port->fcs, event);
3958	}
3959	}
3960
3961	static void
3962	bfa_fcs_lport_ns_sm_rspn_id(struct bfa_fcs_lport_ns_s *ns,
3963	enum vport_ns_event event)
3964	{
3965	bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
3966	bfa_trc(ns->port->fcs, event);
3967
3968	switch (event) {
3969	case NSSM_EVENT_RSP_ERROR:
3970	/*
3971	* Start timer for a delayed retry
3972	*/
3973	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_rspn_id_retry);
3974	ns->port->stats.ns_retries++;
3975	bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ns->port),
3976	&ns->timer, bfa_fcs_lport_ns_timeout, ns,
3977	BFA_FCS_RETRY_TIMEOUT);
3978	break;
3979
3980	case NSSM_EVENT_RSP_OK:
3981	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_rft_id);
3982	bfa_fcs_lport_ns_send_rft_id(ns_cbarg: ns, NULL);
3983	break;
3984
3985	case NSSM_EVENT_PORT_OFFLINE:
3986	bfa_fcxp_discard(fcxp: ns->fcxp);
3987	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
3988	break;
3989
3990	default:
3991	bfa_sm_fault(ns->port->fcs, event);
3992	}
3993	}
3994
3995	static void
3996	bfa_fcs_lport_ns_sm_rspn_id_retry(struct bfa_fcs_lport_ns_s *ns,
3997	enum vport_ns_event event)
3998	{
3999	bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
4000	bfa_trc(ns->port->fcs, event);
4001
4002	switch (event) {
4003	case NSSM_EVENT_TIMEOUT:
4004	/*
4005	* Retry Timer Expired. Re-send
4006	*/
4007	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_rspn_id);
4008	bfa_fcs_lport_ns_send_rspn_id(ns_cbarg: ns, NULL);
4009	break;
4010
4011	case NSSM_EVENT_PORT_OFFLINE:
4012	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
4013	bfa_timer_stop(timer: &ns->timer);
4014	break;
4015
4016	default:
4017	bfa_sm_fault(ns->port->fcs, event);
4018	}
4019	}
4020
4021	static void
4022	bfa_fcs_lport_ns_sm_sending_rft_id(struct bfa_fcs_lport_ns_s *ns,
4023	enum vport_ns_event event)
4024	{
4025	bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
4026	bfa_trc(ns->port->fcs, event);
4027
4028	switch (event) {
4029	case NSSM_EVENT_RFTID_SENT:
4030	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_rft_id);
4031	break;
4032
4033	case NSSM_EVENT_PORT_OFFLINE:
4034	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
4035	bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ns->port),
4036	wqe: &ns->fcxp_wqe);
4037	break;
4038
4039	default:
4040	bfa_sm_fault(ns->port->fcs, event);
4041	}
4042	}
4043
4044	static void
4045	bfa_fcs_lport_ns_sm_rft_id(struct bfa_fcs_lport_ns_s *ns,
4046	enum vport_ns_event event)
4047	{
4048	bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
4049	bfa_trc(ns->port->fcs, event);
4050
4051	switch (event) {
4052	case NSSM_EVENT_RSP_OK:
4053	/* Now move to register FC4 Features */
4054	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_rff_id);
4055	bfa_fcs_lport_ns_send_rff_id(ns_cbarg: ns, NULL);
4056	break;
4057
4058	case NSSM_EVENT_RSP_ERROR:
4059	/*
4060	* Start timer for a delayed retry
4061	*/
4062	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_rft_id_retry);
4063	ns->port->stats.ns_retries++;
4064	bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ns->port),
4065	&ns->timer, bfa_fcs_lport_ns_timeout, ns,
4066	BFA_FCS_RETRY_TIMEOUT);
4067	break;
4068
4069	case NSSM_EVENT_PORT_OFFLINE:
4070	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
4071	bfa_fcxp_discard(fcxp: ns->fcxp);
4072	break;
4073
4074	default:
4075	bfa_sm_fault(ns->port->fcs, event);
4076	}
4077	}
4078
4079	static void
4080	bfa_fcs_lport_ns_sm_rft_id_retry(struct bfa_fcs_lport_ns_s *ns,
4081	enum vport_ns_event event)
4082	{
4083	bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
4084	bfa_trc(ns->port->fcs, event);
4085
4086	switch (event) {
4087	case NSSM_EVENT_TIMEOUT:
4088	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_rft_id);
4089	bfa_fcs_lport_ns_send_rft_id(ns_cbarg: ns, NULL);
4090	break;
4091
4092	case NSSM_EVENT_PORT_OFFLINE:
4093	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
4094	bfa_timer_stop(timer: &ns->timer);
4095	break;
4096
4097	default:
4098	bfa_sm_fault(ns->port->fcs, event);
4099	}
4100	}
4101
4102	static void
4103	bfa_fcs_lport_ns_sm_sending_rff_id(struct bfa_fcs_lport_ns_s *ns,
4104	enum vport_ns_event event)
4105	{
4106	bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
4107	bfa_trc(ns->port->fcs, event);
4108
4109	switch (event) {
4110	case NSSM_EVENT_RFFID_SENT:
4111	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_rff_id);
4112	break;
4113
4114	case NSSM_EVENT_PORT_OFFLINE:
4115	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
4116	bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ns->port),
4117	wqe: &ns->fcxp_wqe);
4118	break;
4119
4120	default:
4121	bfa_sm_fault(ns->port->fcs, event);
4122	}
4123	}
4124
4125	static void
4126	bfa_fcs_lport_ns_sm_rff_id(struct bfa_fcs_lport_ns_s *ns,
4127	enum vport_ns_event event)
4128	{
4129	bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
4130	bfa_trc(ns->port->fcs, event);
4131
4132	switch (event) {
4133	case NSSM_EVENT_RSP_OK:
4134
4135	/*
4136	* If min cfg mode is enabled, we donot initiate rport
4137	* discovery with the fabric. Instead, we will retrieve the
4138	* boot targets from HAL/FW.
4139	*/
4140	if (__fcs_min_cfg(ns->port->fcs)) {
4141	bfa_fcs_lport_ns_boot_target_disc(port: ns->port);
4142	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_online);
4143	return;
4144	}
4145
4146	/*
4147	* If the port role is Initiator Mode issue NS query.
4148	* If it is Target Mode, skip this and go to online.
4149	*/
4150	if (BFA_FCS_VPORT_IS_INITIATOR_MODE(ns->port)) {
4151	bfa_sm_set_state(ns,
4152	bfa_fcs_lport_ns_sm_sending_gid_ft);
4153	bfa_fcs_lport_ns_send_gid_ft(ns_cbarg: ns, NULL);
4154	}
4155	/*
4156	* kick off mgmt srvr state machine
4157	*/
4158	bfa_fcs_lport_ms_online(port: ns->port);
4159	break;
4160
4161	case NSSM_EVENT_RSP_ERROR:
4162	/*
4163	* Start timer for a delayed retry
4164	*/
4165	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_rff_id_retry);
4166	ns->port->stats.ns_retries++;
4167	bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ns->port),
4168	&ns->timer, bfa_fcs_lport_ns_timeout, ns,
4169	BFA_FCS_RETRY_TIMEOUT);
4170	break;
4171
4172	case NSSM_EVENT_PORT_OFFLINE:
4173	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
4174	bfa_fcxp_discard(fcxp: ns->fcxp);
4175	break;
4176
4177	default:
4178	bfa_sm_fault(ns->port->fcs, event);
4179	}
4180	}
4181
4182	static void
4183	bfa_fcs_lport_ns_sm_rff_id_retry(struct bfa_fcs_lport_ns_s *ns,
4184	enum vport_ns_event event)
4185	{
4186	bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
4187	bfa_trc(ns->port->fcs, event);
4188
4189	switch (event) {
4190	case NSSM_EVENT_TIMEOUT:
4191	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_rff_id);
4192	bfa_fcs_lport_ns_send_rff_id(ns_cbarg: ns, NULL);
4193	break;
4194
4195	case NSSM_EVENT_PORT_OFFLINE:
4196	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
4197	bfa_timer_stop(timer: &ns->timer);
4198	break;
4199
4200	default:
4201	bfa_sm_fault(ns->port->fcs, event);
4202	}
4203	}
4204	static void
4205	bfa_fcs_lport_ns_sm_sending_gid_ft(struct bfa_fcs_lport_ns_s *ns,
4206	enum vport_ns_event event)
4207	{
4208	bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
4209	bfa_trc(ns->port->fcs, event);
4210
4211	switch (event) {
4212	case NSSM_EVENT_GIDFT_SENT:
4213	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_gid_ft);
4214	break;
4215
4216	case NSSM_EVENT_PORT_OFFLINE:
4217	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
4218	bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ns->port),
4219	wqe: &ns->fcxp_wqe);
4220	break;
4221
4222	default:
4223	bfa_sm_fault(ns->port->fcs, event);
4224	}
4225	}
4226
4227	static void
4228	bfa_fcs_lport_ns_sm_gid_ft(struct bfa_fcs_lport_ns_s *ns,
4229	enum vport_ns_event event)
4230	{
4231	bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
4232	bfa_trc(ns->port->fcs, event);
4233
4234	switch (event) {
4235	case NSSM_EVENT_RSP_OK:
4236	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_online);
4237	break;
4238
4239	case NSSM_EVENT_RSP_ERROR:
4240	/*
4241	* TBD: for certain reject codes, we don't need to retry
4242	*/
4243	/*
4244	* Start timer for a delayed retry
4245	*/
4246	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_gid_ft_retry);
4247	ns->port->stats.ns_retries++;
4248	bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ns->port),
4249	&ns->timer, bfa_fcs_lport_ns_timeout, ns,
4250	BFA_FCS_RETRY_TIMEOUT);
4251	break;
4252
4253	case NSSM_EVENT_PORT_OFFLINE:
4254	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
4255	bfa_fcxp_discard(fcxp: ns->fcxp);
4256	break;
4257
4258	case NSSM_EVENT_NS_QUERY:
4259	break;
4260
4261	default:
4262	bfa_sm_fault(ns->port->fcs, event);
4263	}
4264	}
4265
4266	static void
4267	bfa_fcs_lport_ns_sm_gid_ft_retry(struct bfa_fcs_lport_ns_s *ns,
4268	enum vport_ns_event event)
4269	{
4270	bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
4271	bfa_trc(ns->port->fcs, event);
4272
4273	switch (event) {
4274	case NSSM_EVENT_TIMEOUT:
4275	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_gid_ft);
4276	bfa_fcs_lport_ns_send_gid_ft(ns_cbarg: ns, NULL);
4277	break;
4278
4279	case NSSM_EVENT_PORT_OFFLINE:
4280	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
4281	bfa_timer_stop(timer: &ns->timer);
4282	break;
4283
4284	default:
4285	bfa_sm_fault(ns->port->fcs, event);
4286	}
4287	}
4288
4289	static void
4290	bfa_fcs_lport_ns_sm_online(struct bfa_fcs_lport_ns_s *ns,
4291	enum vport_ns_event event)
4292	{
4293	bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
4294	bfa_trc(ns->port->fcs, event);
4295
4296	switch (event) {
4297	case NSSM_EVENT_PORT_OFFLINE:
4298	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
4299	break;
4300
4301	case NSSM_EVENT_NS_QUERY:
4302	/*
4303	* If the port role is Initiator Mode issue NS query.
4304	* If it is Target Mode, skip this and go to online.
4305	*/
4306	if (BFA_FCS_VPORT_IS_INITIATOR_MODE(ns->port)) {
4307	bfa_sm_set_state(ns,
4308	bfa_fcs_lport_ns_sm_sending_gid_ft);
4309	bfa_fcs_lport_ns_send_gid_ft(ns_cbarg: ns, NULL);
4310	}
4311	break;
4312
4313	default:
4314	bfa_sm_fault(ns->port->fcs, event);
4315	}
4316	}
4317
4318
4319
4320	/*
4321	* ns_pvt Nameserver local functions
4322	*/
4323
4324	static void
4325	bfa_fcs_lport_ns_send_plogi(void *ns_cbarg, struct bfa_fcxp_s *fcxp_alloced)
4326	{
4327	struct bfa_fcs_lport_ns_s *ns = ns_cbarg;
4328	struct bfa_fcs_lport_s *port = ns->port;
4329	struct fchs_s fchs;
4330	int len;
4331	struct bfa_fcxp_s *fcxp;
4332
4333	bfa_trc(port->fcs, port->pid);
4334
4335	fcxp = fcxp_alloced ? fcxp_alloced :
4336	bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
4337	if (!fcxp) {
4338	port->stats.ns_plogi_alloc_wait++;
4339	bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe,
4340	bfa_fcs_lport_ns_send_plogi, ns, BFA_TRUE);
4341	return;
4342	}
4343	ns->fcxp = fcxp;
4344
4345	len = fc_plogi_build(fchs: &fchs, pld: bfa_fcxp_get_reqbuf(fcxp),
4346	bfa_hton3b(FC_NAME_SERVER),
4347	bfa_fcs_lport_get_fcid(port), ox_id: 0,
4348	port_name: port->port_cfg.pwwn, node_name: port->port_cfg.nwwn,
4349	pdu_size: bfa_fcport_get_maxfrsize(bfa: port->fcs->bfa),
4350	bb_cr: bfa_fcport_get_rx_bbcredit(bfa: port->fcs->bfa));
4351
4352	bfa_fcxp_send(fcxp, NULL, vf_id: port->fabric->vf_id, lp_tag: port->lp_tag, cts: BFA_FALSE,
4353	cos: FC_CLASS_3, reqlen: len, fchs: &fchs,
4354	cbfn: bfa_fcs_lport_ns_plogi_response, cbarg: (void *)ns,
4355	rsp_maxlen: FC_MAX_PDUSZ, FC_ELS_TOV);
4356	port->stats.ns_plogi_sent++;
4357
4358	bfa_sm_send_event(ns, NSSM_EVENT_PLOGI_SENT);
4359	}
4360
4361	static void
4362	bfa_fcs_lport_ns_plogi_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
4363	void *cbarg, bfa_status_t req_status, u32 rsp_len,
4364	u32 resid_len, struct fchs_s *rsp_fchs)
4365	{
4366	struct bfa_fcs_lport_ns_s *ns = (struct bfa_fcs_lport_ns_s *) cbarg;
4367	struct bfa_fcs_lport_s *port = ns->port;
4368	/* struct fc_logi_s *plogi_resp; */
4369	struct fc_els_cmd_s *els_cmd;
4370	struct fc_ls_rjt_s *ls_rjt;
4371
4372	bfa_trc(port->fcs, req_status);
4373	bfa_trc(port->fcs, port->port_cfg.pwwn);
4374
4375	/*
4376	* Sanity Checks
4377	*/
4378	if (req_status != BFA_STATUS_OK) {
4379	bfa_trc(port->fcs, req_status);
4380	port->stats.ns_plogi_rsp_err++;
4381	bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR);
4382	return;
4383	}
4384
4385	els_cmd = (struct fc_els_cmd_s *) BFA_FCXP_RSP_PLD(fcxp);
4386
4387	switch (els_cmd->els_code) {
4388
4389	case FC_ELS_ACC:
4390	if (rsp_len < sizeof(struct fc_logi_s)) {
4391	bfa_trc(port->fcs, rsp_len);
4392	port->stats.ns_plogi_acc_err++;
4393	bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR);
4394	break;
4395	}
4396	port->stats.ns_plogi_accepts++;
4397	bfa_sm_send_event(ns, NSSM_EVENT_RSP_OK);
4398	break;
4399
4400	case FC_ELS_LS_RJT:
4401	ls_rjt = (struct fc_ls_rjt_s *) BFA_FCXP_RSP_PLD(fcxp);
4402
4403	bfa_trc(port->fcs, ls_rjt->reason_code);
4404	bfa_trc(port->fcs, ls_rjt->reason_code_expl);
4405
4406	port->stats.ns_rejects++;
4407
4408	bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR);
4409	break;
4410
4411	default:
4412	port->stats.ns_plogi_unknown_rsp++;
4413	bfa_trc(port->fcs, els_cmd->els_code);
4414	bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR);
4415	}
4416	}
4417
4418	/*
4419	* Register node name for port_id
4420	*/
4421	static void
4422	bfa_fcs_lport_ns_send_rnn_id(void *ns_cbarg, struct bfa_fcxp_s *fcxp_alloced)
4423	{
4424	struct bfa_fcs_lport_ns_s *ns = ns_cbarg;
4425	struct bfa_fcs_lport_s *port = ns->port;
4426	struct fchs_s fchs;
4427	int len;
4428	struct bfa_fcxp_s *fcxp;
4429
4430	bfa_trc(port->fcs, port->port_cfg.pwwn);
4431
4432	fcxp = fcxp_alloced ? fcxp_alloced :
4433	bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
4434	if (!fcxp) {
4435	port->stats.ns_rnnid_alloc_wait++;
4436	bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe,
4437	bfa_fcs_lport_ns_send_rnn_id, ns, BFA_TRUE);
4438	return;
4439	}
4440
4441	ns->fcxp = fcxp;
4442
4443	len = fc_rnnid_build(fchs: &fchs, pyld: bfa_fcxp_get_reqbuf(fcxp),
4444	bfa_fcs_lport_get_fcid(port),
4445	bfa_fcs_lport_get_fcid(port),
4446	bfa_fcs_lport_get_nwwn(port));
4447
4448	bfa_fcxp_send(fcxp, NULL, vf_id: port->fabric->vf_id, lp_tag: port->lp_tag, cts: BFA_FALSE,
4449	cos: FC_CLASS_3, reqlen: len, fchs: &fchs,
4450	cbfn: bfa_fcs_lport_ns_rnn_id_response, cbarg: (void *)ns,
4451	rsp_maxlen: FC_MAX_PDUSZ, FC_FCCT_TOV);
4452
4453	port->stats.ns_rnnid_sent++;
4454	bfa_sm_send_event(ns, NSSM_EVENT_RNNID_SENT);
4455	}
4456
4457	static void
4458	bfa_fcs_lport_ns_rnn_id_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
4459	void *cbarg, bfa_status_t req_status,
4460	u32 rsp_len, u32 resid_len,
4461	struct fchs_s *rsp_fchs)
4462
4463	{
4464	struct bfa_fcs_lport_ns_s *ns = (struct bfa_fcs_lport_ns_s *) cbarg;
4465	struct bfa_fcs_lport_s *port = ns->port;
4466	struct ct_hdr_s *cthdr = NULL;
4467
4468	bfa_trc(port->fcs, port->port_cfg.pwwn);
4469
4470	/*
4471	* Sanity Checks
4472	*/
4473	if (req_status != BFA_STATUS_OK) {
4474	bfa_trc(port->fcs, req_status);
4475	port->stats.ns_rnnid_rsp_err++;
4476	bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR);
4477	return;
4478	}
4479
4480	cthdr = (struct ct_hdr_s *) BFA_FCXP_RSP_PLD(fcxp);
4481	cthdr->cmd_rsp_code = be16_to_cpu(cthdr->cmd_rsp_code);
4482
4483	if (cthdr->cmd_rsp_code == CT_RSP_ACCEPT) {
4484	port->stats.ns_rnnid_accepts++;
4485	bfa_sm_send_event(ns, NSSM_EVENT_RSP_OK);
4486	return;
4487	}
4488
4489	port->stats.ns_rnnid_rejects++;
4490	bfa_trc(port->fcs, cthdr->reason_code);
4491	bfa_trc(port->fcs, cthdr->exp_code);
4492	bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR);
4493	}
4494
4495	/*
4496	* Register the symbolic node name for a given node name.
4497	*/
4498	static void
4499	bfa_fcs_lport_ns_send_rsnn_nn(void *ns_cbarg, struct bfa_fcxp_s *fcxp_alloced)
4500	{
4501	struct bfa_fcs_lport_ns_s *ns = ns_cbarg;
4502	struct bfa_fcs_lport_s *port = ns->port;
4503	struct fchs_s fchs;
4504	int len;
4505	struct bfa_fcxp_s *fcxp;
4506	u8 *nsymbl;
4507
4508	bfa_trc(port->fcs, port->port_cfg.pwwn);
4509
4510	fcxp = fcxp_alloced ? fcxp_alloced :
4511	bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
4512	if (!fcxp) {
4513	port->stats.ns_rsnn_nn_alloc_wait++;
4514	bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe,
4515	bfa_fcs_lport_ns_send_rsnn_nn, ns, BFA_TRUE);
4516	return;
4517	}
4518	ns->fcxp = fcxp;
4519
4520	nsymbl = (u8 *) &(bfa_fcs_lport_get_nsym_name(
4521	bfa_fcs_get_base_port(port->fcs)));
4522
4523	len = fc_rsnn_nn_build(fchs: &fchs, pld: bfa_fcxp_get_reqbuf(fcxp),
4524	bfa_fcs_lport_get_fcid(port),
4525	bfa_fcs_lport_get_nwwn(port), name: nsymbl);
4526
4527	bfa_fcxp_send(fcxp, NULL, vf_id: port->fabric->vf_id, lp_tag: port->lp_tag, cts: BFA_FALSE,
4528	cos: FC_CLASS_3, reqlen: len, fchs: &fchs,
4529	cbfn: bfa_fcs_lport_ns_rsnn_nn_response, cbarg: (void *)ns,
4530	rsp_maxlen: FC_MAX_PDUSZ, FC_FCCT_TOV);
4531
4532	port->stats.ns_rsnn_nn_sent++;
4533
4534	bfa_sm_send_event(ns, NSSM_EVENT_RSNN_NN_SENT);
4535	}
4536
4537	static void
4538	bfa_fcs_lport_ns_rsnn_nn_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
4539	void *cbarg, bfa_status_t req_status,
4540	u32 rsp_len, u32 resid_len,
4541	struct fchs_s *rsp_fchs)
4542	{
4543	struct bfa_fcs_lport_ns_s *ns = (struct bfa_fcs_lport_ns_s *) cbarg;
4544	struct bfa_fcs_lport_s *port = ns->port;
4545	struct ct_hdr_s *cthdr = NULL;
4546
4547	bfa_trc(port->fcs, port->port_cfg.pwwn);
4548
4549	/*
4550	* Sanity Checks
4551	*/
4552	if (req_status != BFA_STATUS_OK) {
4553	bfa_trc(port->fcs, req_status);
4554	port->stats.ns_rsnn_nn_rsp_err++;
4555	bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR);
4556	return;
4557	}
4558
4559	cthdr = (struct ct_hdr_s *) BFA_FCXP_RSP_PLD(fcxp);
4560	cthdr->cmd_rsp_code = be16_to_cpu(cthdr->cmd_rsp_code);
4561
4562	if (cthdr->cmd_rsp_code == CT_RSP_ACCEPT) {
4563	port->stats.ns_rsnn_nn_accepts++;
4564	bfa_sm_send_event(ns, NSSM_EVENT_RSP_OK);
4565	return;
4566	}
4567
4568	port->stats.ns_rsnn_nn_rejects++;
4569	bfa_trc(port->fcs, cthdr->reason_code);
4570	bfa_trc(port->fcs, cthdr->exp_code);
4571	bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR);
4572	}
4573
4574	/*
4575	* Register the symbolic port name.
4576	*/
4577	static void
4578	bfa_fcs_lport_ns_send_rspn_id(void *ns_cbarg, struct bfa_fcxp_s *fcxp_alloced)
4579	{
4580	struct bfa_fcs_lport_ns_s *ns = ns_cbarg;
4581	struct bfa_fcs_lport_s *port = ns->port;
4582	struct fchs_s fchs;
4583	int len;
4584	struct bfa_fcxp_s *fcxp;
4585	u8 symbl[256];
4586	u8 *psymbl = &symbl[0];
4587
4588	memset(symbl, 0, sizeof(symbl));
4589
4590	bfa_trc(port->fcs, port->port_cfg.pwwn);
4591
4592	fcxp = fcxp_alloced ? fcxp_alloced :
4593	bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
4594	if (!fcxp) {
4595	port->stats.ns_rspnid_alloc_wait++;
4596	bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe,
4597	bfa_fcs_lport_ns_send_rspn_id, ns, BFA_TRUE);
4598	return;
4599	}
4600	ns->fcxp = fcxp;
4601
4602	/*
4603	* for V-Port, form a Port Symbolic Name
4604	*/
4605	if (port->vport) {
4606	/*
4607	* For Vports, we append the vport's port symbolic name
4608	* to that of the base port.
4609	*/
4610
4611	strscpy(symbl,
4612	(char *)&(bfa_fcs_lport_get_psym_name
4613	(bfa_fcs_get_base_port(port->fcs))),
4614	sizeof(symbl));
4615
4616	strlcat(p: symbl, q: (char *)&(bfa_fcs_lport_get_psym_name(port)),
4617	avail: sizeof(symbl));
4618	} else {
4619	psymbl = (u8 *) &(bfa_fcs_lport_get_psym_name(port));
4620	}
4621
4622	len = fc_rspnid_build(fchs: &fchs, pld: bfa_fcxp_get_reqbuf(fcxp),
4623	bfa_fcs_lport_get_fcid(port), ox_id: 0, name: psymbl);
4624
4625	bfa_fcxp_send(fcxp, NULL, vf_id: port->fabric->vf_id, lp_tag: port->lp_tag, cts: BFA_FALSE,
4626	cos: FC_CLASS_3, reqlen: len, fchs: &fchs,
4627	cbfn: bfa_fcs_lport_ns_rspn_id_response, cbarg: (void *)ns,
4628	rsp_maxlen: FC_MAX_PDUSZ, FC_FCCT_TOV);
4629
4630	port->stats.ns_rspnid_sent++;
4631
4632	bfa_sm_send_event(ns, NSSM_EVENT_RSPNID_SENT);
4633	}
4634
4635	static void
4636	bfa_fcs_lport_ns_rspn_id_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
4637	void *cbarg, bfa_status_t req_status,
4638	u32 rsp_len, u32 resid_len,
4639	struct fchs_s *rsp_fchs)
4640	{
4641	struct bfa_fcs_lport_ns_s *ns = (struct bfa_fcs_lport_ns_s *) cbarg;
4642	struct bfa_fcs_lport_s *port = ns->port;
4643	struct ct_hdr_s *cthdr = NULL;
4644
4645	bfa_trc(port->fcs, port->port_cfg.pwwn);
4646
4647	/*
4648	* Sanity Checks
4649	*/
4650	if (req_status != BFA_STATUS_OK) {
4651	bfa_trc(port->fcs, req_status);
4652	port->stats.ns_rspnid_rsp_err++;
4653	bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR);
4654	return;
4655	}
4656
4657	cthdr = (struct ct_hdr_s *) BFA_FCXP_RSP_PLD(fcxp);
4658	cthdr->cmd_rsp_code = be16_to_cpu(cthdr->cmd_rsp_code);
4659
4660	if (cthdr->cmd_rsp_code == CT_RSP_ACCEPT) {
4661	port->stats.ns_rspnid_accepts++;
4662	bfa_sm_send_event(ns, NSSM_EVENT_RSP_OK);
4663	return;
4664	}
4665
4666	port->stats.ns_rspnid_rejects++;
4667	bfa_trc(port->fcs, cthdr->reason_code);
4668	bfa_trc(port->fcs, cthdr->exp_code);
4669	bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR);
4670	}
4671
4672	/*
4673	* Register FC4-Types
4674	*/
4675	static void
4676	bfa_fcs_lport_ns_send_rft_id(void *ns_cbarg, struct bfa_fcxp_s *fcxp_alloced)
4677	{
4678	struct bfa_fcs_lport_ns_s *ns = ns_cbarg;
4679	struct bfa_fcs_lport_s *port = ns->port;
4680	struct fchs_s fchs;
4681	int len;
4682	struct bfa_fcxp_s *fcxp;
4683
4684	bfa_trc(port->fcs, port->port_cfg.pwwn);
4685
4686	fcxp = fcxp_alloced ? fcxp_alloced :
4687	bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
4688	if (!fcxp) {
4689	port->stats.ns_rftid_alloc_wait++;
4690	bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe,
4691	bfa_fcs_lport_ns_send_rft_id, ns, BFA_TRUE);
4692	return;
4693	}
4694	ns->fcxp = fcxp;
4695
4696	len = fc_rftid_build(fchs: &fchs, pld: bfa_fcxp_get_reqbuf(fcxp),
4697	bfa_fcs_lport_get_fcid(port), ox_id: 0, role: port->port_cfg.roles);
4698
4699	bfa_fcxp_send(fcxp, NULL, vf_id: port->fabric->vf_id, lp_tag: port->lp_tag, cts: BFA_FALSE,
4700	cos: FC_CLASS_3, reqlen: len, fchs: &fchs,
4701	cbfn: bfa_fcs_lport_ns_rft_id_response, cbarg: (void *)ns,
4702	rsp_maxlen: FC_MAX_PDUSZ, FC_FCCT_TOV);
4703
4704	port->stats.ns_rftid_sent++;
4705	bfa_sm_send_event(ns, NSSM_EVENT_RFTID_SENT);
4706	}
4707
4708	static void
4709	bfa_fcs_lport_ns_rft_id_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
4710	void *cbarg, bfa_status_t req_status,
4711	u32 rsp_len, u32 resid_len,
4712	struct fchs_s *rsp_fchs)
4713	{
4714	struct bfa_fcs_lport_ns_s *ns = (struct bfa_fcs_lport_ns_s *) cbarg;
4715	struct bfa_fcs_lport_s *port = ns->port;
4716	struct ct_hdr_s *cthdr = NULL;
4717
4718	bfa_trc(port->fcs, port->port_cfg.pwwn);
4719
4720	/*
4721	* Sanity Checks
4722	*/
4723	if (req_status != BFA_STATUS_OK) {
4724	bfa_trc(port->fcs, req_status);
4725	port->stats.ns_rftid_rsp_err++;
4726	bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR);
4727	return;
4728	}
4729
4730	cthdr = (struct ct_hdr_s *) BFA_FCXP_RSP_PLD(fcxp);
4731	cthdr->cmd_rsp_code = be16_to_cpu(cthdr->cmd_rsp_code);
4732
4733	if (cthdr->cmd_rsp_code == CT_RSP_ACCEPT) {
4734	port->stats.ns_rftid_accepts++;
4735	bfa_sm_send_event(ns, NSSM_EVENT_RSP_OK);
4736	return;
4737	}
4738
4739	port->stats.ns_rftid_rejects++;
4740	bfa_trc(port->fcs, cthdr->reason_code);
4741	bfa_trc(port->fcs, cthdr->exp_code);
4742	bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR);
4743	}
4744
4745	/*
4746	* Register FC4-Features : Should be done after RFT_ID
4747	*/
4748	static void
4749	bfa_fcs_lport_ns_send_rff_id(void *ns_cbarg, struct bfa_fcxp_s *fcxp_alloced)
4750	{
4751	struct bfa_fcs_lport_ns_s *ns = ns_cbarg;
4752	struct bfa_fcs_lport_s *port = ns->port;
4753	struct fchs_s fchs;
4754	int len;
4755	struct bfa_fcxp_s *fcxp;
4756	u8 fc4_ftrs = 0;
4757
4758	bfa_trc(port->fcs, port->port_cfg.pwwn);
4759
4760	fcxp = fcxp_alloced ? fcxp_alloced :
4761	bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
4762	if (!fcxp) {
4763	port->stats.ns_rffid_alloc_wait++;
4764	bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe,
4765	bfa_fcs_lport_ns_send_rff_id, ns, BFA_TRUE);
4766	return;
4767	}
4768	ns->fcxp = fcxp;
4769
4770	if (BFA_FCS_VPORT_IS_INITIATOR_MODE(ns->port))
4771	fc4_ftrs = FC_GS_FCP_FC4_FEATURE_INITIATOR;
4772
4773	len = fc_rffid_build(fchs: &fchs, pyld: bfa_fcxp_get_reqbuf(fcxp),
4774	bfa_fcs_lport_get_fcid(port), ox_id: 0,
4775	fc4_type: FC_TYPE_FCP, fc4_ftrs);
4776
4777	bfa_fcxp_send(fcxp, NULL, vf_id: port->fabric->vf_id, lp_tag: port->lp_tag, cts: BFA_FALSE,
4778	cos: FC_CLASS_3, reqlen: len, fchs: &fchs,
4779	cbfn: bfa_fcs_lport_ns_rff_id_response, cbarg: (void *)ns,
4780	rsp_maxlen: FC_MAX_PDUSZ, FC_FCCT_TOV);
4781
4782	port->stats.ns_rffid_sent++;
4783	bfa_sm_send_event(ns, NSSM_EVENT_RFFID_SENT);
4784	}
4785
4786	static void
4787	bfa_fcs_lport_ns_rff_id_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
4788	void *cbarg, bfa_status_t req_status,
4789	u32 rsp_len, u32 resid_len,
4790	struct fchs_s *rsp_fchs)
4791	{
4792	struct bfa_fcs_lport_ns_s *ns = (struct bfa_fcs_lport_ns_s *) cbarg;
4793	struct bfa_fcs_lport_s *port = ns->port;
4794	struct ct_hdr_s *cthdr = NULL;
4795
4796	bfa_trc(port->fcs, port->port_cfg.pwwn);
4797
4798	/*
4799	* Sanity Checks
4800	*/
4801	if (req_status != BFA_STATUS_OK) {
4802	bfa_trc(port->fcs, req_status);
4803	port->stats.ns_rffid_rsp_err++;
4804	bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR);
4805	return;
4806	}
4807
4808	cthdr = (struct ct_hdr_s *) BFA_FCXP_RSP_PLD(fcxp);
4809	cthdr->cmd_rsp_code = be16_to_cpu(cthdr->cmd_rsp_code);
4810
4811	if (cthdr->cmd_rsp_code == CT_RSP_ACCEPT) {
4812	port->stats.ns_rffid_accepts++;
4813	bfa_sm_send_event(ns, NSSM_EVENT_RSP_OK);
4814	return;
4815	}
4816
4817	port->stats.ns_rffid_rejects++;
4818	bfa_trc(port->fcs, cthdr->reason_code);
4819	bfa_trc(port->fcs, cthdr->exp_code);
4820
4821	if (cthdr->reason_code == CT_RSN_NOT_SUPP) {
4822	/* if this command is not supported, we don't retry */
4823	bfa_sm_send_event(ns, NSSM_EVENT_RSP_OK);
4824	} else
4825	bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR);
4826	}
4827	/*
4828	* Query Fabric for FC4-Types Devices.
4829	*
4830	* TBD : Need to use a local (FCS private) response buffer, since the response
4831	* can be larger than 2K.
4832	*/
4833	static void
4834	bfa_fcs_lport_ns_send_gid_ft(void *ns_cbarg, struct bfa_fcxp_s *fcxp_alloced)
4835	{
4836	struct bfa_fcs_lport_ns_s *ns = ns_cbarg;
4837	struct bfa_fcs_lport_s *port = ns->port;
4838	struct fchs_s fchs;
4839	int len;
4840	struct bfa_fcxp_s *fcxp;
4841
4842	bfa_trc(port->fcs, port->pid);
4843
4844	fcxp = fcxp_alloced ? fcxp_alloced :
4845	bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
4846	if (!fcxp) {
4847	port->stats.ns_gidft_alloc_wait++;
4848	bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe,
4849	bfa_fcs_lport_ns_send_gid_ft, ns, BFA_TRUE);
4850	return;
4851	}
4852	ns->fcxp = fcxp;
4853
4854	/*
4855	* This query is only initiated for FCP initiator mode.
4856	*/
4857	len = fc_gid_ft_build(fchs: &fchs, pld: bfa_fcxp_get_reqbuf(fcxp),
4858	s_id: ns->port->pid, fc4_type: FC_TYPE_FCP);
4859
4860	bfa_fcxp_send(fcxp, NULL, vf_id: port->fabric->vf_id, lp_tag: port->lp_tag, cts: BFA_FALSE,
4861	cos: FC_CLASS_3, reqlen: len, fchs: &fchs,
4862	cbfn: bfa_fcs_lport_ns_gid_ft_response, cbarg: (void *)ns,
4863	rsp_maxlen: bfa_fcxp_get_maxrsp(bfa: port->fcs->bfa), FC_FCCT_TOV);
4864
4865	port->stats.ns_gidft_sent++;
4866
4867	bfa_sm_send_event(ns, NSSM_EVENT_GIDFT_SENT);
4868	}
4869
4870	static void
4871	bfa_fcs_lport_ns_gid_ft_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
4872	void *cbarg, bfa_status_t req_status,
4873	u32 rsp_len, u32 resid_len,
4874	struct fchs_s *rsp_fchs)
4875	{
4876	struct bfa_fcs_lport_ns_s *ns = (struct bfa_fcs_lport_ns_s *) cbarg;
4877	struct bfa_fcs_lport_s *port = ns->port;
4878	struct ct_hdr_s *cthdr = NULL;
4879	u32 n_pids;
4880
4881	bfa_trc(port->fcs, port->port_cfg.pwwn);
4882
4883	/*
4884	* Sanity Checks
4885	*/
4886	if (req_status != BFA_STATUS_OK) {
4887	bfa_trc(port->fcs, req_status);
4888	port->stats.ns_gidft_rsp_err++;
4889	bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR);
4890	return;
4891	}
4892
4893	if (resid_len != 0) {
4894	/*
4895	* TBD : we will need to allocate a larger buffer & retry the
4896	* command
4897	*/
4898	bfa_trc(port->fcs, rsp_len);
4899	bfa_trc(port->fcs, resid_len);
4900	return;
4901	}
4902
4903	cthdr = (struct ct_hdr_s *) BFA_FCXP_RSP_PLD(fcxp);
4904	cthdr->cmd_rsp_code = be16_to_cpu(cthdr->cmd_rsp_code);
4905
4906	switch (cthdr->cmd_rsp_code) {
4907
4908	case CT_RSP_ACCEPT:
4909
4910	port->stats.ns_gidft_accepts++;
4911	n_pids = (fc_get_ctresp_pyld_len(resp_len: rsp_len) / sizeof(u32));
4912	bfa_trc(port->fcs, n_pids);
4913	bfa_fcs_lport_ns_process_gidft_pids(port,
4914	pid_buf: (u32 *) (cthdr + 1),
4915	n_pids);
4916	bfa_sm_send_event(ns, NSSM_EVENT_RSP_OK);
4917	break;
4918
4919	case CT_RSP_REJECT:
4920
4921	/*
4922	* Check the reason code & explanation.
4923	* There may not have been any FC4 devices in the fabric
4924	*/
4925	port->stats.ns_gidft_rejects++;
4926	bfa_trc(port->fcs, cthdr->reason_code);
4927	bfa_trc(port->fcs, cthdr->exp_code);
4928
4929	if ((cthdr->reason_code == CT_RSN_UNABLE_TO_PERF)
4930	&& (cthdr->exp_code == CT_NS_EXP_FT_NOT_REG)) {
4931
4932	bfa_sm_send_event(ns, NSSM_EVENT_RSP_OK);
4933	} else {
4934	/*
4935	* for all other errors, retry
4936	*/
4937	bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR);
4938	}
4939	break;
4940
4941	default:
4942	port->stats.ns_gidft_unknown_rsp++;
4943	bfa_trc(port->fcs, cthdr->cmd_rsp_code);
4944	bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR);
4945	}
4946	}
4947
4948	/*
4949	* This routine will be called by bfa_timer on timer timeouts.
4950	*
4951	* param[in] port - pointer to bfa_fcs_lport_t.
4952	*
4953	* return
4954	* void
4955	*
4956	* Special Considerations:
4957	*
4958	* note
4959	*/
4960	static void
4961	bfa_fcs_lport_ns_timeout(void *arg)
4962	{
4963	struct bfa_fcs_lport_ns_s *ns = (struct bfa_fcs_lport_ns_s *) arg;
4964
4965	ns->port->stats.ns_timeouts++;
4966	bfa_sm_send_event(ns, NSSM_EVENT_TIMEOUT);
4967	}
4968
4969	/*
4970	* Process the PID list in GID_FT response
4971	*/
4972	static void
4973	bfa_fcs_lport_ns_process_gidft_pids(struct bfa_fcs_lport_s *port, u32 *pid_buf,
4974	u32 n_pids)
4975	{
4976	struct fcgs_gidft_resp_s *gidft_entry;
4977	struct bfa_fcs_rport_s *rport;
4978	u32 ii;
4979	struct bfa_fcs_fabric_s *fabric = port->fabric;
4980	struct bfa_fcs_vport_s *vport;
4981	struct list_head *qe;
4982	u8 found = 0;
4983
4984	for (ii = 0; ii < n_pids; ii++) {
4985	gidft_entry = (struct fcgs_gidft_resp_s *) &pid_buf[ii];
4986
4987	if (gidft_entry->pid == port->pid)
4988	continue;
4989
4990	/*
4991	* Ignore PID if it is of base port
4992	* (Avoid vports discovering base port as remote port)
4993	*/
4994	if (gidft_entry->pid == fabric->bport.pid)
4995	continue;
4996
4997	/*
4998	* Ignore PID if it is of vport created on the same base port
4999	* (Avoid vport discovering every other vport created on the
5000	* same port as remote port)
5001	*/
5002	list_for_each(qe, &fabric->vport_q) {
5003	vport = (struct bfa_fcs_vport_s *) qe;
5004	if (vport->lport.pid == gidft_entry->pid)
5005	found = 1;
5006	}
5007
5008	if (found) {
5009	found = 0;
5010	continue;
5011	}
5012
5013	/*
5014	* Check if this rport already exists
5015	*/
5016	rport = bfa_fcs_lport_get_rport_by_pid(port, pid: gidft_entry->pid);
5017	if (rport == NULL) {
5018	/*
5019	* this is a new device. create rport
5020	*/
5021	rport = bfa_fcs_rport_create(port, pid: gidft_entry->pid);
5022	} else {
5023	/*
5024	* this rport already exists
5025	*/
5026	bfa_fcs_rport_scn(rport);
5027	}
5028
5029	bfa_trc(port->fcs, gidft_entry->pid);
5030
5031	/*
5032	* if the last entry bit is set, bail out.
5033	*/
5034	if (gidft_entry->last)
5035	return;
5036	}
5037	}
5038
5039	/*
5040	* fcs_ns_public FCS nameserver public interfaces
5041	*/
5042
5043	/*
5044	* Functions called by port/fab.
5045	* These will send relevant Events to the ns state machine.
5046	*/
5047	void
5048	bfa_fcs_lport_ns_init(struct bfa_fcs_lport_s *port)
5049	{
5050	struct bfa_fcs_lport_ns_s *ns = BFA_FCS_GET_NS_FROM_PORT(port);
5051
5052	ns->port = port;
5053	bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
5054	}
5055
5056	void
5057	bfa_fcs_lport_ns_offline(struct bfa_fcs_lport_s *port)
5058	{
5059	struct bfa_fcs_lport_ns_s *ns = BFA_FCS_GET_NS_FROM_PORT(port);
5060
5061	ns->port = port;
5062	bfa_sm_send_event(ns, NSSM_EVENT_PORT_OFFLINE);
5063	}
5064
5065	void
5066	bfa_fcs_lport_ns_online(struct bfa_fcs_lport_s *port)
5067	{
5068	struct bfa_fcs_lport_ns_s *ns = BFA_FCS_GET_NS_FROM_PORT(port);
5069
5070	ns->port = port;
5071	bfa_sm_send_event(ns, NSSM_EVENT_PORT_ONLINE);
5072	}
5073
5074	void
5075	bfa_fcs_lport_ns_query(struct bfa_fcs_lport_s *port)
5076	{
5077	struct bfa_fcs_lport_ns_s *ns = BFA_FCS_GET_NS_FROM_PORT(port);
5078
5079	bfa_trc(port->fcs, port->pid);
5080	if (bfa_sm_cmp_state(ns, bfa_fcs_lport_ns_sm_online))
5081	bfa_sm_send_event(ns, NSSM_EVENT_NS_QUERY);
5082	}
5083
5084	static void
5085	bfa_fcs_lport_ns_boot_target_disc(bfa_fcs_lport_t *port)
5086	{
5087
5088	struct bfa_fcs_rport_s *rport;
5089	u8 nwwns;
5090	wwn_t wwns[BFA_PREBOOT_BOOTLUN_MAX];
5091	int ii;
5092
5093	bfa_iocfc_get_bootwwns(bfa: port->fcs->bfa, nwwns: &nwwns, wwns);
5094
5095	for (ii = 0 ; ii < nwwns; ++ii) {
5096	rport = bfa_fcs_rport_create_by_wwn(port, wwn: wwns[ii]);
5097	WARN_ON(!rport);
5098	}
5099	}
5100
5101	void
5102	bfa_fcs_lport_ns_util_send_rspn_id(void *cbarg, struct bfa_fcxp_s *fcxp_alloced)
5103	{
5104	struct bfa_fcs_lport_ns_s *ns = cbarg;
5105	struct bfa_fcs_lport_s *port = ns->port;
5106	struct fchs_s fchs;
5107	struct bfa_fcxp_s *fcxp;
5108	u8 symbl[256];
5109	int len;
5110
5111	/* Avoid sending RSPN in the following states. */
5112	if (bfa_sm_cmp_state(ns, bfa_fcs_lport_ns_sm_offline) ||
5113	bfa_sm_cmp_state(ns, bfa_fcs_lport_ns_sm_plogi_sending) ||
5114	bfa_sm_cmp_state(ns, bfa_fcs_lport_ns_sm_plogi) ||
5115	bfa_sm_cmp_state(ns, bfa_fcs_lport_ns_sm_plogi_retry) ||
5116	bfa_sm_cmp_state(ns, bfa_fcs_lport_ns_sm_rspn_id_retry))
5117	return;
5118
5119	memset(symbl, 0, sizeof(symbl));
5120	bfa_trc(port->fcs, port->port_cfg.pwwn);
5121
5122	fcxp = fcxp_alloced ? fcxp_alloced :
5123	bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE);
5124	if (!fcxp) {
5125	port->stats.ns_rspnid_alloc_wait++;
5126	bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe,
5127	bfa_fcs_lport_ns_util_send_rspn_id, ns, BFA_FALSE);
5128	return;
5129	}
5130
5131	ns->fcxp = fcxp;
5132
5133	if (port->vport) {
5134	/*
5135	* For Vports, we append the vport's port symbolic name
5136	* to that of the base port.
5137	*/
5138	strscpy(symbl, (char *)&(bfa_fcs_lport_get_psym_name
5139	(bfa_fcs_get_base_port(port->fcs))),
5140	sizeof(symbl));
5141
5142	strlcat(p: symbl,
5143	q: (char *)&(bfa_fcs_lport_get_psym_name(port)),
5144	avail: sizeof(symbl));
5145	}
5146
5147	len = fc_rspnid_build(fchs: &fchs, pld: bfa_fcxp_get_reqbuf(fcxp),
5148	bfa_fcs_lport_get_fcid(port), ox_id: 0, name: symbl);
5149
5150	bfa_fcxp_send(fcxp, NULL, vf_id: port->fabric->vf_id, lp_tag: port->lp_tag, cts: BFA_FALSE,
5151	cos: FC_CLASS_3, reqlen: len, fchs: &fchs, NULL, NULL, rsp_maxlen: FC_MAX_PDUSZ, rsp_timeout: 0);
5152
5153	port->stats.ns_rspnid_sent++;
5154	}
5155
5156	/*
5157	* FCS SCN
5158	*/
5159
5160	#define FC_QOS_RSCN_EVENT 0x0c
5161	#define FC_FABRIC_NAME_RSCN_EVENT 0x0d
5162
5163	/*
5164	* forward declarations
5165	*/
5166	static void bfa_fcs_lport_scn_send_scr(void *scn_cbarg,
5167	struct bfa_fcxp_s *fcxp_alloced);
5168	static void bfa_fcs_lport_scn_scr_response(void *fcsarg,
5169	struct bfa_fcxp_s *fcxp,
5170	void *cbarg,
5171	bfa_status_t req_status,
5172	u32 rsp_len,
5173	u32 resid_len,
5174	struct fchs_s *rsp_fchs);
5175	static void bfa_fcs_lport_scn_send_ls_acc(struct bfa_fcs_lport_s *port,
5176	struct fchs_s *rx_fchs);
5177	static void bfa_fcs_lport_scn_timeout(void *arg);
5178
5179	/*
5180	* fcs_scm_sm FCS SCN state machine
5181	*/
5182
5183	static void bfa_fcs_lport_scn_sm_offline(struct bfa_fcs_lport_scn_s *scn,
5184	enum port_scn_event event);
5185	static void bfa_fcs_lport_scn_sm_sending_scr(
5186	struct bfa_fcs_lport_scn_s *scn,
5187	enum port_scn_event event);
5188	static void bfa_fcs_lport_scn_sm_scr(struct bfa_fcs_lport_scn_s *scn,
5189	enum port_scn_event event);
5190	static void bfa_fcs_lport_scn_sm_scr_retry(struct bfa_fcs_lport_scn_s *scn,
5191	enum port_scn_event event);
5192	static void bfa_fcs_lport_scn_sm_online(struct bfa_fcs_lport_scn_s *scn,
5193	enum port_scn_event event);
5194
5195	/*
5196	* Starting state - awaiting link up.
5197	*/
5198	static void
5199	bfa_fcs_lport_scn_sm_offline(struct bfa_fcs_lport_scn_s *scn,
5200	enum port_scn_event event)
5201	{
5202	switch (event) {
5203	case SCNSM_EVENT_PORT_ONLINE:
5204	bfa_sm_set_state(scn, bfa_fcs_lport_scn_sm_sending_scr);
5205	bfa_fcs_lport_scn_send_scr(scn_cbarg: scn, NULL);
5206	break;
5207
5208	case SCNSM_EVENT_PORT_OFFLINE:
5209	break;
5210
5211	default:
5212	bfa_sm_fault(scn->port->fcs, event);
5213	}
5214	}
5215
5216	static void
5217	bfa_fcs_lport_scn_sm_sending_scr(struct bfa_fcs_lport_scn_s *scn,
5218	enum port_scn_event event)
5219	{
5220	switch (event) {
5221	case SCNSM_EVENT_SCR_SENT:
5222	bfa_sm_set_state(scn, bfa_fcs_lport_scn_sm_scr);
5223	break;
5224
5225	case SCNSM_EVENT_PORT_OFFLINE:
5226	bfa_sm_set_state(scn, bfa_fcs_lport_scn_sm_offline);
5227	bfa_fcxp_walloc_cancel(bfa: scn->port->fcs->bfa, wqe: &scn->fcxp_wqe);
5228	break;
5229
5230	default:
5231	bfa_sm_fault(scn->port->fcs, event);
5232	}
5233	}
5234
5235	static void
5236	bfa_fcs_lport_scn_sm_scr(struct bfa_fcs_lport_scn_s *scn,
5237	enum port_scn_event event)
5238	{
5239	struct bfa_fcs_lport_s *port = scn->port;
5240
5241	switch (event) {
5242	case SCNSM_EVENT_RSP_OK:
5243	bfa_sm_set_state(scn, bfa_fcs_lport_scn_sm_online);
5244	break;
5245
5246	case SCNSM_EVENT_RSP_ERROR:
5247	bfa_sm_set_state(scn, bfa_fcs_lport_scn_sm_scr_retry);
5248	bfa_timer_start(port->fcs->bfa, &scn->timer,
5249	bfa_fcs_lport_scn_timeout, scn,
5250	BFA_FCS_RETRY_TIMEOUT);
5251	break;
5252
5253	case SCNSM_EVENT_PORT_OFFLINE:
5254	bfa_sm_set_state(scn, bfa_fcs_lport_scn_sm_offline);
5255	bfa_fcxp_discard(fcxp: scn->fcxp);
5256	break;
5257
5258	default:
5259	bfa_sm_fault(port->fcs, event);
5260	}
5261	}
5262
5263	static void
5264	bfa_fcs_lport_scn_sm_scr_retry(struct bfa_fcs_lport_scn_s *scn,
5265	enum port_scn_event event)
5266	{
5267	switch (event) {
5268	case SCNSM_EVENT_TIMEOUT:
5269	bfa_sm_set_state(scn, bfa_fcs_lport_scn_sm_sending_scr);
5270	bfa_fcs_lport_scn_send_scr(scn_cbarg: scn, NULL);
5271	break;
5272
5273	case SCNSM_EVENT_PORT_OFFLINE:
5274	bfa_sm_set_state(scn, bfa_fcs_lport_scn_sm_offline);
5275	bfa_timer_stop(timer: &scn->timer);
5276	break;
5277
5278	default:
5279	bfa_sm_fault(scn->port->fcs, event);
5280	}
5281	}
5282
5283	static void
5284	bfa_fcs_lport_scn_sm_online(struct bfa_fcs_lport_scn_s *scn,
5285	enum port_scn_event event)
5286	{
5287	switch (event) {
5288	case SCNSM_EVENT_PORT_OFFLINE:
5289	bfa_sm_set_state(scn, bfa_fcs_lport_scn_sm_offline);
5290	break;
5291
5292	default:
5293	bfa_sm_fault(scn->port->fcs, event);
5294	}
5295	}
5296
5297
5298
5299	/*
5300	* fcs_scn_private FCS SCN private functions
5301	*/
5302
5303	/*
5304	* This routine will be called to send a SCR command.
5305	*/
5306	static void
5307	bfa_fcs_lport_scn_send_scr(void *scn_cbarg, struct bfa_fcxp_s *fcxp_alloced)
5308	{
5309	struct bfa_fcs_lport_scn_s *scn = scn_cbarg;
5310	struct bfa_fcs_lport_s *port = scn->port;
5311	struct fchs_s fchs;
5312	int len;
5313	struct bfa_fcxp_s *fcxp;
5314
5315	bfa_trc(port->fcs, port->pid);
5316	bfa_trc(port->fcs, port->port_cfg.pwwn);
5317
5318	fcxp = fcxp_alloced ? fcxp_alloced :
5319	bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
5320	if (!fcxp) {
5321	bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &scn->fcxp_wqe,
5322	bfa_fcs_lport_scn_send_scr, scn, BFA_TRUE);
5323	return;
5324	}
5325	scn->fcxp = fcxp;
5326
5327	/* Handle VU registrations for Base port only */
5328	if ((!port->vport) && bfa_ioc_get_fcmode(&port->fcs->bfa->ioc)) {
5329	len = fc_scr_build(fchs: &fchs, scr: bfa_fcxp_get_reqbuf(fcxp),
5330	set_br_reg: port->fabric->lps->brcd_switch,
5331	s_id: port->pid, ox_id: 0);
5332	} else {
5333	len = fc_scr_build(fchs: &fchs, scr: bfa_fcxp_get_reqbuf(fcxp),
5334	set_br_reg: BFA_FALSE,
5335	s_id: port->pid, ox_id: 0);
5336	}
5337
5338	bfa_fcxp_send(fcxp, NULL, vf_id: port->fabric->vf_id, lp_tag: port->lp_tag, cts: BFA_FALSE,
5339	cos: FC_CLASS_3, reqlen: len, fchs: &fchs,
5340	cbfn: bfa_fcs_lport_scn_scr_response,
5341	cbarg: (void *)scn, rsp_maxlen: FC_MAX_PDUSZ, FC_ELS_TOV);
5342
5343	bfa_sm_send_event(scn, SCNSM_EVENT_SCR_SENT);
5344	}
5345
5346	static void
5347	bfa_fcs_lport_scn_scr_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
5348	void *cbarg, bfa_status_t req_status, u32 rsp_len,
5349	u32 resid_len, struct fchs_s *rsp_fchs)
5350	{
5351	struct bfa_fcs_lport_scn_s *scn = (struct bfa_fcs_lport_scn_s *) cbarg;
5352	struct bfa_fcs_lport_s *port = scn->port;
5353	struct fc_els_cmd_s *els_cmd;
5354	struct fc_ls_rjt_s *ls_rjt;
5355
5356	bfa_trc(port->fcs, port->port_cfg.pwwn);
5357
5358	/*
5359	* Sanity Checks
5360	*/
5361	if (req_status != BFA_STATUS_OK) {
5362	bfa_trc(port->fcs, req_status);
5363	bfa_sm_send_event(scn, SCNSM_EVENT_RSP_ERROR);
5364	return;
5365	}
5366
5367	els_cmd = (struct fc_els_cmd_s *) BFA_FCXP_RSP_PLD(fcxp);
5368
5369	switch (els_cmd->els_code) {
5370
5371	case FC_ELS_ACC:
5372	bfa_sm_send_event(scn, SCNSM_EVENT_RSP_OK);
5373	break;
5374
5375	case FC_ELS_LS_RJT:
5376
5377	ls_rjt = (struct fc_ls_rjt_s *) BFA_FCXP_RSP_PLD(fcxp);
5378
5379	bfa_trc(port->fcs, ls_rjt->reason_code);
5380	bfa_trc(port->fcs, ls_rjt->reason_code_expl);
5381
5382	bfa_sm_send_event(scn, SCNSM_EVENT_RSP_ERROR);
5383	break;
5384
5385	default:
5386	bfa_sm_send_event(scn, SCNSM_EVENT_RSP_ERROR);
5387	}
5388	}
5389
5390	/*
5391	* Send a LS Accept
5392	*/
5393	static void
5394	bfa_fcs_lport_scn_send_ls_acc(struct bfa_fcs_lport_s *port,
5395	struct fchs_s *rx_fchs)
5396	{
5397	struct fchs_s fchs;
5398	struct bfa_fcxp_s *fcxp;
5399	struct bfa_rport_s *bfa_rport = NULL;
5400	int len;
5401
5402	bfa_trc(port->fcs, rx_fchs->s_id);
5403
5404	fcxp = bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE);
5405	if (!fcxp)
5406	return;
5407
5408	len = fc_ls_acc_build(fchs: &fchs, els_cmd: bfa_fcxp_get_reqbuf(fcxp),
5409	d_id: rx_fchs->s_id, bfa_fcs_lport_get_fcid(port),
5410	ox_id: rx_fchs->ox_id);
5411
5412	bfa_fcxp_send(fcxp, rport: bfa_rport, vf_id: port->fabric->vf_id, lp_tag: port->lp_tag,
5413	cts: BFA_FALSE, cos: FC_CLASS_3, reqlen: len, fchs: &fchs, NULL, NULL,
5414	rsp_maxlen: FC_MAX_PDUSZ, rsp_timeout: 0);
5415	}
5416
5417	/*
5418	* This routine will be called by bfa_timer on timer timeouts.
5419	*
5420	* param[in] vport - pointer to bfa_fcs_lport_t.
5421	* param[out] vport_status - pointer to return vport status in
5422	*
5423	* return
5424	* void
5425	*
5426	* Special Considerations:
5427	*
5428	* note
5429	*/
5430	static void
5431	bfa_fcs_lport_scn_timeout(void *arg)
5432	{
5433	struct bfa_fcs_lport_scn_s *scn = (struct bfa_fcs_lport_scn_s *) arg;
5434
5435	bfa_sm_send_event(scn, SCNSM_EVENT_TIMEOUT);
5436	}
5437
5438
5439
5440	/*
5441	* fcs_scn_public FCS state change notification public interfaces
5442	*/
5443
5444	/*
5445	* Functions called by port/fab
5446	*/
5447	void
5448	bfa_fcs_lport_scn_init(struct bfa_fcs_lport_s *port)
5449	{
5450	struct bfa_fcs_lport_scn_s *scn = BFA_FCS_GET_SCN_FROM_PORT(port);
5451
5452	scn->port = port;
5453	bfa_sm_set_state(scn, bfa_fcs_lport_scn_sm_offline);
5454	}
5455
5456	void
5457	bfa_fcs_lport_scn_offline(struct bfa_fcs_lport_s *port)
5458	{
5459	struct bfa_fcs_lport_scn_s *scn = BFA_FCS_GET_SCN_FROM_PORT(port);
5460
5461	scn->port = port;
5462	bfa_sm_send_event(scn, SCNSM_EVENT_PORT_OFFLINE);
5463	}
5464
5465	void
5466	bfa_fcs_lport_fab_scn_online(struct bfa_fcs_lport_s *port)
5467	{
5468	struct bfa_fcs_lport_scn_s *scn = BFA_FCS_GET_SCN_FROM_PORT(port);
5469
5470	scn->port = port;
5471	bfa_sm_send_event(scn, SCNSM_EVENT_PORT_ONLINE);
5472	}
5473
5474	static void
5475	bfa_fcs_lport_scn_portid_rscn(struct bfa_fcs_lport_s *port, u32 rpid)
5476	{
5477	struct bfa_fcs_rport_s *rport;
5478	struct bfa_fcs_fabric_s *fabric = port->fabric;
5479	struct bfa_fcs_vport_s *vport;
5480	struct list_head *qe;
5481
5482	bfa_trc(port->fcs, rpid);
5483
5484	/*
5485	* Ignore PID if it is of base port or of vports created on the
5486	* same base port. It is to avoid vports discovering base port or
5487	* other vports created on same base port as remote port
5488	*/
5489	if (rpid == fabric->bport.pid)
5490	return;
5491
5492	list_for_each(qe, &fabric->vport_q) {
5493	vport = (struct bfa_fcs_vport_s *) qe;
5494	if (vport->lport.pid == rpid)
5495	return;
5496	}
5497	/*
5498	* If this is an unknown device, then it just came online.
5499	* Otherwise let rport handle the RSCN event.
5500	*/
5501	rport = bfa_fcs_lport_get_rport_by_pid(port, pid: rpid);
5502	if (!rport)
5503	rport = bfa_fcs_lport_get_rport_by_old_pid(port, pid: rpid);
5504
5505	if (rport == NULL) {
5506	/*
5507	* If min cfg mode is enabled, we donot need to
5508	* discover any new rports.
5509	*/
5510	if (!__fcs_min_cfg(port->fcs))
5511	rport = bfa_fcs_rport_create(port, pid: rpid);
5512	} else
5513	bfa_fcs_rport_scn(rport);
5514	}
5515
5516	/*
5517	* rscn format based PID comparison
5518	*/
5519	#define __fc_pid_match(__c0, __c1, __fmt) \
5520	(((__fmt) == FC_RSCN_FORMAT_FABRIC) || \
5521	(((__fmt) == FC_RSCN_FORMAT_DOMAIN) && \
5522	((__c0)[0] == (__c1)[0])) || \
5523	(((__fmt) == FC_RSCN_FORMAT_AREA) && \
5524	((__c0)[0] == (__c1)[0]) && \
5525	((__c0)[1] == (__c1)[1])))
5526
5527	static void
5528	bfa_fcs_lport_scn_multiport_rscn(struct bfa_fcs_lport_s *port,
5529	enum fc_rscn_format format,
5530	u32 rscn_pid)
5531	{
5532	struct bfa_fcs_rport_s *rport;
5533	struct list_head *qe, *qe_next;
5534	u8 *c0, *c1;
5535
5536	bfa_trc(port->fcs, format);
5537	bfa_trc(port->fcs, rscn_pid);
5538
5539	c0 = (u8 *) &rscn_pid;
5540
5541	list_for_each_safe(qe, qe_next, &port->rport_q) {
5542	rport = (struct bfa_fcs_rport_s *) qe;
5543	c1 = (u8 *) &rport->pid;
5544	if (__fc_pid_match(c0, c1, format))
5545	bfa_fcs_rport_scn(rport);
5546	}
5547	}
5548
5549
5550	void
5551	bfa_fcs_lport_scn_process_rscn(struct bfa_fcs_lport_s *port,
5552	struct fchs_s *fchs, u32 len)
5553	{
5554	struct fc_rscn_pl_s *rscn = (struct fc_rscn_pl_s *) (fchs + 1);
5555	int num_entries;
5556	u32 rscn_pid;
5557	bfa_boolean_t nsquery = BFA_FALSE, found;
5558	int i = 0, j;
5559
5560	num_entries =
5561	(be16_to_cpu(rscn->payldlen) -
5562	sizeof(u32)) / sizeof(rscn->event[0]);
5563
5564	bfa_trc(port->fcs, num_entries);
5565
5566	port->stats.num_rscn++;
5567
5568	bfa_fcs_lport_scn_send_ls_acc(port, rx_fchs: fchs);
5569
5570	for (i = 0; i < num_entries; i++) {
5571	rscn_pid = rscn->event[i].portid;
5572
5573	bfa_trc(port->fcs, rscn->event[i].format);
5574	bfa_trc(port->fcs, rscn_pid);
5575
5576	/* check for duplicate entries in the list */
5577	found = BFA_FALSE;
5578	for (j = 0; j < i; j++) {
5579	if (rscn->event[j].portid == rscn_pid) {
5580	found = BFA_TRUE;
5581	break;
5582	}
5583	}
5584
5585	/* if found in down the list, pid has been already processed */
5586	if (found) {
5587	bfa_trc(port->fcs, rscn_pid);
5588	continue;
5589	}
5590
5591	switch (rscn->event[i].format) {
5592	case FC_RSCN_FORMAT_PORTID:
5593	if (rscn->event[i].qualifier == FC_QOS_RSCN_EVENT) {
5594	/*
5595	* Ignore this event.
5596	* f/w would have processed it
5597	*/
5598	bfa_trc(port->fcs, rscn_pid);
5599	} else {
5600	port->stats.num_portid_rscn++;
5601	bfa_fcs_lport_scn_portid_rscn(port, rpid: rscn_pid);
5602	}
5603	break;
5604
5605	case FC_RSCN_FORMAT_FABRIC:
5606	if (rscn->event[i].qualifier ==
5607	FC_FABRIC_NAME_RSCN_EVENT) {
5608	bfa_fcs_lport_ms_fabric_rscn(port);
5609	break;
5610	}
5611	fallthrough;
5612
5613	case FC_RSCN_FORMAT_AREA:
5614	case FC_RSCN_FORMAT_DOMAIN:
5615	nsquery = BFA_TRUE;
5616	bfa_fcs_lport_scn_multiport_rscn(port,
5617	format: rscn->event[i].format,
5618	rscn_pid);
5619	break;
5620
5621
5622	default:
5623	WARN_ON(1);
5624	nsquery = BFA_TRUE;
5625	}
5626	}
5627
5628	/*
5629	* If any of area, domain or fabric RSCN is received, do a fresh
5630	* discovery to find new devices.
5631	*/
5632	if (nsquery)
5633	bfa_fcs_lport_ns_query(port);
5634	}
5635
5636	/*
5637	* BFA FCS port
5638	*/
5639	/*
5640	* fcs_port_api BFA FCS port API
5641	*/
5642	struct bfa_fcs_lport_s *
5643	bfa_fcs_get_base_port(struct bfa_fcs_s *fcs)
5644	{
5645	return &fcs->fabric.bport;
5646	}
5647
5648	wwn_t
5649	bfa_fcs_lport_get_rport(struct bfa_fcs_lport_s *port, wwn_t wwn, int index,
5650	int nrports, bfa_boolean_t bwwn)
5651	{
5652	struct list_head *qh, *qe;
5653	struct bfa_fcs_rport_s *rport = NULL;
5654	int i;
5655	struct bfa_fcs_s *fcs;
5656
5657	if (port == NULL || nrports == 0)
5658	return (wwn_t) 0;
5659
5660	fcs = port->fcs;
5661	bfa_trc(fcs, (u32) nrports);
5662
5663	i = 0;
5664	qh = &port->rport_q;
5665	qe = bfa_q_first(qh);
5666
5667	while ((qe != qh) && (i < nrports)) {
5668	rport = (struct bfa_fcs_rport_s *) qe;
5669	if (bfa_ntoh3b(rport->pid) > 0xFFF000) {
5670	qe = bfa_q_next(qe);
5671	bfa_trc(fcs, (u32) rport->pwwn);
5672	bfa_trc(fcs, rport->pid);
5673	bfa_trc(fcs, i);
5674	continue;
5675	}
5676
5677	if (bwwn) {
5678	if (!memcmp(p: &wwn, q: &rport->pwwn, size: 8))
5679	break;
5680	} else {
5681	if (i == index)
5682	break;
5683	}
5684
5685	i++;
5686	qe = bfa_q_next(qe);
5687	}
5688
5689	bfa_trc(fcs, i);
5690	if (rport)
5691	return rport->pwwn;
5692	else
5693	return (wwn_t) 0;
5694	}
5695
5696	void
5697	bfa_fcs_lport_get_rport_quals(struct bfa_fcs_lport_s *port,
5698	struct bfa_rport_qualifier_s rports[], int *nrports)
5699	{
5700	struct list_head *qh, *qe;
5701	struct bfa_fcs_rport_s *rport = NULL;
5702	int i;
5703	struct bfa_fcs_s *fcs;
5704
5705	if (port == NULL || rports == NULL || *nrports == 0)
5706	return;
5707
5708	fcs = port->fcs;
5709	bfa_trc(fcs, (u32) *nrports);
5710
5711	i = 0;
5712	qh = &port->rport_q;
5713	qe = bfa_q_first(qh);
5714
5715	while ((qe != qh) && (i < *nrports)) {
5716	rport = (struct bfa_fcs_rport_s *) qe;
5717	if (bfa_ntoh3b(rport->pid) > 0xFFF000) {
5718	qe = bfa_q_next(qe);
5719	bfa_trc(fcs, (u32) rport->pwwn);
5720	bfa_trc(fcs, rport->pid);
5721	bfa_trc(fcs, i);
5722	continue;
5723	}
5724
5725	if (!rport->pwwn && !rport->pid) {
5726	qe = bfa_q_next(qe);
5727	continue;
5728	}
5729
5730	rports[i].pwwn = rport->pwwn;
5731	rports[i].pid = rport->pid;
5732
5733	i++;
5734	qe = bfa_q_next(qe);
5735	}
5736
5737	bfa_trc(fcs, i);
5738	*nrports = i;
5739	}
5740
5741	/*
5742	* Iterate's through all the rport's in the given port to
5743	* determine the maximum operating speed.
5744	*
5745	* !!!! To be used in TRL Functionality only !!!!
5746	*/
5747	bfa_port_speed_t
5748	bfa_fcs_lport_get_rport_max_speed(bfa_fcs_lport_t *port)
5749	{
5750	struct list_head *qh, *qe;
5751	struct bfa_fcs_rport_s *rport = NULL;
5752	struct bfa_fcs_s *fcs;
5753	bfa_port_speed_t max_speed = 0;
5754	struct bfa_port_attr_s port_attr;
5755	bfa_port_speed_t port_speed, rport_speed;
5756	bfa_boolean_t trl_enabled;
5757
5758	if (port == NULL)
5759	return 0;
5760
5761	fcs = port->fcs;
5762	trl_enabled = bfa_fcport_is_ratelim(bfa: port->fcs->bfa);
5763
5764	/* Get Physical port's current speed */
5765	bfa_fcport_get_attr(bfa: port->fcs->bfa, attr: &port_attr);
5766	port_speed = port_attr.speed;
5767	bfa_trc(fcs, port_speed);
5768
5769	qh = &port->rport_q;
5770	qe = bfa_q_first(qh);
5771
5772	while (qe != qh) {
5773	rport = (struct bfa_fcs_rport_s *) qe;
5774	if ((bfa_ntoh3b(rport->pid) > 0xFFF000) ||
5775	(bfa_fcs_rport_get_state(rport) == BFA_RPORT_OFFLINE) ||
5776	(rport->scsi_function != BFA_RPORT_TARGET)) {
5777	qe = bfa_q_next(qe);
5778	continue;
5779	}
5780
5781	rport_speed = rport->rpf.rpsc_speed;
5782	if ((trl_enabled) && (rport_speed ==
5783	BFA_PORT_SPEED_UNKNOWN)) {
5784	/* Use default ratelim speed setting */
5785	rport_speed =
5786	bfa_fcport_get_ratelim_speed(bfa: port->fcs->bfa);
5787	}
5788
5789	if (rport_speed > max_speed)
5790	max_speed = rport_speed;
5791
5792	qe = bfa_q_next(qe);
5793	}
5794
5795	if (max_speed > port_speed)
5796	max_speed = port_speed;
5797
5798	bfa_trc(fcs, max_speed);
5799	return max_speed;
5800	}
5801
5802	struct bfa_fcs_lport_s *
5803	bfa_fcs_lookup_port(struct bfa_fcs_s *fcs, u16 vf_id, wwn_t lpwwn)
5804	{
5805	struct bfa_fcs_vport_s *vport;
5806	bfa_fcs_vf_t *vf;
5807
5808	WARN_ON(fcs == NULL);
5809
5810	vf = bfa_fcs_vf_lookup(fcs, vf_id);
5811	if (vf == NULL) {
5812	bfa_trc(fcs, vf_id);
5813	return NULL;
5814	}
5815
5816	if (!lpwwn || (vf->bport.port_cfg.pwwn == lpwwn))
5817	return &vf->bport;
5818
5819	vport = bfa_fcs_fabric_vport_lookup(fabric: vf, pwwn: lpwwn);
5820	if (vport)
5821	return &vport->lport;
5822
5823	return NULL;
5824	}
5825
5826	/*
5827	* API corresponding to NPIV_VPORT_GETINFO.
5828	*/
5829	void
5830	bfa_fcs_lport_get_info(struct bfa_fcs_lport_s *port,
5831	struct bfa_lport_info_s *port_info)
5832	{
5833
5834	bfa_trc(port->fcs, port->fabric->fabric_name);
5835
5836	if (port->vport == NULL) {
5837	/*
5838	* This is a Physical port
5839	*/
5840	port_info->port_type = BFA_LPORT_TYPE_PHYSICAL;
5841
5842	/*
5843	* @todo : need to fix the state & reason
5844	*/
5845	port_info->port_state = 0;
5846	port_info->offline_reason = 0;
5847
5848	port_info->port_wwn = bfa_fcs_lport_get_pwwn(port);
5849	port_info->node_wwn = bfa_fcs_lport_get_nwwn(port);
5850
5851	port_info->max_vports_supp =
5852	bfa_lps_get_max_vport(bfa: port->fcs->bfa);
5853	port_info->num_vports_inuse =
5854	port->fabric->num_vports;
5855	port_info->max_rports_supp = BFA_FCS_MAX_RPORTS_SUPP;
5856	port_info->num_rports_inuse = port->num_rports;
5857	} else {
5858	/*
5859	* This is a virtual port
5860	*/
5861	port_info->port_type = BFA_LPORT_TYPE_VIRTUAL;
5862
5863	/*
5864	* @todo : need to fix the state & reason
5865	*/
5866	port_info->port_state = 0;
5867	port_info->offline_reason = 0;
5868
5869	port_info->port_wwn = bfa_fcs_lport_get_pwwn(port);
5870	port_info->node_wwn = bfa_fcs_lport_get_nwwn(port);
5871	}
5872	}
5873
5874	void
5875	bfa_fcs_lport_get_stats(struct bfa_fcs_lport_s *fcs_port,
5876	struct bfa_lport_stats_s *port_stats)
5877	{
5878	*port_stats = fcs_port->stats;
5879	}
5880
5881	void
5882	bfa_fcs_lport_clear_stats(struct bfa_fcs_lport_s *fcs_port)
5883	{
5884	memset(&fcs_port->stats, 0, sizeof(struct bfa_lport_stats_s));
5885	}
5886
5887	/*
5888	* Let new loop map create missing rports
5889	*/
5890	void
5891	bfa_fcs_lport_lip_scn_online(struct bfa_fcs_lport_s *port)
5892	{
5893	bfa_fcs_lport_loop_online(port);
5894	}
5895
5896	/*
5897	* FCS virtual port state machine
5898	*/
5899
5900	#define __vport_fcs(__vp) ((__vp)->lport.fcs)
5901	#define __vport_pwwn(__vp) ((__vp)->lport.port_cfg.pwwn)
5902	#define __vport_nwwn(__vp) ((__vp)->lport.port_cfg.nwwn)
5903	#define __vport_bfa(__vp) ((__vp)->lport.fcs->bfa)
5904	#define __vport_fcid(__vp) ((__vp)->lport.pid)
5905	#define __vport_fabric(__vp) ((__vp)->lport.fabric)
5906	#define __vport_vfid(__vp) ((__vp)->lport.fabric->vf_id)
5907
5908	#define BFA_FCS_VPORT_MAX_RETRIES 5
5909	/*
5910	* Forward declarations
5911	*/
5912	static void bfa_fcs_vport_do_fdisc(struct bfa_fcs_vport_s *vport);
5913	static void bfa_fcs_vport_timeout(void *vport_arg);
5914	static void bfa_fcs_vport_do_logo(struct bfa_fcs_vport_s *vport);
5915	static void bfa_fcs_vport_free(struct bfa_fcs_vport_s *vport);
5916
5917	/*
5918	* fcs_vport_sm FCS virtual port state machine
5919	*/
5920
5921	static void bfa_fcs_vport_sm_uninit(struct bfa_fcs_vport_s *vport,
5922	enum bfa_fcs_vport_event event);
5923	static void bfa_fcs_vport_sm_created(struct bfa_fcs_vport_s *vport,
5924	enum bfa_fcs_vport_event event);
5925	static void bfa_fcs_vport_sm_offline(struct bfa_fcs_vport_s *vport,
5926	enum bfa_fcs_vport_event event);
5927	static void bfa_fcs_vport_sm_fdisc(struct bfa_fcs_vport_s *vport,
5928	enum bfa_fcs_vport_event event);
5929	static void bfa_fcs_vport_sm_fdisc_retry(struct bfa_fcs_vport_s *vport,
5930	enum bfa_fcs_vport_event event);
5931	static void bfa_fcs_vport_sm_fdisc_rsp_wait(struct bfa_fcs_vport_s *vport,
5932	enum bfa_fcs_vport_event event);
5933	static void bfa_fcs_vport_sm_online(struct bfa_fcs_vport_s *vport,
5934	enum bfa_fcs_vport_event event);
5935	static void bfa_fcs_vport_sm_deleting(struct bfa_fcs_vport_s *vport,
5936	enum bfa_fcs_vport_event event);
5937	static void bfa_fcs_vport_sm_cleanup(struct bfa_fcs_vport_s *vport,
5938	enum bfa_fcs_vport_event event);
5939	static void bfa_fcs_vport_sm_logo(struct bfa_fcs_vport_s *vport,
5940	enum bfa_fcs_vport_event event);
5941	static void bfa_fcs_vport_sm_error(struct bfa_fcs_vport_s *vport,
5942	enum bfa_fcs_vport_event event);
5943	static void bfa_fcs_vport_sm_stopping(struct bfa_fcs_vport_s *vport,
5944	enum bfa_fcs_vport_event event);
5945	static void bfa_fcs_vport_sm_logo_for_stop(struct bfa_fcs_vport_s *vport,
5946	enum bfa_fcs_vport_event event);
5947
5948	struct bfa_fcs_vport_sm_table_s {
5949	bfa_fcs_vport_sm_t sm; /* state machine function */
5950	enum bfa_vport_state state; /* state machine encoding */
5951	char *name; /* state name for display */
5952	};
5953
5954	static inline enum bfa_vport_state
5955	bfa_vport_sm_to_state(struct bfa_fcs_vport_sm_table_s *smt, bfa_fcs_vport_sm_t sm)
5956	{
5957	int i = 0;
5958
5959	while (smt[i].sm && smt[i].sm != sm)
5960	i++;
5961	return smt[i].state;
5962	}
5963
5964	static struct bfa_fcs_vport_sm_table_s vport_sm_table[] = {
5965	{BFA_SM(bfa_fcs_vport_sm_uninit), BFA_FCS_VPORT_UNINIT},
5966	{BFA_SM(bfa_fcs_vport_sm_created), BFA_FCS_VPORT_CREATED},
5967	{BFA_SM(bfa_fcs_vport_sm_offline), BFA_FCS_VPORT_OFFLINE},
5968	{BFA_SM(bfa_fcs_vport_sm_fdisc), BFA_FCS_VPORT_FDISC},
5969	{BFA_SM(bfa_fcs_vport_sm_fdisc_retry), BFA_FCS_VPORT_FDISC_RETRY},
5970	{BFA_SM(bfa_fcs_vport_sm_fdisc_rsp_wait), BFA_FCS_VPORT_FDISC_RSP_WAIT},
5971	{BFA_SM(bfa_fcs_vport_sm_online), BFA_FCS_VPORT_ONLINE},
5972	{BFA_SM(bfa_fcs_vport_sm_deleting), BFA_FCS_VPORT_DELETING},
5973	{BFA_SM(bfa_fcs_vport_sm_cleanup), BFA_FCS_VPORT_CLEANUP},
5974	{BFA_SM(bfa_fcs_vport_sm_logo), BFA_FCS_VPORT_LOGO},
5975	{BFA_SM(bfa_fcs_vport_sm_error), BFA_FCS_VPORT_ERROR}
5976	};
5977
5978	/*
5979	* Beginning state.
5980	*/
5981	static void
5982	bfa_fcs_vport_sm_uninit(struct bfa_fcs_vport_s *vport,
5983	enum bfa_fcs_vport_event event)
5984	{
5985	bfa_trc(__vport_fcs(vport), __vport_pwwn(vport));
5986	bfa_trc(__vport_fcs(vport), event);
5987
5988	switch (event) {
5989	case BFA_FCS_VPORT_SM_CREATE:
5990	bfa_sm_set_state(vport, bfa_fcs_vport_sm_created);
5991	bfa_fcs_fabric_addvport(__vport_fabric(vport), vport);
5992	break;
5993
5994	default:
5995	bfa_sm_fault(__vport_fcs(vport), event);
5996	}
5997	}
5998
5999	/*
6000	* Created state - a start event is required to start up the state machine.
6001	*/
6002	static void
6003	bfa_fcs_vport_sm_created(struct bfa_fcs_vport_s *vport,
6004	enum bfa_fcs_vport_event event)
6005	{
6006	bfa_trc(__vport_fcs(vport), __vport_pwwn(vport));
6007	bfa_trc(__vport_fcs(vport), event);
6008
6009	switch (event) {
6010	case BFA_FCS_VPORT_SM_START:
6011	if (bfa_sm_cmp_state(__vport_fabric(vport),
6012	bfa_fcs_fabric_sm_online)
6013	&& bfa_fcs_fabric_npiv_capable(__vport_fabric(vport))) {
6014	bfa_sm_set_state(vport, bfa_fcs_vport_sm_fdisc);
6015	bfa_fcs_vport_do_fdisc(vport);
6016	} else {
6017	/*
6018	* Fabric is offline or not NPIV capable, stay in
6019	* offline state.
6020	*/
6021	vport->vport_stats.fab_no_npiv++;
6022	bfa_sm_set_state(vport, bfa_fcs_vport_sm_offline);
6023	}
6024	break;
6025
6026	case BFA_FCS_VPORT_SM_DELETE:
6027	bfa_sm_set_state(vport, bfa_fcs_vport_sm_cleanup);
6028	bfa_fcs_lport_delete(port: &vport->lport);
6029	break;
6030
6031	case BFA_FCS_VPORT_SM_ONLINE:
6032	case BFA_FCS_VPORT_SM_OFFLINE:
6033	/*
6034	* Ignore ONLINE/OFFLINE events from fabric
6035	* till vport is started.
6036	*/
6037	break;
6038
6039	default:
6040	bfa_sm_fault(__vport_fcs(vport), event);
6041	}
6042	}
6043
6044	/*
6045	* Offline state - awaiting ONLINE event from fabric SM.
6046	*/
6047	static void
6048	bfa_fcs_vport_sm_offline(struct bfa_fcs_vport_s *vport,
6049	enum bfa_fcs_vport_event event)
6050	{
6051	bfa_trc(__vport_fcs(vport), __vport_pwwn(vport));
6052	bfa_trc(__vport_fcs(vport), event);
6053
6054	switch (event) {
6055	case BFA_FCS_VPORT_SM_DELETE:
6056	bfa_sm_set_state(vport, bfa_fcs_vport_sm_cleanup);
6057	bfa_fcs_lport_delete(port: &vport->lport);
6058	break;
6059
6060	case BFA_FCS_VPORT_SM_ONLINE:
6061	bfa_sm_set_state(vport, bfa_fcs_vport_sm_fdisc);
6062	vport->fdisc_retries = 0;
6063	bfa_fcs_vport_do_fdisc(vport);
6064	break;
6065
6066	case BFA_FCS_VPORT_SM_STOP:
6067	bfa_sm_set_state(vport, bfa_fcs_vport_sm_cleanup);
6068	bfa_sm_send_event(&vport->lport, BFA_FCS_PORT_SM_STOP);
6069	break;
6070
6071	case BFA_FCS_VPORT_SM_OFFLINE:
6072	/*
6073	* This can happen if the vport couldn't be initialzied
6074	* due the fact that the npiv was not enabled on the switch.
6075	* In that case we will put the vport in offline state.
6076	* However, the link can go down and cause the this event to
6077	* be sent when we are already offline. Ignore it.
6078	*/
6079	break;
6080
6081	default:
6082	bfa_sm_fault(__vport_fcs(vport), event);
6083	}
6084	}
6085
6086
6087	/*
6088	* FDISC is sent and awaiting reply from fabric.
6089	*/
6090	static void
6091	bfa_fcs_vport_sm_fdisc(struct bfa_fcs_vport_s *vport,
6092	enum bfa_fcs_vport_event event)
6093	{
6094	bfa_trc(__vport_fcs(vport), __vport_pwwn(vport));
6095	bfa_trc(__vport_fcs(vport), event);
6096
6097	switch (event) {
6098	case BFA_FCS_VPORT_SM_DELETE:
6099	bfa_sm_set_state(vport, bfa_fcs_vport_sm_fdisc_rsp_wait);
6100	break;
6101
6102	case BFA_FCS_VPORT_SM_OFFLINE:
6103	bfa_sm_set_state(vport, bfa_fcs_vport_sm_offline);
6104	bfa_sm_send_event(vport->lps, BFA_LPS_SM_OFFLINE);
6105	break;
6106
6107	case BFA_FCS_VPORT_SM_RSP_OK:
6108	bfa_sm_set_state(vport, bfa_fcs_vport_sm_online);
6109	bfa_fcs_lport_online(port: &vport->lport);
6110	break;
6111
6112	case BFA_FCS_VPORT_SM_RSP_ERROR:
6113	bfa_sm_set_state(vport, bfa_fcs_vport_sm_fdisc_retry);
6114	bfa_timer_start(__vport_bfa(vport), &vport->timer,
6115	bfa_fcs_vport_timeout, vport,
6116	BFA_FCS_RETRY_TIMEOUT);
6117	break;
6118
6119	case BFA_FCS_VPORT_SM_RSP_FAILED:
6120	case BFA_FCS_VPORT_SM_FABRIC_MAX:
6121	bfa_sm_set_state(vport, bfa_fcs_vport_sm_offline);
6122	break;
6123
6124	case BFA_FCS_VPORT_SM_RSP_DUP_WWN:
6125	bfa_sm_set_state(vport, bfa_fcs_vport_sm_error);
6126	break;
6127
6128	default:
6129	bfa_sm_fault(__vport_fcs(vport), event);
6130	}
6131	}
6132
6133	/*
6134	* FDISC attempt failed - a timer is active to retry FDISC.
6135	*/
6136	static void
6137	bfa_fcs_vport_sm_fdisc_retry(struct bfa_fcs_vport_s *vport,
6138	enum bfa_fcs_vport_event event)
6139	{
6140	bfa_trc(__vport_fcs(vport), __vport_pwwn(vport));
6141	bfa_trc(__vport_fcs(vport), event);
6142
6143	switch (event) {
6144	case BFA_FCS_VPORT_SM_DELETE:
6145	bfa_sm_set_state(vport, bfa_fcs_vport_sm_cleanup);
6146	bfa_timer_stop(timer: &vport->timer);
6147	bfa_fcs_lport_delete(port: &vport->lport);
6148	break;
6149
6150	case BFA_FCS_VPORT_SM_OFFLINE:
6151	bfa_sm_set_state(vport, bfa_fcs_vport_sm_offline);
6152	bfa_timer_stop(timer: &vport->timer);
6153	break;
6154
6155	case BFA_FCS_VPORT_SM_TIMEOUT:
6156	bfa_sm_set_state(vport, bfa_fcs_vport_sm_fdisc);
6157	vport->vport_stats.fdisc_retries++;
6158	vport->fdisc_retries++;
6159	bfa_fcs_vport_do_fdisc(vport);
6160	break;
6161
6162	default:
6163	bfa_sm_fault(__vport_fcs(vport), event);
6164	}
6165	}
6166
6167	/*
6168	* FDISC is in progress and we got a vport delete request -
6169	* this is a wait state while we wait for fdisc response and
6170	* we will transition to the appropriate state - on rsp status.
6171	*/
6172	static void
6173	bfa_fcs_vport_sm_fdisc_rsp_wait(struct bfa_fcs_vport_s *vport,
6174	enum bfa_fcs_vport_event event)
6175	{
6176	bfa_trc(__vport_fcs(vport), __vport_pwwn(vport));
6177	bfa_trc(__vport_fcs(vport), event);
6178
6179	switch (event) {
6180	case BFA_FCS_VPORT_SM_RSP_OK:
6181	bfa_sm_set_state(vport, bfa_fcs_vport_sm_deleting);
6182	bfa_fcs_lport_delete(port: &vport->lport);
6183	break;
6184
6185	case BFA_FCS_VPORT_SM_DELETE:
6186	break;
6187
6188	case BFA_FCS_VPORT_SM_OFFLINE:
6189	case BFA_FCS_VPORT_SM_RSP_ERROR:
6190	case BFA_FCS_VPORT_SM_RSP_FAILED:
6191	case BFA_FCS_VPORT_SM_FABRIC_MAX:
6192	case BFA_FCS_VPORT_SM_RSP_DUP_WWN:
6193	bfa_sm_set_state(vport, bfa_fcs_vport_sm_cleanup);
6194	bfa_sm_send_event(vport->lps, BFA_LPS_SM_OFFLINE);
6195	bfa_fcs_lport_delete(port: &vport->lport);
6196	break;
6197
6198	default:
6199	bfa_sm_fault(__vport_fcs(vport), event);
6200	}
6201	}
6202
6203	/*
6204	* Vport is online (FDISC is complete).
6205	*/
6206	static void
6207	bfa_fcs_vport_sm_online(struct bfa_fcs_vport_s *vport,
6208	enum bfa_fcs_vport_event event)
6209	{
6210	bfa_trc(__vport_fcs(vport), __vport_pwwn(vport));
6211	bfa_trc(__vport_fcs(vport), event);
6212
6213	switch (event) {
6214	case BFA_FCS_VPORT_SM_DELETE:
6215	bfa_sm_set_state(vport, bfa_fcs_vport_sm_deleting);
6216	bfa_fcs_lport_delete(port: &vport->lport);
6217	break;
6218
6219	case BFA_FCS_VPORT_SM_STOP:
6220	bfa_sm_set_state(vport, bfa_fcs_vport_sm_stopping);
6221	bfa_sm_send_event(&vport->lport, BFA_FCS_PORT_SM_STOP);
6222	break;
6223
6224	case BFA_FCS_VPORT_SM_OFFLINE:
6225	bfa_sm_set_state(vport, bfa_fcs_vport_sm_offline);
6226	bfa_sm_send_event(vport->lps, BFA_LPS_SM_OFFLINE);
6227	bfa_fcs_lport_offline(port: &vport->lport);
6228	break;
6229
6230	default:
6231	bfa_sm_fault(__vport_fcs(vport), event);
6232	}
6233	}
6234
6235	/*
6236	* Vport is being stopped - awaiting lport stop completion to send
6237	* LOGO to fabric.
6238	*/
6239	static void
6240	bfa_fcs_vport_sm_stopping(struct bfa_fcs_vport_s *vport,
6241	enum bfa_fcs_vport_event event)
6242	{
6243	bfa_trc(__vport_fcs(vport), __vport_pwwn(vport));
6244	bfa_trc(__vport_fcs(vport), event);
6245
6246	switch (event) {
6247	case BFA_FCS_VPORT_SM_STOPCOMP:
6248	bfa_sm_set_state(vport, bfa_fcs_vport_sm_logo_for_stop);
6249	bfa_fcs_vport_do_logo(vport);
6250	break;
6251
6252	case BFA_FCS_VPORT_SM_OFFLINE:
6253	bfa_sm_set_state(vport, bfa_fcs_vport_sm_cleanup);
6254	break;
6255
6256	default:
6257	bfa_sm_fault(__vport_fcs(vport), event);
6258	}
6259	}
6260
6261	/*
6262	* Vport is being deleted - awaiting lport delete completion to send
6263	* LOGO to fabric.
6264	*/
6265	static void
6266	bfa_fcs_vport_sm_deleting(struct bfa_fcs_vport_s *vport,
6267	enum bfa_fcs_vport_event event)
6268	{
6269	bfa_trc(__vport_fcs(vport), __vport_pwwn(vport));
6270	bfa_trc(__vport_fcs(vport), event);
6271
6272	switch (event) {
6273	case BFA_FCS_VPORT_SM_DELETE:
6274	break;
6275
6276	case BFA_FCS_VPORT_SM_DELCOMP:
6277	bfa_sm_set_state(vport, bfa_fcs_vport_sm_logo);
6278	bfa_fcs_vport_do_logo(vport);
6279	break;
6280
6281	case BFA_FCS_VPORT_SM_OFFLINE:
6282	bfa_sm_set_state(vport, bfa_fcs_vport_sm_cleanup);
6283	break;
6284
6285	default:
6286	bfa_sm_fault(__vport_fcs(vport), event);
6287	}
6288	}
6289
6290	/*
6291	* Error State.
6292	* This state will be set when the Vport Creation fails due
6293	* to errors like Dup WWN. In this state only operation allowed
6294	* is a Vport Delete.
6295	*/
6296	static void
6297	bfa_fcs_vport_sm_error(struct bfa_fcs_vport_s *vport,
6298	enum bfa_fcs_vport_event event)
6299	{
6300	bfa_trc(__vport_fcs(vport), __vport_pwwn(vport));
6301	bfa_trc(__vport_fcs(vport), event);
6302
6303	switch (event) {
6304	case BFA_FCS_VPORT_SM_DELETE:
6305	bfa_sm_set_state(vport, bfa_fcs_vport_sm_cleanup);
6306	bfa_fcs_lport_delete(port: &vport->lport);
6307	break;
6308
6309	default:
6310	bfa_trc(__vport_fcs(vport), event);
6311	}
6312	}
6313
6314	/*
6315	* Lport cleanup is in progress since vport is being deleted. Fabric is
6316	* offline, so no LOGO is needed to complete vport deletion.
6317	*/
6318	static void
6319	bfa_fcs_vport_sm_cleanup(struct bfa_fcs_vport_s *vport,
6320	enum bfa_fcs_vport_event event)
6321	{
6322	bfa_trc(__vport_fcs(vport), __vport_pwwn(vport));
6323	bfa_trc(__vport_fcs(vport), event);
6324
6325	switch (event) {
6326	case BFA_FCS_VPORT_SM_DELCOMP:
6327	bfa_sm_set_state(vport, bfa_fcs_vport_sm_uninit);
6328	bfa_fcs_vport_free(vport);
6329	break;
6330
6331	case BFA_FCS_VPORT_SM_STOPCOMP:
6332	bfa_sm_set_state(vport, bfa_fcs_vport_sm_created);
6333	break;
6334
6335	case BFA_FCS_VPORT_SM_DELETE:
6336	break;
6337
6338	default:
6339	bfa_sm_fault(__vport_fcs(vport), event);
6340	}
6341	}
6342
6343	/*
6344	* LOGO is sent to fabric. Vport stop is in progress. Lport stop cleanup
6345	* is done.
6346	*/
6347	static void
6348	bfa_fcs_vport_sm_logo_for_stop(struct bfa_fcs_vport_s *vport,
6349	enum bfa_fcs_vport_event event)
6350	{
6351	bfa_trc(__vport_fcs(vport), __vport_pwwn(vport));
6352	bfa_trc(__vport_fcs(vport), event);
6353
6354	switch (event) {
6355	case BFA_FCS_VPORT_SM_OFFLINE:
6356	bfa_sm_send_event(vport->lps, BFA_LPS_SM_OFFLINE);
6357	fallthrough;
6358
6359	case BFA_FCS_VPORT_SM_RSP_OK:
6360	case BFA_FCS_VPORT_SM_RSP_ERROR:
6361	bfa_sm_set_state(vport, bfa_fcs_vport_sm_created);
6362	break;
6363
6364	default:
6365	bfa_sm_fault(__vport_fcs(vport), event);
6366	}
6367	}
6368
6369	/*
6370	* LOGO is sent to fabric. Vport delete is in progress. Lport delete cleanup
6371	* is done.
6372	*/
6373	static void
6374	bfa_fcs_vport_sm_logo(struct bfa_fcs_vport_s *vport,
6375	enum bfa_fcs_vport_event event)
6376	{
6377	bfa_trc(__vport_fcs(vport), __vport_pwwn(vport));
6378	bfa_trc(__vport_fcs(vport), event);
6379
6380	switch (event) {
6381	case BFA_FCS_VPORT_SM_OFFLINE:
6382	bfa_sm_send_event(vport->lps, BFA_LPS_SM_OFFLINE);
6383	fallthrough;
6384
6385	case BFA_FCS_VPORT_SM_RSP_OK:
6386	case BFA_FCS_VPORT_SM_RSP_ERROR:
6387	bfa_sm_set_state(vport, bfa_fcs_vport_sm_uninit);
6388	bfa_fcs_vport_free(vport);
6389	break;
6390
6391	case BFA_FCS_VPORT_SM_DELETE:
6392	break;
6393
6394	default:
6395	bfa_sm_fault(__vport_fcs(vport), event);
6396	}
6397	}
6398
6399
6400
6401	/*
6402	* fcs_vport_private FCS virtual port private functions
6403	*/
6404	/*
6405	* Send AEN notification
6406	*/
6407	static void
6408	bfa_fcs_vport_aen_post(struct bfa_fcs_lport_s *port,
6409	enum bfa_lport_aen_event event)
6410	{
6411	struct bfad_s *bfad = (struct bfad_s *)port->fabric->fcs->bfad;
6412	struct bfa_aen_entry_s *aen_entry;
6413
6414	bfad_get_aen_entry(bfad, aen_entry);
6415	if (!aen_entry)
6416	return;
6417
6418	aen_entry->aen_data.lport.vf_id = port->fabric->vf_id;
6419	aen_entry->aen_data.lport.roles = port->port_cfg.roles;
6420	aen_entry->aen_data.lport.ppwwn = bfa_fcs_lport_get_pwwn(
6421	bfa_fcs_get_base_port(port->fcs));
6422	aen_entry->aen_data.lport.lpwwn = bfa_fcs_lport_get_pwwn(port);
6423
6424	/* Send the AEN notification */
6425	bfad_im_post_vendor_event(entry: aen_entry, drv: bfad, cnt: ++port->fcs->fcs_aen_seq,
6426	cat: BFA_AEN_CAT_LPORT, evt: event);
6427	}
6428
6429	/*
6430	* This routine will be called to send a FDISC command.
6431	*/
6432	static void
6433	bfa_fcs_vport_do_fdisc(struct bfa_fcs_vport_s *vport)
6434	{
6435	bfa_lps_fdisc(lps: vport->lps, uarg: vport,
6436	pdusz: bfa_fcport_get_maxfrsize(__vport_bfa(vport)),
6437	__vport_pwwn(vport), __vport_nwwn(vport));
6438	vport->vport_stats.fdisc_sent++;
6439	}
6440
6441	static void
6442	bfa_fcs_vport_fdisc_rejected(struct bfa_fcs_vport_s *vport)
6443	{
6444	u8 lsrjt_rsn = vport->lps->lsrjt_rsn;
6445	u8 lsrjt_expl = vport->lps->lsrjt_expl;
6446
6447	bfa_trc(__vport_fcs(vport), lsrjt_rsn);
6448	bfa_trc(__vport_fcs(vport), lsrjt_expl);
6449
6450	/* For certain reason codes, we don't want to retry. */
6451	switch (vport->lps->lsrjt_expl) {
6452	case FC_LS_RJT_EXP_INV_PORT_NAME: /* by brocade */
6453	case FC_LS_RJT_EXP_INVALID_NPORT_ID: /* by Cisco */
6454	if (vport->fdisc_retries < BFA_FCS_VPORT_MAX_RETRIES)
6455	bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_ERROR);
6456	else {
6457	bfa_fcs_vport_aen_post(port: &vport->lport,
6458	event: BFA_LPORT_AEN_NPIV_DUP_WWN);
6459	bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_DUP_WWN);
6460	}
6461	break;
6462
6463	case FC_LS_RJT_EXP_INSUFF_RES:
6464	/*
6465	* This means max logins per port/switch setting on the
6466	* switch was exceeded.
6467	*/
6468	if (vport->fdisc_retries < BFA_FCS_VPORT_MAX_RETRIES)
6469	bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_ERROR);
6470	else {
6471	bfa_fcs_vport_aen_post(port: &vport->lport,
6472	event: BFA_LPORT_AEN_NPIV_FABRIC_MAX);
6473	bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_FABRIC_MAX);
6474	}
6475	break;
6476
6477	default:
6478	if (vport->fdisc_retries == 0)
6479	bfa_fcs_vport_aen_post(port: &vport->lport,
6480	event: BFA_LPORT_AEN_NPIV_UNKNOWN);
6481	bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_ERROR);
6482	}
6483	}
6484
6485	/*
6486	* Called to send a logout to the fabric. Used when a V-Port is
6487	* deleted/stopped.
6488	*/
6489	static void
6490	bfa_fcs_vport_do_logo(struct bfa_fcs_vport_s *vport)
6491	{
6492	bfa_trc(__vport_fcs(vport), __vport_pwwn(vport));
6493
6494	vport->vport_stats.logo_sent++;
6495	bfa_lps_fdisclogo(lps: vport->lps);
6496	}
6497
6498
6499	/*
6500	* This routine will be called by bfa_timer on timer timeouts.
6501	*
6502	* param[in] vport - pointer to bfa_fcs_vport_t.
6503	* param[out] vport_status - pointer to return vport status in
6504	*
6505	* return
6506	* void
6507	*
6508	* Special Considerations:
6509	*
6510	* note
6511	*/
6512	static void
6513	bfa_fcs_vport_timeout(void *vport_arg)
6514	{
6515	struct bfa_fcs_vport_s *vport = (struct bfa_fcs_vport_s *) vport_arg;
6516
6517	vport->vport_stats.fdisc_timeouts++;
6518	bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_TIMEOUT);
6519	}
6520
6521	static void
6522	bfa_fcs_vport_free(struct bfa_fcs_vport_s *vport)
6523	{
6524	struct bfad_vport_s *vport_drv =
6525	(struct bfad_vport_s *)vport->vport_drv;
6526
6527	bfa_fcs_fabric_delvport(__vport_fabric(vport), vport);
6528	bfa_lps_delete(lps: vport->lps);
6529
6530	if (vport_drv->comp_del) {
6531	complete(vport_drv->comp_del);
6532	return;
6533	}
6534
6535	/*
6536	* We queue the vport delete work to the IM work_q from here.
6537	* The memory for the bfad_vport_s is freed from the FC function
6538	* template vport_delete entry point.
6539	*/
6540	bfad_im_port_delete(bfad: vport_drv->drv_port.bfad, port: &vport_drv->drv_port);
6541	}
6542
6543	/*
6544	* fcs_vport_public FCS virtual port public interfaces
6545	*/
6546
6547	/*
6548	* Online notification from fabric SM.
6549	*/
6550	void
6551	bfa_fcs_vport_online(struct bfa_fcs_vport_s *vport)
6552	{
6553	vport->vport_stats.fab_online++;
6554	if (bfa_fcs_fabric_npiv_capable(__vport_fabric(vport)))
6555	bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_ONLINE);
6556	else
6557	vport->vport_stats.fab_no_npiv++;
6558	}
6559
6560	/*
6561	* Offline notification from fabric SM.
6562	*/
6563	void
6564	bfa_fcs_vport_offline(struct bfa_fcs_vport_s *vport)
6565	{
6566	vport->vport_stats.fab_offline++;
6567	bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_OFFLINE);
6568	}
6569
6570	/*
6571	* Cleanup notification from fabric SM on link timer expiry.
6572	*/
6573	void
6574	bfa_fcs_vport_cleanup(struct bfa_fcs_vport_s *vport)
6575	{
6576	vport->vport_stats.fab_cleanup++;
6577	}
6578
6579	/*
6580	* Stop notification from fabric SM. To be invoked from within FCS.
6581	*/
6582	void
6583	bfa_fcs_vport_fcs_stop(struct bfa_fcs_vport_s *vport)
6584	{
6585	bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_STOP);
6586	}
6587
6588	/*
6589	* delete notification from fabric SM. To be invoked from within FCS.
6590	*/
6591	void
6592	bfa_fcs_vport_fcs_delete(struct bfa_fcs_vport_s *vport)
6593	{
6594	bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_DELETE);
6595	}
6596
6597	/*
6598	* Stop completion callback from associated lport
6599	*/
6600	void
6601	bfa_fcs_vport_stop_comp(struct bfa_fcs_vport_s *vport)
6602	{
6603	bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_STOPCOMP);
6604	}
6605
6606	/*
6607	* Delete completion callback from associated lport
6608	*/
6609	void
6610	bfa_fcs_vport_delete_comp(struct bfa_fcs_vport_s *vport)
6611	{
6612	bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_DELCOMP);
6613	}
6614
6615
6616
6617	/*
6618	* fcs_vport_api Virtual port API
6619	*/
6620
6621	/*
6622	* Use this function to instantiate a new FCS vport object. This
6623	* function will not trigger any HW initialization process (which will be
6624	* done in vport_start() call)
6625	*
6626	* param[in] vport - pointer to bfa_fcs_vport_t. This space
6627	* needs to be allocated by the driver.
6628	* param[in] fcs - FCS instance
6629	* param[in] vport_cfg - vport configuration
6630	* param[in] vf_id - VF_ID if vport is created within a VF.
6631	* FC_VF_ID_NULL to specify base fabric.
6632	* param[in] vport_drv - Opaque handle back to the driver's vport
6633	* structure
6634	*
6635	* retval BFA_STATUS_OK - on success.
6636	* retval BFA_STATUS_FAILED - on failure.
6637	*/
6638	bfa_status_t
6639	bfa_fcs_vport_create(struct bfa_fcs_vport_s *vport, struct bfa_fcs_s *fcs,
6640	u16 vf_id, struct bfa_lport_cfg_s *vport_cfg,
6641	struct bfad_vport_s *vport_drv)
6642	{
6643	if (vport_cfg->pwwn == 0)
6644	return BFA_STATUS_INVALID_WWN;
6645
6646	if (bfa_fcs_lport_get_pwwn(&fcs->fabric.bport) == vport_cfg->pwwn)
6647	return BFA_STATUS_VPORT_WWN_BP;
6648
6649	if (bfa_fcs_vport_lookup(fcs, vf_id, vpwwn: vport_cfg->pwwn) != NULL)
6650	return BFA_STATUS_VPORT_EXISTS;
6651
6652	if (fcs->fabric.num_vports ==
6653	bfa_lps_get_max_vport(bfa: fcs->bfa))
6654	return BFA_STATUS_VPORT_MAX;
6655
6656	vport->lps = bfa_lps_alloc(bfa: fcs->bfa);
6657	if (!vport->lps)
6658	return BFA_STATUS_VPORT_MAX;
6659
6660	vport->vport_drv = vport_drv;
6661	vport_cfg->preboot_vp = BFA_FALSE;
6662
6663	bfa_sm_set_state(vport, bfa_fcs_vport_sm_uninit);
6664	bfa_fcs_lport_attach(lport: &vport->lport, fcs, vf_id, vport);
6665	bfa_fcs_lport_init(lport: &vport->lport, port_cfg: vport_cfg);
6666	bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_CREATE);
6667
6668	return BFA_STATUS_OK;
6669	}
6670
6671	/*
6672	* Use this function to instantiate a new FCS PBC vport object. This
6673	* function will not trigger any HW initialization process (which will be
6674	* done in vport_start() call)
6675	*
6676	* param[in] vport - pointer to bfa_fcs_vport_t. This space
6677	* needs to be allocated by the driver.
6678	* param[in] fcs - FCS instance
6679	* param[in] vport_cfg - vport configuration
6680	* param[in] vf_id - VF_ID if vport is created within a VF.
6681	* FC_VF_ID_NULL to specify base fabric.
6682	* param[in] vport_drv - Opaque handle back to the driver's vport
6683	* structure
6684	*
6685	* retval BFA_STATUS_OK - on success.
6686	* retval BFA_STATUS_FAILED - on failure.
6687	*/
6688	bfa_status_t
6689	bfa_fcs_pbc_vport_create(struct bfa_fcs_vport_s *vport, struct bfa_fcs_s *fcs,
6690	u16 vf_id, struct bfa_lport_cfg_s *vport_cfg,
6691	struct bfad_vport_s *vport_drv)
6692	{
6693	bfa_status_t rc;
6694
6695	rc = bfa_fcs_vport_create(vport, fcs, vf_id, vport_cfg, vport_drv);
6696	vport->lport.port_cfg.preboot_vp = BFA_TRUE;
6697
6698	return rc;
6699	}
6700
6701	/*
6702	* Use this function to findout if this is a pbc vport or not.
6703	*
6704	* @param[in] vport - pointer to bfa_fcs_vport_t.
6705	*
6706	* @returns None
6707	*/
6708	bfa_boolean_t
6709	bfa_fcs_is_pbc_vport(struct bfa_fcs_vport_s *vport)
6710	{
6711
6712	if (vport && (vport->lport.port_cfg.preboot_vp == BFA_TRUE))
6713	return BFA_TRUE;
6714	else
6715	return BFA_FALSE;
6716
6717	}
6718
6719	/*
6720	* Use this function initialize the vport.
6721	*
6722	* @param[in] vport - pointer to bfa_fcs_vport_t.
6723	*
6724	* @returns None
6725	*/
6726	bfa_status_t
6727	bfa_fcs_vport_start(struct bfa_fcs_vport_s *vport)
6728	{
6729	bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_START);
6730
6731	return BFA_STATUS_OK;
6732	}
6733
6734	/*
6735	* Use this function quiese the vport object. This function will return
6736	* immediately, when the vport is actually stopped, the
6737	* bfa_drv_vport_stop_cb() will be called.
6738	*
6739	* param[in] vport - pointer to bfa_fcs_vport_t.
6740	*
6741	* return None
6742	*/
6743	bfa_status_t
6744	bfa_fcs_vport_stop(struct bfa_fcs_vport_s *vport)
6745	{
6746	bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_STOP);
6747
6748	return BFA_STATUS_OK;
6749	}
6750
6751	/*
6752	* Use this function to delete a vport object. Fabric object should
6753	* be stopped before this function call.
6754	*
6755	* !!!!!!! Donot invoke this from within FCS !!!!!!!
6756	*
6757	* param[in] vport - pointer to bfa_fcs_vport_t.
6758	*
6759	* return None
6760	*/
6761	bfa_status_t
6762	bfa_fcs_vport_delete(struct bfa_fcs_vport_s *vport)
6763	{
6764
6765	if (vport->lport.port_cfg.preboot_vp)
6766	return BFA_STATUS_PBC;
6767
6768	bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_DELETE);
6769
6770	return BFA_STATUS_OK;
6771	}
6772
6773	/*
6774	* Use this function to get vport's current status info.
6775	*
6776	* param[in] vport pointer to bfa_fcs_vport_t.
6777	* param[out] attr pointer to return vport attributes
6778	*
6779	* return None
6780	*/
6781	void
6782	bfa_fcs_vport_get_attr(struct bfa_fcs_vport_s *vport,
6783	struct bfa_vport_attr_s *attr)
6784	{
6785	if (vport == NULL || attr == NULL)
6786	return;
6787
6788	memset(attr, 0, sizeof(struct bfa_vport_attr_s));
6789
6790	bfa_fcs_lport_get_attr(port: &vport->lport, port_attr: &attr->port_attr);
6791	attr->vport_state = bfa_vport_sm_to_state(smt: vport_sm_table, sm: vport->sm);
6792	}
6793
6794
6795	/*
6796	* Lookup a virtual port. Excludes base port from lookup.
6797	*/
6798	struct bfa_fcs_vport_s *
6799	bfa_fcs_vport_lookup(struct bfa_fcs_s *fcs, u16 vf_id, wwn_t vpwwn)
6800	{
6801	struct bfa_fcs_vport_s *vport;
6802	struct bfa_fcs_fabric_s *fabric;
6803
6804	bfa_trc(fcs, vf_id);
6805	bfa_trc(fcs, vpwwn);
6806
6807	fabric = bfa_fcs_vf_lookup(fcs, vf_id);
6808	if (!fabric) {
6809	bfa_trc(fcs, vf_id);
6810	return NULL;
6811	}
6812
6813	vport = bfa_fcs_fabric_vport_lookup(fabric, pwwn: vpwwn);
6814	return vport;
6815	}
6816
6817	/*
6818	* FDISC Response
6819	*/
6820	void
6821	bfa_cb_lps_fdisc_comp(void *bfad, void *uarg, bfa_status_t status)
6822	{
6823	struct bfa_fcs_vport_s *vport = uarg;
6824
6825	bfa_trc(__vport_fcs(vport), __vport_pwwn(vport));
6826	bfa_trc(__vport_fcs(vport), status);
6827
6828	switch (status) {
6829	case BFA_STATUS_OK:
6830	/*
6831	* Initialize the V-Port fields
6832	*/
6833	__vport_fcid(vport) = vport->lps->lp_pid;
6834	vport->vport_stats.fdisc_accepts++;
6835	bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_OK);
6836	break;
6837
6838	case BFA_STATUS_INVALID_MAC:
6839	/* Only for CNA */
6840	vport->vport_stats.fdisc_acc_bad++;
6841	bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_ERROR);
6842
6843	break;
6844
6845	case BFA_STATUS_EPROTOCOL:
6846	switch (vport->lps->ext_status) {
6847	case BFA_EPROTO_BAD_ACCEPT:
6848	vport->vport_stats.fdisc_acc_bad++;
6849	break;
6850
6851	case BFA_EPROTO_UNKNOWN_RSP:
6852	vport->vport_stats.fdisc_unknown_rsp++;
6853	break;
6854
6855	default:
6856	break;
6857	}
6858
6859	if (vport->fdisc_retries < BFA_FCS_VPORT_MAX_RETRIES)
6860	bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_ERROR);
6861	else
6862	bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_FAILED);
6863
6864	break;
6865
6866	case BFA_STATUS_ETIMER:
6867	vport->vport_stats.fdisc_timeouts++;
6868	if (vport->fdisc_retries < BFA_FCS_VPORT_MAX_RETRIES)
6869	bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_ERROR);
6870	else
6871	bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_FAILED);
6872	break;
6873
6874	case BFA_STATUS_FABRIC_RJT:
6875	vport->vport_stats.fdisc_rejects++;
6876	bfa_fcs_vport_fdisc_rejected(vport);
6877	break;
6878
6879	default:
6880	vport->vport_stats.fdisc_rsp_err++;
6881	bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_ERROR);
6882	}
6883	}
6884
6885	/*
6886	* LOGO response
6887	*/
6888	void
6889	bfa_cb_lps_fdisclogo_comp(void *bfad, void *uarg)
6890	{
6891	struct bfa_fcs_vport_s *vport = uarg;
6892	bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_OK);
6893	}
6894
6895	/*
6896	* Received clear virtual link
6897	*/
6898	void
6899	bfa_cb_lps_cvl_event(void *bfad, void *uarg)
6900	{
6901	struct bfa_fcs_vport_s *vport = uarg;
6902
6903	/* Send an Offline followed by an ONLINE */
6904	bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_OFFLINE);
6905	bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_ONLINE);
6906	}
6907