1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (C) 2021 Broadcom. All Rights Reserved. The term
4  * “Broadcom” refers to Broadcom Inc. and/or its subsidiaries.
5  */
6 
7 /*
8  * This file implements remote node state machines for:
9  * - Fabric logins.
10  * - Fabric controller events.
11  * - Name/directory services interaction.
12  * - Point-to-point logins.
13  */
14 
15 /*
16  * fabric_sm Node State Machine: Fabric States
17  * ns_sm Node State Machine: Name/Directory Services States
18  * p2p_sm Node State Machine: Point-to-Point Node States
19  */
20 
21 #include "efc.h"
22 
23 static void
24 efc_fabric_initiate_shutdown(struct efc_node *node)
25 {
26 	struct efc *efc = node->efc;
27 
28 	node->els_io_enabled = false;
29 
30 	if (node->attached) {
31 		int rc;
32 
33 		/* issue hw node free; don't care if succeeds right away
34 		 * or sometime later, will check node->attached later in
35 		 * shutdown process
36 		 */
37 		rc = efc_cmd_node_detach(efc, &node->rnode);
38 		if (rc < 0) {
39 			node_printf(node, "Failed freeing HW node, rc=%d\n",
40 				    rc);
41 		}
42 	}
43 	/*
44 	 * node has either been detached or is in the process of being detached,
45 	 * call common node's initiate cleanup function
46 	 */
47 	efc_node_initiate_cleanup(node);
48 }
49 
50 static void
51 __efc_fabric_common(const char *funcname, struct efc_sm_ctx *ctx,
52 		    enum efc_sm_event evt, void *arg)
53 {
54 	struct efc_node *node = NULL;
55 
56 	node = ctx->app;
57 
58 	switch (evt) {
59 	case EFC_EVT_DOMAIN_ATTACH_OK:
60 		break;
61 	case EFC_EVT_SHUTDOWN:
62 		node->shutdown_reason = EFC_NODE_SHUTDOWN_DEFAULT;
63 		efc_fabric_initiate_shutdown(node);
64 		break;
65 
66 	default:
67 		/* call default event handler common to all nodes */
68 		__efc_node_common(funcname, ctx, evt, arg);
69 	}
70 }
71 
72 void
73 __efc_fabric_init(struct efc_sm_ctx *ctx, enum efc_sm_event evt,
74 		  void *arg)
75 {
76 	struct efc_node *node = ctx->app;
77 	struct efc *efc = node->efc;
78 
79 	efc_node_evt_set(ctx, evt, __func__);
80 
81 	node_sm_trace();
82 
83 	switch (evt) {
84 	case EFC_EVT_REENTER:
85 		efc_log_debug(efc, ">>> reenter !!\n");
86 		fallthrough;
87 
88 	case EFC_EVT_ENTER:
89 		/* send FLOGI */
90 		efc_send_flogi(node);
91 		efc_node_transition(node, __efc_fabric_flogi_wait_rsp, NULL);
92 		break;
93 
94 	default:
95 		__efc_fabric_common(__func__, ctx, evt, arg);
96 	}
97 }
98 
99 void
100 efc_fabric_set_topology(struct efc_node *node,
101 			enum efc_nport_topology topology)
102 {
103 	node->nport->topology = topology;
104 }
105 
106 void
107 efc_fabric_notify_topology(struct efc_node *node)
108 {
109 	struct efc_node *tmp_node;
110 	unsigned long index;
111 
112 	/*
113 	 * now loop through the nodes in the nport
114 	 * and send topology notification
115 	 */
116 	xa_for_each(&node->nport->lookup, index, tmp_node) {
117 		if (tmp_node != node) {
118 			efc_node_post_event(tmp_node,
119 					    EFC_EVT_NPORT_TOPOLOGY_NOTIFY,
120 					    &node->nport->topology);
121 		}
122 	}
123 }
124 
125 static bool efc_rnode_is_nport(struct fc_els_flogi *rsp)
126 {
127 	return !(ntohs(rsp->fl_csp.sp_features) & FC_SP_FT_FPORT);
128 }
129 
130 void
131 __efc_fabric_flogi_wait_rsp(struct efc_sm_ctx *ctx,
132 			    enum efc_sm_event evt, void *arg)
133 {
134 	struct efc_node_cb *cbdata = arg;
135 	struct efc_node *node = ctx->app;
136 
137 	efc_node_evt_set(ctx, evt, __func__);
138 
139 	node_sm_trace();
140 
141 	switch (evt) {
142 	case EFC_EVT_SRRS_ELS_REQ_OK: {
143 		if (efc_node_check_els_req(ctx, evt, arg, ELS_FLOGI,
144 					   __efc_fabric_common, __func__)) {
145 			return;
146 		}
147 		WARN_ON(!node->els_req_cnt);
148 		node->els_req_cnt--;
149 
150 		memcpy(node->nport->domain->flogi_service_params,
151 		       cbdata->els_rsp.virt,
152 		       sizeof(struct fc_els_flogi));
153 
154 		/* Check to see if the fabric is an F_PORT or and N_PORT */
155 		if (!efc_rnode_is_nport(cbdata->els_rsp.virt)) {
156 			/* sm: if not nport / efc_domain_attach */
157 			/* ext_status has the fc_id, attach domain */
158 			efc_fabric_set_topology(node, EFC_NPORT_TOPO_FABRIC);
159 			efc_fabric_notify_topology(node);
160 			WARN_ON(node->nport->domain->attached);
161 			efc_domain_attach(node->nport->domain,
162 					  cbdata->ext_status);
163 			efc_node_transition(node,
164 					    __efc_fabric_wait_domain_attach,
165 					    NULL);
166 			break;
167 		}
168 
169 		/*  sm: if nport and p2p_winner / efc_domain_attach */
170 		efc_fabric_set_topology(node, EFC_NPORT_TOPO_P2P);
171 		if (efc_p2p_setup(node->nport)) {
172 			node_printf(node,
173 				    "p2p setup failed, shutting down node\n");
174 			node->shutdown_reason = EFC_NODE_SHUTDOWN_DEFAULT;
175 			efc_fabric_initiate_shutdown(node);
176 			break;
177 		}
178 
179 		if (node->nport->p2p_winner) {
180 			efc_node_transition(node,
181 					    __efc_p2p_wait_domain_attach,
182 					     NULL);
183 			if (node->nport->domain->attached &&
184 			    !node->nport->domain->domain_notify_pend) {
185 				/*
186 				 * already attached,
187 				 * just send ATTACH_OK
188 				 */
189 				node_printf(node,
190 					    "p2p winner, domain already attached\n");
191 				efc_node_post_event(node,
192 						    EFC_EVT_DOMAIN_ATTACH_OK,
193 						    NULL);
194 			}
195 		} else {
196 			/*
197 			 * peer is p2p winner;
198 			 * PLOGI will be received on the
199 			 * remote SID=1 node;
200 			 * this node has served its purpose
201 			 */
202 			node->shutdown_reason = EFC_NODE_SHUTDOWN_DEFAULT;
203 			efc_fabric_initiate_shutdown(node);
204 		}
205 
206 		break;
207 	}
208 
209 	case EFC_EVT_ELS_REQ_ABORTED:
210 	case EFC_EVT_SRRS_ELS_REQ_RJT:
211 	case EFC_EVT_SRRS_ELS_REQ_FAIL: {
212 		struct efc_nport *nport = node->nport;
213 		/*
214 		 * with these errors, we have no recovery,
215 		 * so shutdown the nport, leave the link
216 		 * up and the domain ready
217 		 */
218 		if (efc_node_check_els_req(ctx, evt, arg, ELS_FLOGI,
219 					   __efc_fabric_common, __func__)) {
220 			return;
221 		}
222 		node_printf(node,
223 			    "FLOGI failed evt=%s, shutting down nport [%s]\n",
224 			    efc_sm_event_name(evt), nport->display_name);
225 		WARN_ON(!node->els_req_cnt);
226 		node->els_req_cnt--;
227 		efc_sm_post_event(&nport->sm, EFC_EVT_SHUTDOWN, NULL);
228 		break;
229 	}
230 
231 	default:
232 		__efc_fabric_common(__func__, ctx, evt, arg);
233 	}
234 }
235 
236 void
237 __efc_vport_fabric_init(struct efc_sm_ctx *ctx,
238 			enum efc_sm_event evt, void *arg)
239 {
240 	struct efc_node *node = ctx->app;
241 
242 	efc_node_evt_set(ctx, evt, __func__);
243 
244 	node_sm_trace();
245 
246 	switch (evt) {
247 	case EFC_EVT_ENTER:
248 		/* sm: / send FDISC */
249 		efc_send_fdisc(node);
250 		efc_node_transition(node, __efc_fabric_fdisc_wait_rsp, NULL);
251 		break;
252 
253 	default:
254 		__efc_fabric_common(__func__, ctx, evt, arg);
255 	}
256 }
257 
258 void
259 __efc_fabric_fdisc_wait_rsp(struct efc_sm_ctx *ctx,
260 			    enum efc_sm_event evt, void *arg)
261 {
262 	struct efc_node_cb *cbdata = arg;
263 	struct efc_node *node = ctx->app;
264 
265 	efc_node_evt_set(ctx, evt, __func__);
266 
267 	node_sm_trace();
268 
269 	switch (evt) {
270 	case EFC_EVT_SRRS_ELS_REQ_OK: {
271 		/* fc_id is in ext_status */
272 		if (efc_node_check_els_req(ctx, evt, arg, ELS_FDISC,
273 					   __efc_fabric_common, __func__)) {
274 			return;
275 		}
276 
277 		WARN_ON(!node->els_req_cnt);
278 		node->els_req_cnt--;
279 		/* sm: / efc_nport_attach */
280 		efc_nport_attach(node->nport, cbdata->ext_status);
281 		efc_node_transition(node, __efc_fabric_wait_domain_attach,
282 				    NULL);
283 		break;
284 	}
285 
286 	case EFC_EVT_SRRS_ELS_REQ_RJT:
287 	case EFC_EVT_SRRS_ELS_REQ_FAIL: {
288 		if (efc_node_check_els_req(ctx, evt, arg, ELS_FDISC,
289 					   __efc_fabric_common, __func__)) {
290 			return;
291 		}
292 		WARN_ON(!node->els_req_cnt);
293 		node->els_req_cnt--;
294 		efc_log_err(node->efc, "FDISC failed, shutting down nport\n");
295 		/* sm: / shutdown nport */
296 		efc_sm_post_event(&node->nport->sm, EFC_EVT_SHUTDOWN, NULL);
297 		break;
298 	}
299 
300 	default:
301 		__efc_fabric_common(__func__, ctx, evt, arg);
302 	}
303 }
304 
305 static int
306 efc_start_ns_node(struct efc_nport *nport)
307 {
308 	struct efc_node *ns;
309 
310 	/* Instantiate a name services node */
311 	ns = efc_node_find(nport, FC_FID_DIR_SERV);
312 	if (!ns) {
313 		ns = efc_node_alloc(nport, FC_FID_DIR_SERV, false, false);
314 		if (!ns)
315 			return -EIO;
316 	}
317 	/*
318 	 * for found ns, should we be transitioning from here?
319 	 * breaks transition only
320 	 *  1. from within state machine or
321 	 *  2. if after alloc
322 	 */
323 	if (ns->efc->nodedb_mask & EFC_NODEDB_PAUSE_NAMESERVER)
324 		efc_node_pause(ns, __efc_ns_init);
325 	else
326 		efc_node_transition(ns, __efc_ns_init, NULL);
327 	return 0;
328 }
329 
330 static int
331 efc_start_fabctl_node(struct efc_nport *nport)
332 {
333 	struct efc_node *fabctl;
334 
335 	fabctl = efc_node_find(nport, FC_FID_FCTRL);
336 	if (!fabctl) {
337 		fabctl = efc_node_alloc(nport, FC_FID_FCTRL,
338 					false, false);
339 		if (!fabctl)
340 			return -EIO;
341 	}
342 	/*
343 	 * for found ns, should we be transitioning from here?
344 	 * breaks transition only
345 	 *  1. from within state machine or
346 	 *  2. if after alloc
347 	 */
348 	efc_node_transition(fabctl, __efc_fabctl_init, NULL);
349 	return 0;
350 }
351 
352 void
353 __efc_fabric_wait_domain_attach(struct efc_sm_ctx *ctx,
354 				enum efc_sm_event evt, void *arg)
355 {
356 	struct efc_node *node = ctx->app;
357 
358 	efc_node_evt_set(ctx, evt, __func__);
359 
360 	node_sm_trace();
361 
362 	switch (evt) {
363 	case EFC_EVT_ENTER:
364 		efc_node_hold_frames(node);
365 		break;
366 
367 	case EFC_EVT_EXIT:
368 		efc_node_accept_frames(node);
369 		break;
370 	case EFC_EVT_DOMAIN_ATTACH_OK:
371 	case EFC_EVT_NPORT_ATTACH_OK: {
372 		int rc;
373 
374 		rc = efc_start_ns_node(node->nport);
375 		if (rc)
376 			return;
377 
378 		/* sm: if enable_ini / start fabctl node */
379 		/* Instantiate the fabric controller (sends SCR) */
380 		if (node->nport->enable_rscn) {
381 			rc = efc_start_fabctl_node(node->nport);
382 			if (rc)
383 				return;
384 		}
385 		efc_node_transition(node, __efc_fabric_idle, NULL);
386 		break;
387 	}
388 	default:
389 		__efc_fabric_common(__func__, ctx, evt, arg);
390 	}
391 }
392 
393 void
394 __efc_fabric_idle(struct efc_sm_ctx *ctx, enum efc_sm_event evt,
395 		  void *arg)
396 {
397 	struct efc_node *node = ctx->app;
398 
399 	efc_node_evt_set(ctx, evt, __func__);
400 
401 	node_sm_trace();
402 
403 	switch (evt) {
404 	case EFC_EVT_DOMAIN_ATTACH_OK:
405 		break;
406 	default:
407 		__efc_fabric_common(__func__, ctx, evt, arg);
408 	}
409 }
410 
411 void
412 __efc_ns_init(struct efc_sm_ctx *ctx, enum efc_sm_event evt, void *arg)
413 {
414 	struct efc_node *node = ctx->app;
415 
416 	efc_node_evt_set(ctx, evt, __func__);
417 
418 	node_sm_trace();
419 
420 	switch (evt) {
421 	case EFC_EVT_ENTER:
422 		/* sm: / send PLOGI */
423 		efc_send_plogi(node);
424 		efc_node_transition(node, __efc_ns_plogi_wait_rsp, NULL);
425 		break;
426 	default:
427 		__efc_fabric_common(__func__, ctx, evt, arg);
428 	}
429 }
430 
431 void
432 __efc_ns_plogi_wait_rsp(struct efc_sm_ctx *ctx,
433 			enum efc_sm_event evt, void *arg)
434 {
435 	struct efc_node_cb *cbdata = arg;
436 	struct efc_node *node = ctx->app;
437 
438 	efc_node_evt_set(ctx, evt, __func__);
439 
440 	node_sm_trace();
441 
442 	switch (evt) {
443 	case EFC_EVT_SRRS_ELS_REQ_OK: {
444 		int rc;
445 
446 		/* Save service parameters */
447 		if (efc_node_check_els_req(ctx, evt, arg, ELS_PLOGI,
448 					   __efc_fabric_common, __func__)) {
449 			return;
450 		}
451 		WARN_ON(!node->els_req_cnt);
452 		node->els_req_cnt--;
453 		/* sm: / save sparams, efc_node_attach */
454 		efc_node_save_sparms(node, cbdata->els_rsp.virt);
455 		rc = efc_node_attach(node);
456 		efc_node_transition(node, __efc_ns_wait_node_attach, NULL);
457 		if (rc < 0)
458 			efc_node_post_event(node, EFC_EVT_NODE_ATTACH_FAIL,
459 					    NULL);
460 		break;
461 	}
462 	default:
463 		__efc_fabric_common(__func__, ctx, evt, arg);
464 	}
465 }
466 
467 void
468 __efc_ns_wait_node_attach(struct efc_sm_ctx *ctx,
469 			  enum efc_sm_event evt, void *arg)
470 {
471 	struct efc_node *node = ctx->app;
472 
473 	efc_node_evt_set(ctx, evt, __func__);
474 
475 	node_sm_trace();
476 
477 	switch (evt) {
478 	case EFC_EVT_ENTER:
479 		efc_node_hold_frames(node);
480 		break;
481 
482 	case EFC_EVT_EXIT:
483 		efc_node_accept_frames(node);
484 		break;
485 
486 	case EFC_EVT_NODE_ATTACH_OK:
487 		node->attached = true;
488 		/* sm: / send RFTID */
489 		efc_ns_send_rftid(node);
490 		efc_node_transition(node, __efc_ns_rftid_wait_rsp, NULL);
491 		break;
492 
493 	case EFC_EVT_NODE_ATTACH_FAIL:
494 		/* node attach failed, shutdown the node */
495 		node->attached = false;
496 		node_printf(node, "Node attach failed\n");
497 		node->shutdown_reason = EFC_NODE_SHUTDOWN_DEFAULT;
498 		efc_fabric_initiate_shutdown(node);
499 		break;
500 
501 	case EFC_EVT_SHUTDOWN:
502 		node_printf(node, "Shutdown event received\n");
503 		node->shutdown_reason = EFC_NODE_SHUTDOWN_DEFAULT;
504 		efc_node_transition(node,
505 				    __efc_fabric_wait_attach_evt_shutdown,
506 				     NULL);
507 		break;
508 
509 	/*
510 	 * if receive RSCN just ignore,
511 	 * we haven't sent GID_PT yet (ACC sent by fabctl node)
512 	 */
513 	case EFC_EVT_RSCN_RCVD:
514 		break;
515 
516 	default:
517 		__efc_fabric_common(__func__, ctx, evt, arg);
518 	}
519 }
520 
521 void
522 __efc_fabric_wait_attach_evt_shutdown(struct efc_sm_ctx *ctx,
523 				      enum efc_sm_event evt, void *arg)
524 {
525 	struct efc_node *node = ctx->app;
526 
527 	efc_node_evt_set(ctx, evt, __func__);
528 
529 	node_sm_trace();
530 
531 	switch (evt) {
532 	case EFC_EVT_ENTER:
533 		efc_node_hold_frames(node);
534 		break;
535 
536 	case EFC_EVT_EXIT:
537 		efc_node_accept_frames(node);
538 		break;
539 
540 	/* wait for any of these attach events and then shutdown */
541 	case EFC_EVT_NODE_ATTACH_OK:
542 		node->attached = true;
543 		node_printf(node, "Attach evt=%s, proceed to shutdown\n",
544 			    efc_sm_event_name(evt));
545 		efc_fabric_initiate_shutdown(node);
546 		break;
547 
548 	case EFC_EVT_NODE_ATTACH_FAIL:
549 		node->attached = false;
550 		node_printf(node, "Attach evt=%s, proceed to shutdown\n",
551 			    efc_sm_event_name(evt));
552 		efc_fabric_initiate_shutdown(node);
553 		break;
554 
555 	/* ignore shutdown event as we're already in shutdown path */
556 	case EFC_EVT_SHUTDOWN:
557 		node_printf(node, "Shutdown event received\n");
558 		break;
559 
560 	default:
561 		__efc_fabric_common(__func__, ctx, evt, arg);
562 	}
563 }
564 
565 void
566 __efc_ns_rftid_wait_rsp(struct efc_sm_ctx *ctx,
567 			enum efc_sm_event evt, void *arg)
568 {
569 	struct efc_node *node = ctx->app;
570 
571 	efc_node_evt_set(ctx, evt, __func__);
572 
573 	node_sm_trace();
574 
575 	switch (evt) {
576 	case EFC_EVT_SRRS_ELS_REQ_OK:
577 		if (efc_node_check_ns_req(ctx, evt, arg, FC_NS_RFT_ID,
578 					  __efc_fabric_common, __func__)) {
579 			return;
580 		}
581 		WARN_ON(!node->els_req_cnt);
582 		node->els_req_cnt--;
583 		/* sm: / send RFFID */
584 		efc_ns_send_rffid(node);
585 		efc_node_transition(node, __efc_ns_rffid_wait_rsp, NULL);
586 		break;
587 
588 	/*
589 	 * if receive RSCN just ignore,
590 	 * we haven't sent GID_PT yet (ACC sent by fabctl node)
591 	 */
592 	case EFC_EVT_RSCN_RCVD:
593 		break;
594 
595 	default:
596 		__efc_fabric_common(__func__, ctx, evt, arg);
597 	}
598 }
599 
600 void
601 __efc_ns_rffid_wait_rsp(struct efc_sm_ctx *ctx,
602 			enum efc_sm_event evt, void *arg)
603 {
604 	struct efc_node *node = ctx->app;
605 
606 	efc_node_evt_set(ctx, evt, __func__);
607 
608 	node_sm_trace();
609 
610 	/*
611 	 * Waits for an RFFID response event;
612 	 * if rscn enabled, a GIDPT name services request is issued.
613 	 */
614 	switch (evt) {
615 	case EFC_EVT_SRRS_ELS_REQ_OK:	{
616 		if (efc_node_check_ns_req(ctx, evt, arg, FC_NS_RFF_ID,
617 					  __efc_fabric_common, __func__)) {
618 			return;
619 		}
620 		WARN_ON(!node->els_req_cnt);
621 		node->els_req_cnt--;
622 		if (node->nport->enable_rscn) {
623 			/* sm: if enable_rscn / send GIDPT */
624 			efc_ns_send_gidpt(node);
625 
626 			efc_node_transition(node, __efc_ns_gidpt_wait_rsp,
627 					    NULL);
628 		} else {
629 			/* if 'T' only, we're done, go to idle */
630 			efc_node_transition(node, __efc_ns_idle, NULL);
631 		}
632 		break;
633 	}
634 	/*
635 	 * if receive RSCN just ignore,
636 	 * we haven't sent GID_PT yet (ACC sent by fabctl node)
637 	 */
638 	case EFC_EVT_RSCN_RCVD:
639 		break;
640 
641 	default:
642 		__efc_fabric_common(__func__, ctx, evt, arg);
643 	}
644 }
645 
646 static int
647 efc_process_gidpt_payload(struct efc_node *node,
648 			  void *data, u32 gidpt_len)
649 {
650 	u32 i, j;
651 	struct efc_node *newnode;
652 	struct efc_nport *nport = node->nport;
653 	struct efc *efc = node->efc;
654 	u32 port_id = 0, port_count, plist_count;
655 	struct efc_node *n;
656 	struct efc_node **active_nodes;
657 	int residual;
658 	struct {
659 		struct fc_ct_hdr hdr;
660 		struct fc_gid_pn_resp pn_rsp;
661 	} *rsp;
662 	struct fc_gid_pn_resp *gidpt;
663 	unsigned long index;
664 
665 	rsp = data;
666 	gidpt = &rsp->pn_rsp;
667 	residual = be16_to_cpu(rsp->hdr.ct_mr_size);
668 
669 	if (residual != 0)
670 		efc_log_debug(node->efc, "residual is %u words\n", residual);
671 
672 	if (be16_to_cpu(rsp->hdr.ct_cmd) == FC_FS_RJT) {
673 		node_printf(node,
674 			    "GIDPT request failed: rsn x%x rsn_expl x%x\n",
675 			    rsp->hdr.ct_reason, rsp->hdr.ct_explan);
676 		return -EIO;
677 	}
678 
679 	plist_count = (gidpt_len - sizeof(struct fc_ct_hdr)) / sizeof(*gidpt);
680 
681 	/* Count the number of nodes */
682 	port_count = 0;
683 	xa_for_each(&nport->lookup, index, n) {
684 		port_count++;
685 	}
686 
687 	/* Allocate a buffer for all nodes */
688 	active_nodes = kcalloc(port_count, sizeof(*active_nodes), GFP_ATOMIC);
689 	if (!active_nodes) {
690 		node_printf(node, "efc_malloc failed\n");
691 		return -EIO;
692 	}
693 
694 	/* Fill buffer with fc_id of active nodes */
695 	i = 0;
696 	xa_for_each(&nport->lookup, index, n) {
697 		port_id = n->rnode.fc_id;
698 		switch (port_id) {
699 		case FC_FID_FLOGI:
700 		case FC_FID_FCTRL:
701 		case FC_FID_DIR_SERV:
702 			break;
703 		default:
704 			if (port_id != FC_FID_DOM_MGR)
705 				active_nodes[i++] = n;
706 			break;
707 		}
708 	}
709 
710 	/* update the active nodes buffer */
711 	for (i = 0; i < plist_count; i++) {
712 		hton24(gidpt[i].fp_fid, port_id);
713 
714 		for (j = 0; j < port_count; j++) {
715 			if (active_nodes[j] &&
716 			    port_id == active_nodes[j]->rnode.fc_id) {
717 				active_nodes[j] = NULL;
718 			}
719 		}
720 
721 		if (gidpt[i].fp_resvd & FC_NS_FID_LAST)
722 			break;
723 	}
724 
725 	/* Those remaining in the active_nodes[] are now gone ! */
726 	for (i = 0; i < port_count; i++) {
727 		/*
728 		 * if we're an initiator and the remote node
729 		 * is a target, then post the node missing event.
730 		 * if we're target and we have enabled
731 		 * target RSCN, then post the node missing event.
732 		 */
733 		if (!active_nodes[i])
734 			continue;
735 
736 		if ((node->nport->enable_ini && active_nodes[i]->targ) ||
737 		    (node->nport->enable_tgt && enable_target_rscn(efc))) {
738 			efc_node_post_event(active_nodes[i],
739 					    EFC_EVT_NODE_MISSING, NULL);
740 		} else {
741 			node_printf(node,
742 				    "GID_PT: skipping non-tgt port_id x%06x\n",
743 				    active_nodes[i]->rnode.fc_id);
744 		}
745 	}
746 	kfree(active_nodes);
747 
748 	for (i = 0; i < plist_count; i++) {
749 		hton24(gidpt[i].fp_fid, port_id);
750 
751 		/* Don't create node for ourselves */
752 		if (port_id == node->rnode.nport->fc_id) {
753 			if (gidpt[i].fp_resvd & FC_NS_FID_LAST)
754 				break;
755 			continue;
756 		}
757 
758 		newnode = efc_node_find(nport, port_id);
759 		if (!newnode) {
760 			if (!node->nport->enable_ini)
761 				continue;
762 
763 			newnode = efc_node_alloc(nport, port_id, false, false);
764 			if (!newnode) {
765 				efc_log_err(efc, "efc_node_alloc() failed\n");
766 				return -EIO;
767 			}
768 			/*
769 			 * send PLOGI automatically
770 			 * if initiator
771 			 */
772 			efc_node_init_device(newnode, true);
773 		}
774 
775 		if (node->nport->enable_ini && newnode->targ) {
776 			efc_node_post_event(newnode, EFC_EVT_NODE_REFOUND,
777 					    NULL);
778 		}
779 
780 		if (gidpt[i].fp_resvd & FC_NS_FID_LAST)
781 			break;
782 	}
783 	return 0;
784 }
785 
786 void
787 __efc_ns_gidpt_wait_rsp(struct efc_sm_ctx *ctx,
788 			enum efc_sm_event evt, void *arg)
789 {
790 	struct efc_node_cb *cbdata = arg;
791 	struct efc_node *node = ctx->app;
792 
793 	efc_node_evt_set(ctx, evt, __func__);
794 
795 	node_sm_trace();
796 	/*
797 	 * Wait for a GIDPT response from the name server. Process the FC_IDs
798 	 * that are reported by creating new remote ports, as needed.
799 	 */
800 
801 	switch (evt) {
802 	case EFC_EVT_SRRS_ELS_REQ_OK:	{
803 		if (efc_node_check_ns_req(ctx, evt, arg, FC_NS_GID_PT,
804 					  __efc_fabric_common, __func__)) {
805 			return;
806 		}
807 		WARN_ON(!node->els_req_cnt);
808 		node->els_req_cnt--;
809 		/* sm: / process GIDPT payload */
810 		efc_process_gidpt_payload(node, cbdata->els_rsp.virt,
811 					  cbdata->els_rsp.len);
812 		efc_node_transition(node, __efc_ns_idle, NULL);
813 		break;
814 	}
815 
816 	case EFC_EVT_SRRS_ELS_REQ_FAIL:	{
817 		/* not much we can do; will retry with the next RSCN */
818 		node_printf(node, "GID_PT failed to complete\n");
819 		WARN_ON(!node->els_req_cnt);
820 		node->els_req_cnt--;
821 		efc_node_transition(node, __efc_ns_idle, NULL);
822 		break;
823 	}
824 
825 	/* if receive RSCN here, queue up another discovery processing */
826 	case EFC_EVT_RSCN_RCVD: {
827 		node_printf(node, "RSCN received during GID_PT processing\n");
828 		node->rscn_pending = true;
829 		break;
830 	}
831 
832 	default:
833 		__efc_fabric_common(__func__, ctx, evt, arg);
834 	}
835 }
836 
837 void
838 __efc_ns_idle(struct efc_sm_ctx *ctx, enum efc_sm_event evt, void *arg)
839 {
840 	struct efc_node *node = ctx->app;
841 	struct efc *efc = node->efc;
842 
843 	efc_node_evt_set(ctx, evt, __func__);
844 
845 	node_sm_trace();
846 
847 	/*
848 	 * Wait for RSCN received events (posted from the fabric controller)
849 	 * and restart the GIDPT name services query and processing.
850 	 */
851 
852 	switch (evt) {
853 	case EFC_EVT_ENTER:
854 		if (!node->rscn_pending)
855 			break;
856 
857 		node_printf(node, "RSCN pending, restart discovery\n");
858 		node->rscn_pending = false;
859 		fallthrough;
860 
861 	case EFC_EVT_RSCN_RCVD: {
862 		/* sm: / send GIDPT */
863 		/*
864 		 * If target RSCN processing is enabled,
865 		 * and this is target only (not initiator),
866 		 * and tgt_rscn_delay is non-zero,
867 		 * then we delay issuing the GID_PT
868 		 */
869 		if (efc->tgt_rscn_delay_msec != 0 &&
870 		    !node->nport->enable_ini && node->nport->enable_tgt &&
871 		    enable_target_rscn(efc)) {
872 			efc_node_transition(node, __efc_ns_gidpt_delay, NULL);
873 		} else {
874 			efc_ns_send_gidpt(node);
875 			efc_node_transition(node, __efc_ns_gidpt_wait_rsp,
876 					    NULL);
877 		}
878 		break;
879 	}
880 
881 	default:
882 		__efc_fabric_common(__func__, ctx, evt, arg);
883 	}
884 }
885 
886 static void
887 gidpt_delay_timer_cb(struct timer_list *t)
888 {
889 	struct efc_node *node = from_timer(node, t, gidpt_delay_timer);
890 
891 	del_timer(&node->gidpt_delay_timer);
892 
893 	efc_node_post_event(node, EFC_EVT_GIDPT_DELAY_EXPIRED, NULL);
894 }
895 
896 void
897 __efc_ns_gidpt_delay(struct efc_sm_ctx *ctx,
898 		     enum efc_sm_event evt, void *arg)
899 {
900 	struct efc_node *node = ctx->app;
901 	struct efc *efc = node->efc;
902 
903 	efc_node_evt_set(ctx, evt, __func__);
904 
905 	node_sm_trace();
906 
907 	switch (evt) {
908 	case EFC_EVT_ENTER: {
909 		u64 delay_msec, tmp;
910 
911 		/*
912 		 * Compute the delay time.
913 		 * Set to tgt_rscn_delay, if the time since last GIDPT
914 		 * is less than tgt_rscn_period, then use tgt_rscn_period.
915 		 */
916 		delay_msec = efc->tgt_rscn_delay_msec;
917 		tmp = jiffies_to_msecs(jiffies) - node->time_last_gidpt_msec;
918 		if (tmp < efc->tgt_rscn_period_msec)
919 			delay_msec = efc->tgt_rscn_period_msec;
920 
921 		timer_setup(&node->gidpt_delay_timer, &gidpt_delay_timer_cb,
922 			    0);
923 		mod_timer(&node->gidpt_delay_timer,
924 			  jiffies + msecs_to_jiffies(delay_msec));
925 
926 		break;
927 	}
928 
929 	case EFC_EVT_GIDPT_DELAY_EXPIRED:
930 		node->time_last_gidpt_msec = jiffies_to_msecs(jiffies);
931 
932 		efc_ns_send_gidpt(node);
933 		efc_node_transition(node, __efc_ns_gidpt_wait_rsp, NULL);
934 		break;
935 
936 	case EFC_EVT_RSCN_RCVD: {
937 		efc_log_debug(efc,
938 			      "RSCN received while in GIDPT delay - no action\n");
939 		break;
940 	}
941 
942 	default:
943 		__efc_fabric_common(__func__, ctx, evt, arg);
944 	}
945 }
946 
947 void
948 __efc_fabctl_init(struct efc_sm_ctx *ctx,
949 		  enum efc_sm_event evt, void *arg)
950 {
951 	struct efc_node *node = ctx->app;
952 
953 	node_sm_trace();
954 
955 	switch (evt) {
956 	case EFC_EVT_ENTER:
957 		/* no need to login to fabric controller, just send SCR */
958 		efc_send_scr(node);
959 		efc_node_transition(node, __efc_fabctl_wait_scr_rsp, NULL);
960 		break;
961 
962 	case EFC_EVT_NODE_ATTACH_OK:
963 		node->attached = true;
964 		break;
965 
966 	default:
967 		__efc_fabric_common(__func__, ctx, evt, arg);
968 	}
969 }
970 
971 void
972 __efc_fabctl_wait_scr_rsp(struct efc_sm_ctx *ctx,
973 			  enum efc_sm_event evt, void *arg)
974 {
975 	struct efc_node *node = ctx->app;
976 
977 	efc_node_evt_set(ctx, evt, __func__);
978 
979 	node_sm_trace();
980 
981 	/*
982 	 * Fabric controller node state machine:
983 	 * Wait for an SCR response from the fabric controller.
984 	 */
985 	switch (evt) {
986 	case EFC_EVT_SRRS_ELS_REQ_OK:
987 		if (efc_node_check_els_req(ctx, evt, arg, ELS_SCR,
988 					   __efc_fabric_common, __func__)) {
989 			return;
990 		}
991 		WARN_ON(!node->els_req_cnt);
992 		node->els_req_cnt--;
993 		efc_node_transition(node, __efc_fabctl_ready, NULL);
994 		break;
995 
996 	default:
997 		__efc_fabric_common(__func__, ctx, evt, arg);
998 	}
999 }
1000 
1001 static void
1002 efc_process_rscn(struct efc_node *node, struct efc_node_cb *cbdata)
1003 {
1004 	struct efc *efc = node->efc;
1005 	struct efc_nport *nport = node->nport;
1006 	struct efc_node *ns;
1007 
1008 	/* Forward this event to the name-services node */
1009 	ns = efc_node_find(nport, FC_FID_DIR_SERV);
1010 	if (ns)
1011 		efc_node_post_event(ns, EFC_EVT_RSCN_RCVD, cbdata);
1012 	else
1013 		efc_log_warn(efc, "can't find name server node\n");
1014 }
1015 
1016 void
1017 __efc_fabctl_ready(struct efc_sm_ctx *ctx,
1018 		   enum efc_sm_event evt, void *arg)
1019 {
1020 	struct efc_node_cb *cbdata = arg;
1021 	struct efc_node *node = ctx->app;
1022 
1023 	efc_node_evt_set(ctx, evt, __func__);
1024 
1025 	node_sm_trace();
1026 
1027 	/*
1028 	 * Fabric controller node state machine: Ready.
1029 	 * In this state, the fabric controller sends a RSCN, which is received
1030 	 * by this node and is forwarded to the name services node object; and
1031 	 * the RSCN LS_ACC is sent.
1032 	 */
1033 	switch (evt) {
1034 	case EFC_EVT_RSCN_RCVD: {
1035 		struct fc_frame_header *hdr = cbdata->header->dma.virt;
1036 
1037 		/*
1038 		 * sm: / process RSCN (forward to name services node),
1039 		 * send LS_ACC
1040 		 */
1041 		efc_process_rscn(node, cbdata);
1042 		efc_send_ls_acc(node, be16_to_cpu(hdr->fh_ox_id));
1043 		efc_node_transition(node, __efc_fabctl_wait_ls_acc_cmpl,
1044 				    NULL);
1045 		break;
1046 	}
1047 
1048 	default:
1049 		__efc_fabric_common(__func__, ctx, evt, arg);
1050 	}
1051 }
1052 
1053 void
1054 __efc_fabctl_wait_ls_acc_cmpl(struct efc_sm_ctx *ctx,
1055 			      enum efc_sm_event evt, void *arg)
1056 {
1057 	struct efc_node *node = ctx->app;
1058 
1059 	efc_node_evt_set(ctx, evt, __func__);
1060 
1061 	node_sm_trace();
1062 
1063 	switch (evt) {
1064 	case EFC_EVT_ENTER:
1065 		efc_node_hold_frames(node);
1066 		break;
1067 
1068 	case EFC_EVT_EXIT:
1069 		efc_node_accept_frames(node);
1070 		break;
1071 
1072 	case EFC_EVT_SRRS_ELS_CMPL_OK:
1073 		WARN_ON(!node->els_cmpl_cnt);
1074 		node->els_cmpl_cnt--;
1075 		efc_node_transition(node, __efc_fabctl_ready, NULL);
1076 		break;
1077 
1078 	default:
1079 		__efc_fabric_common(__func__, ctx, evt, arg);
1080 	}
1081 }
1082 
1083 static uint64_t
1084 efc_get_wwpn(struct fc_els_flogi *sp)
1085 {
1086 	return be64_to_cpu(sp->fl_wwnn);
1087 }
1088 
1089 static int
1090 efc_rnode_is_winner(struct efc_nport *nport)
1091 {
1092 	struct fc_els_flogi *remote_sp;
1093 	u64 remote_wwpn;
1094 	u64 local_wwpn = nport->wwpn;
1095 	u64 wwn_bump = 0;
1096 
1097 	remote_sp = (struct fc_els_flogi *)nport->domain->flogi_service_params;
1098 	remote_wwpn = efc_get_wwpn(remote_sp);
1099 
1100 	local_wwpn ^= wwn_bump;
1101 
1102 	efc_log_debug(nport->efc, "r: %llx\n",
1103 		      be64_to_cpu(remote_sp->fl_wwpn));
1104 	efc_log_debug(nport->efc, "l: %llx\n", local_wwpn);
1105 
1106 	if (remote_wwpn == local_wwpn) {
1107 		efc_log_warn(nport->efc,
1108 			     "WWPN of remote node [%08x %08x] matches local WWPN\n",
1109 			     (u32)(local_wwpn >> 32ll),
1110 			     (u32)local_wwpn);
1111 		return -1;
1112 	}
1113 
1114 	return (remote_wwpn > local_wwpn);
1115 }
1116 
1117 void
1118 __efc_p2p_wait_domain_attach(struct efc_sm_ctx *ctx,
1119 			     enum efc_sm_event evt, void *arg)
1120 {
1121 	struct efc_node *node = ctx->app;
1122 	struct efc *efc = node->efc;
1123 
1124 	efc_node_evt_set(ctx, evt, __func__);
1125 
1126 	node_sm_trace();
1127 
1128 	switch (evt) {
1129 	case EFC_EVT_ENTER:
1130 		efc_node_hold_frames(node);
1131 		break;
1132 
1133 	case EFC_EVT_EXIT:
1134 		efc_node_accept_frames(node);
1135 		break;
1136 
1137 	case EFC_EVT_DOMAIN_ATTACH_OK: {
1138 		struct efc_nport *nport = node->nport;
1139 		struct efc_node *rnode;
1140 
1141 		/*
1142 		 * this transient node (SID=0 (recv'd FLOGI)
1143 		 * or DID=fabric (sent FLOGI))
1144 		 * is the p2p winner, will use a separate node
1145 		 * to send PLOGI to peer
1146 		 */
1147 		WARN_ON(!node->nport->p2p_winner);
1148 
1149 		rnode = efc_node_find(nport, node->nport->p2p_remote_port_id);
1150 		if (rnode) {
1151 			/*
1152 			 * the "other" transient p2p node has
1153 			 * already kicked off the
1154 			 * new node from which PLOGI is sent
1155 			 */
1156 			node_printf(node,
1157 				    "Node with fc_id x%x already exists\n",
1158 				    rnode->rnode.fc_id);
1159 		} else {
1160 			/*
1161 			 * create new node (SID=1, DID=2)
1162 			 * from which to send PLOGI
1163 			 */
1164 			rnode = efc_node_alloc(nport,
1165 					       nport->p2p_remote_port_id,
1166 						false, false);
1167 			if (!rnode) {
1168 				efc_log_err(efc, "node alloc failed\n");
1169 				return;
1170 			}
1171 
1172 			efc_fabric_notify_topology(node);
1173 			/* sm: / allocate p2p remote node */
1174 			efc_node_transition(rnode, __efc_p2p_rnode_init,
1175 					    NULL);
1176 		}
1177 
1178 		/*
1179 		 * the transient node (SID=0 or DID=fabric)
1180 		 * has served its purpose
1181 		 */
1182 		if (node->rnode.fc_id == 0) {
1183 			/*
1184 			 * if this is the SID=0 node,
1185 			 * move to the init state in case peer
1186 			 * has restarted FLOGI discovery and FLOGI is pending
1187 			 */
1188 			/* don't send PLOGI on efc_d_init entry */
1189 			efc_node_init_device(node, false);
1190 		} else {
1191 			/*
1192 			 * if this is the DID=fabric node
1193 			 * (we initiated FLOGI), shut it down
1194 			 */
1195 			node->shutdown_reason = EFC_NODE_SHUTDOWN_DEFAULT;
1196 			efc_fabric_initiate_shutdown(node);
1197 		}
1198 		break;
1199 	}
1200 
1201 	default:
1202 		__efc_fabric_common(__func__, ctx, evt, arg);
1203 	}
1204 }
1205 
1206 void
1207 __efc_p2p_rnode_init(struct efc_sm_ctx *ctx,
1208 		     enum efc_sm_event evt, void *arg)
1209 {
1210 	struct efc_node_cb *cbdata = arg;
1211 	struct efc_node *node = ctx->app;
1212 
1213 	efc_node_evt_set(ctx, evt, __func__);
1214 
1215 	node_sm_trace();
1216 
1217 	switch (evt) {
1218 	case EFC_EVT_ENTER:
1219 		/* sm: / send PLOGI */
1220 		efc_send_plogi(node);
1221 		efc_node_transition(node, __efc_p2p_wait_plogi_rsp, NULL);
1222 		break;
1223 
1224 	case EFC_EVT_ABTS_RCVD:
1225 		/* sm: send BA_ACC */
1226 		efc_send_bls_acc(node, cbdata->header->dma.virt);
1227 
1228 		break;
1229 
1230 	default:
1231 		__efc_fabric_common(__func__, ctx, evt, arg);
1232 	}
1233 }
1234 
1235 void
1236 __efc_p2p_wait_flogi_acc_cmpl(struct efc_sm_ctx *ctx,
1237 			      enum efc_sm_event evt, void *arg)
1238 {
1239 	struct efc_node_cb *cbdata = arg;
1240 	struct efc_node *node = ctx->app;
1241 
1242 	efc_node_evt_set(ctx, evt, __func__);
1243 
1244 	node_sm_trace();
1245 
1246 	switch (evt) {
1247 	case EFC_EVT_ENTER:
1248 		efc_node_hold_frames(node);
1249 		break;
1250 
1251 	case EFC_EVT_EXIT:
1252 		efc_node_accept_frames(node);
1253 		break;
1254 
1255 	case EFC_EVT_SRRS_ELS_CMPL_OK:
1256 		WARN_ON(!node->els_cmpl_cnt);
1257 		node->els_cmpl_cnt--;
1258 
1259 		/* sm: if p2p_winner / domain_attach */
1260 		if (node->nport->p2p_winner) {
1261 			efc_node_transition(node,
1262 					    __efc_p2p_wait_domain_attach,
1263 					NULL);
1264 			if (!node->nport->domain->attached) {
1265 				node_printf(node, "Domain not attached\n");
1266 				efc_domain_attach(node->nport->domain,
1267 						  node->nport->p2p_port_id);
1268 			} else {
1269 				node_printf(node, "Domain already attached\n");
1270 				efc_node_post_event(node,
1271 						    EFC_EVT_DOMAIN_ATTACH_OK,
1272 						    NULL);
1273 			}
1274 		} else {
1275 			/* this node has served its purpose;
1276 			 * we'll expect a PLOGI on a separate
1277 			 * node (remote SID=0x1); return this node
1278 			 * to init state in case peer
1279 			 * restarts discovery -- it may already
1280 			 * have (pending frames may exist).
1281 			 */
1282 			/* don't send PLOGI on efc_d_init entry */
1283 			efc_node_init_device(node, false);
1284 		}
1285 		break;
1286 
1287 	case EFC_EVT_SRRS_ELS_CMPL_FAIL:
1288 		/*
1289 		 * LS_ACC failed, possibly due to link down;
1290 		 * shutdown node and wait
1291 		 * for FLOGI discovery to restart
1292 		 */
1293 		node_printf(node, "FLOGI LS_ACC failed, shutting down\n");
1294 		WARN_ON(!node->els_cmpl_cnt);
1295 		node->els_cmpl_cnt--;
1296 		node->shutdown_reason = EFC_NODE_SHUTDOWN_DEFAULT;
1297 		efc_fabric_initiate_shutdown(node);
1298 		break;
1299 
1300 	case EFC_EVT_ABTS_RCVD: {
1301 		/* sm: / send BA_ACC */
1302 		efc_send_bls_acc(node, cbdata->header->dma.virt);
1303 		break;
1304 	}
1305 
1306 	default:
1307 		__efc_fabric_common(__func__, ctx, evt, arg);
1308 	}
1309 }
1310 
1311 void
1312 __efc_p2p_wait_plogi_rsp(struct efc_sm_ctx *ctx,
1313 			 enum efc_sm_event evt, void *arg)
1314 {
1315 	struct efc_node_cb *cbdata = arg;
1316 	struct efc_node *node = ctx->app;
1317 
1318 	efc_node_evt_set(ctx, evt, __func__);
1319 
1320 	node_sm_trace();
1321 
1322 	switch (evt) {
1323 	case EFC_EVT_SRRS_ELS_REQ_OK: {
1324 		int rc;
1325 
1326 		if (efc_node_check_els_req(ctx, evt, arg, ELS_PLOGI,
1327 					   __efc_fabric_common, __func__)) {
1328 			return;
1329 		}
1330 		WARN_ON(!node->els_req_cnt);
1331 		node->els_req_cnt--;
1332 		/* sm: / save sparams, efc_node_attach */
1333 		efc_node_save_sparms(node, cbdata->els_rsp.virt);
1334 		rc = efc_node_attach(node);
1335 		efc_node_transition(node, __efc_p2p_wait_node_attach, NULL);
1336 		if (rc < 0)
1337 			efc_node_post_event(node, EFC_EVT_NODE_ATTACH_FAIL,
1338 					    NULL);
1339 		break;
1340 	}
1341 	case EFC_EVT_SRRS_ELS_REQ_FAIL: {
1342 		if (efc_node_check_els_req(ctx, evt, arg, ELS_PLOGI,
1343 					   __efc_fabric_common, __func__)) {
1344 			return;
1345 		}
1346 		node_printf(node, "PLOGI failed, shutting down\n");
1347 		WARN_ON(!node->els_req_cnt);
1348 		node->els_req_cnt--;
1349 		node->shutdown_reason = EFC_NODE_SHUTDOWN_DEFAULT;
1350 		efc_fabric_initiate_shutdown(node);
1351 		break;
1352 	}
1353 
1354 	case EFC_EVT_PLOGI_RCVD: {
1355 		struct fc_frame_header *hdr = cbdata->header->dma.virt;
1356 		/* if we're in external loopback mode, just send LS_ACC */
1357 		if (node->efc->external_loopback) {
1358 			efc_send_plogi_acc(node, be16_to_cpu(hdr->fh_ox_id));
1359 		} else {
1360 			/*
1361 			 * if this isn't external loopback,
1362 			 * pass to default handler
1363 			 */
1364 			__efc_fabric_common(__func__, ctx, evt, arg);
1365 		}
1366 		break;
1367 	}
1368 	case EFC_EVT_PRLI_RCVD:
1369 		/* I, or I+T */
1370 		/* sent PLOGI and before completion was seen, received the
1371 		 * PRLI from the remote node (WCQEs and RCQEs come in on
1372 		 * different queues and order of processing cannot be assumed)
1373 		 * Save OXID so PRLI can be sent after the attach and continue
1374 		 * to wait for PLOGI response
1375 		 */
1376 		efc_process_prli_payload(node, cbdata->payload->dma.virt);
1377 		efc_send_ls_acc_after_attach(node,
1378 					     cbdata->header->dma.virt,
1379 					     EFC_NODE_SEND_LS_ACC_PRLI);
1380 		efc_node_transition(node, __efc_p2p_wait_plogi_rsp_recvd_prli,
1381 				    NULL);
1382 		break;
1383 	default:
1384 		__efc_fabric_common(__func__, ctx, evt, arg);
1385 	}
1386 }
1387 
1388 void
1389 __efc_p2p_wait_plogi_rsp_recvd_prli(struct efc_sm_ctx *ctx,
1390 				    enum efc_sm_event evt, void *arg)
1391 {
1392 	struct efc_node_cb *cbdata = arg;
1393 	struct efc_node *node = ctx->app;
1394 
1395 	efc_node_evt_set(ctx, evt, __func__);
1396 
1397 	node_sm_trace();
1398 
1399 	switch (evt) {
1400 	case EFC_EVT_ENTER:
1401 		/*
1402 		 * Since we've received a PRLI, we have a port login and will
1403 		 * just need to wait for the PLOGI response to do the node
1404 		 * attach and then we can send the LS_ACC for the PRLI. If,
1405 		 * during this time, we receive FCP_CMNDs (which is possible
1406 		 * since we've already sent a PRLI and our peer may have
1407 		 * accepted).
1408 		 * At this time, we are not waiting on any other unsolicited
1409 		 * frames to continue with the login process. Thus, it will not
1410 		 * hurt to hold frames here.
1411 		 */
1412 		efc_node_hold_frames(node);
1413 		break;
1414 
1415 	case EFC_EVT_EXIT:
1416 		efc_node_accept_frames(node);
1417 		break;
1418 
1419 	case EFC_EVT_SRRS_ELS_REQ_OK: {	/* PLOGI response received */
1420 		int rc;
1421 
1422 		/* Completion from PLOGI sent */
1423 		if (efc_node_check_els_req(ctx, evt, arg, ELS_PLOGI,
1424 					   __efc_fabric_common, __func__)) {
1425 			return;
1426 		}
1427 		WARN_ON(!node->els_req_cnt);
1428 		node->els_req_cnt--;
1429 		/* sm: / save sparams, efc_node_attach */
1430 		efc_node_save_sparms(node, cbdata->els_rsp.virt);
1431 		rc = efc_node_attach(node);
1432 		efc_node_transition(node, __efc_p2p_wait_node_attach, NULL);
1433 		if (rc < 0)
1434 			efc_node_post_event(node, EFC_EVT_NODE_ATTACH_FAIL,
1435 					    NULL);
1436 		break;
1437 	}
1438 	case EFC_EVT_SRRS_ELS_REQ_FAIL:	/* PLOGI response received */
1439 	case EFC_EVT_SRRS_ELS_REQ_RJT:
1440 		/* PLOGI failed, shutdown the node */
1441 		if (efc_node_check_els_req(ctx, evt, arg, ELS_PLOGI,
1442 					   __efc_fabric_common, __func__)) {
1443 			return;
1444 		}
1445 		WARN_ON(!node->els_req_cnt);
1446 		node->els_req_cnt--;
1447 		node->shutdown_reason = EFC_NODE_SHUTDOWN_DEFAULT;
1448 		efc_fabric_initiate_shutdown(node);
1449 		break;
1450 
1451 	default:
1452 		__efc_fabric_common(__func__, ctx, evt, arg);
1453 	}
1454 }
1455 
1456 void
1457 __efc_p2p_wait_node_attach(struct efc_sm_ctx *ctx,
1458 			   enum efc_sm_event evt, void *arg)
1459 {
1460 	struct efc_node_cb *cbdata = arg;
1461 	struct efc_node *node = ctx->app;
1462 
1463 	efc_node_evt_set(ctx, evt, __func__);
1464 
1465 	node_sm_trace();
1466 
1467 	switch (evt) {
1468 	case EFC_EVT_ENTER:
1469 		efc_node_hold_frames(node);
1470 		break;
1471 
1472 	case EFC_EVT_EXIT:
1473 		efc_node_accept_frames(node);
1474 		break;
1475 
1476 	case EFC_EVT_NODE_ATTACH_OK:
1477 		node->attached = true;
1478 		switch (node->send_ls_acc) {
1479 		case EFC_NODE_SEND_LS_ACC_PRLI: {
1480 			efc_d_send_prli_rsp(node->ls_acc_io,
1481 					    node->ls_acc_oxid);
1482 			node->send_ls_acc = EFC_NODE_SEND_LS_ACC_NONE;
1483 			node->ls_acc_io = NULL;
1484 			break;
1485 		}
1486 		case EFC_NODE_SEND_LS_ACC_PLOGI: /* Can't happen in P2P */
1487 		case EFC_NODE_SEND_LS_ACC_NONE:
1488 		default:
1489 			/* Normal case for I */
1490 			/* sm: send_plogi_acc is not set / send PLOGI acc */
1491 			efc_node_transition(node, __efc_d_port_logged_in,
1492 					    NULL);
1493 			break;
1494 		}
1495 		break;
1496 
1497 	case EFC_EVT_NODE_ATTACH_FAIL:
1498 		/* node attach failed, shutdown the node */
1499 		node->attached = false;
1500 		node_printf(node, "Node attach failed\n");
1501 		node->shutdown_reason = EFC_NODE_SHUTDOWN_DEFAULT;
1502 		efc_fabric_initiate_shutdown(node);
1503 		break;
1504 
1505 	case EFC_EVT_SHUTDOWN:
1506 		node_printf(node, "%s received\n", efc_sm_event_name(evt));
1507 		node->shutdown_reason = EFC_NODE_SHUTDOWN_DEFAULT;
1508 		efc_node_transition(node,
1509 				    __efc_fabric_wait_attach_evt_shutdown,
1510 				     NULL);
1511 		break;
1512 	case EFC_EVT_PRLI_RCVD:
1513 		node_printf(node, "%s: PRLI received before node is attached\n",
1514 			    efc_sm_event_name(evt));
1515 		efc_process_prli_payload(node, cbdata->payload->dma.virt);
1516 		efc_send_ls_acc_after_attach(node,
1517 					     cbdata->header->dma.virt,
1518 				EFC_NODE_SEND_LS_ACC_PRLI);
1519 		break;
1520 
1521 	default:
1522 		__efc_fabric_common(__func__, ctx, evt, arg);
1523 	}
1524 }
1525 
1526 int
1527 efc_p2p_setup(struct efc_nport *nport)
1528 {
1529 	struct efc *efc = nport->efc;
1530 	int rnode_winner;
1531 
1532 	rnode_winner = efc_rnode_is_winner(nport);
1533 
1534 	/* set nport flags to indicate p2p "winner" */
1535 	if (rnode_winner == 1) {
1536 		nport->p2p_remote_port_id = 0;
1537 		nport->p2p_port_id = 0;
1538 		nport->p2p_winner = false;
1539 	} else if (rnode_winner == 0) {
1540 		nport->p2p_remote_port_id = 2;
1541 		nport->p2p_port_id = 1;
1542 		nport->p2p_winner = true;
1543 	} else {
1544 		/* no winner; only okay if external loopback enabled */
1545 		if (nport->efc->external_loopback) {
1546 			/*
1547 			 * External loopback mode enabled;
1548 			 * local nport and remote node
1549 			 * will be registered with an NPortID = 1;
1550 			 */
1551 			efc_log_debug(efc,
1552 				      "External loopback mode enabled\n");
1553 			nport->p2p_remote_port_id = 1;
1554 			nport->p2p_port_id = 1;
1555 			nport->p2p_winner = true;
1556 		} else {
1557 			efc_log_warn(efc,
1558 				     "failed to determine p2p winner\n");
1559 			return rnode_winner;
1560 		}
1561 	}
1562 	return 0;
1563 }
1564