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  * device_sm Node State Machine: Remote Device States
9  */
10 
11 #include "efc.h"
12 #include "efc_device.h"
13 #include "efc_fabric.h"
14 
15 void
16 efc_d_send_prli_rsp(struct efc_node *node, u16 ox_id)
17 {
18 	int rc = EFC_SCSI_CALL_COMPLETE;
19 	struct efc *efc = node->efc;
20 
21 	node->ls_acc_oxid = ox_id;
22 	node->send_ls_acc = EFC_NODE_SEND_LS_ACC_PRLI;
23 
24 	/*
25 	 * Wait for backend session registration
26 	 * to complete before sending PRLI resp
27 	 */
28 
29 	if (node->init) {
30 		efc_log_info(efc, "[%s] found(initiator) WWPN:%s WWNN:%s\n",
31 			     node->display_name, node->wwpn, node->wwnn);
32 		if (node->nport->enable_tgt)
33 			rc = efc->tt.scsi_new_node(efc, node);
34 	}
35 
36 	if (rc < 0)
37 		efc_node_post_event(node, EFC_EVT_NODE_SESS_REG_FAIL, NULL);
38 
39 	if (rc == EFC_SCSI_CALL_COMPLETE)
40 		efc_node_post_event(node, EFC_EVT_NODE_SESS_REG_OK, NULL);
41 }
42 
43 static void
44 __efc_d_common(const char *funcname, struct efc_sm_ctx *ctx,
45 	       enum efc_sm_event evt, void *arg)
46 {
47 	struct efc_node *node = NULL;
48 	struct efc *efc = NULL;
49 
50 	node = ctx->app;
51 	efc = node->efc;
52 
53 	switch (evt) {
54 	/* Handle shutdown events */
55 	case EFC_EVT_SHUTDOWN:
56 		efc_log_debug(efc, "[%s] %-20s %-20s\n", node->display_name,
57 			      funcname, efc_sm_event_name(evt));
58 		node->shutdown_reason = EFC_NODE_SHUTDOWN_DEFAULT;
59 		efc_node_transition(node, __efc_d_initiate_shutdown, NULL);
60 		break;
61 	case EFC_EVT_SHUTDOWN_EXPLICIT_LOGO:
62 		efc_log_debug(efc, "[%s] %-20s %-20s\n",
63 			      node->display_name, funcname,
64 				efc_sm_event_name(evt));
65 		node->shutdown_reason = EFC_NODE_SHUTDOWN_EXPLICIT_LOGO;
66 		efc_node_transition(node, __efc_d_initiate_shutdown, NULL);
67 		break;
68 	case EFC_EVT_SHUTDOWN_IMPLICIT_LOGO:
69 		efc_log_debug(efc, "[%s] %-20s %-20s\n", node->display_name,
70 			      funcname, efc_sm_event_name(evt));
71 		node->shutdown_reason = EFC_NODE_SHUTDOWN_IMPLICIT_LOGO;
72 		efc_node_transition(node, __efc_d_initiate_shutdown, NULL);
73 		break;
74 
75 	default:
76 		/* call default event handler common to all nodes */
77 		__efc_node_common(funcname, ctx, evt, arg);
78 	}
79 }
80 
81 static void
82 __efc_d_wait_del_node(struct efc_sm_ctx *ctx,
83 		      enum efc_sm_event evt, void *arg)
84 {
85 	struct efc_node *node = ctx->app;
86 
87 	efc_node_evt_set(ctx, evt, __func__);
88 
89 	/*
90 	 * State is entered when a node sends a delete initiator/target call
91 	 * to the target-server/initiator-client and needs to wait for that
92 	 * work to complete.
93 	 */
94 	node_sm_trace();
95 
96 	switch (evt) {
97 	case EFC_EVT_ENTER:
98 		efc_node_hold_frames(node);
99 		fallthrough;
100 
101 	case EFC_EVT_NODE_ACTIVE_IO_LIST_EMPTY:
102 	case EFC_EVT_ALL_CHILD_NODES_FREE:
103 		/* These are expected events. */
104 		break;
105 
106 	case EFC_EVT_NODE_DEL_INI_COMPLETE:
107 	case EFC_EVT_NODE_DEL_TGT_COMPLETE:
108 		/*
109 		 * node has either been detached or is in the process
110 		 * of being detached,
111 		 * call common node's initiate cleanup function
112 		 */
113 		efc_node_initiate_cleanup(node);
114 		break;
115 
116 	case EFC_EVT_EXIT:
117 		efc_node_accept_frames(node);
118 		break;
119 
120 	case EFC_EVT_SRRS_ELS_REQ_FAIL:
121 		/* Can happen as ELS IO IO's complete */
122 		WARN_ON(!node->els_req_cnt);
123 		node->els_req_cnt--;
124 		break;
125 
126 	/* ignore shutdown events as we're already in shutdown path */
127 	case EFC_EVT_SHUTDOWN:
128 		/* have default shutdown event take precedence */
129 		node->shutdown_reason = EFC_NODE_SHUTDOWN_DEFAULT;
130 		fallthrough;
131 
132 	case EFC_EVT_SHUTDOWN_EXPLICIT_LOGO:
133 	case EFC_EVT_SHUTDOWN_IMPLICIT_LOGO:
134 		node_printf(node, "%s received\n", efc_sm_event_name(evt));
135 		break;
136 	case EFC_EVT_DOMAIN_ATTACH_OK:
137 		/* don't care about domain_attach_ok */
138 		break;
139 	default:
140 		__efc_d_common(__func__, ctx, evt, arg);
141 	}
142 }
143 
144 static void
145 __efc_d_wait_del_ini_tgt(struct efc_sm_ctx *ctx,
146 			 enum efc_sm_event evt, void *arg)
147 {
148 	struct efc_node *node = ctx->app;
149 
150 	efc_node_evt_set(ctx, evt, __func__);
151 
152 	node_sm_trace();
153 
154 	switch (evt) {
155 	case EFC_EVT_ENTER:
156 		efc_node_hold_frames(node);
157 		fallthrough;
158 
159 	case EFC_EVT_NODE_ACTIVE_IO_LIST_EMPTY:
160 	case EFC_EVT_ALL_CHILD_NODES_FREE:
161 		/* These are expected events. */
162 		break;
163 
164 	case EFC_EVT_NODE_DEL_INI_COMPLETE:
165 	case EFC_EVT_NODE_DEL_TGT_COMPLETE:
166 		efc_node_transition(node, __efc_d_wait_del_node, NULL);
167 		break;
168 
169 	case EFC_EVT_EXIT:
170 		efc_node_accept_frames(node);
171 		break;
172 
173 	case EFC_EVT_SRRS_ELS_REQ_FAIL:
174 		/* Can happen as ELS IO IO's complete */
175 		WARN_ON(!node->els_req_cnt);
176 		node->els_req_cnt--;
177 		break;
178 
179 	/* ignore shutdown events as we're already in shutdown path */
180 	case EFC_EVT_SHUTDOWN:
181 		/* have default shutdown event take precedence */
182 		node->shutdown_reason = EFC_NODE_SHUTDOWN_DEFAULT;
183 		fallthrough;
184 
185 	case EFC_EVT_SHUTDOWN_EXPLICIT_LOGO:
186 	case EFC_EVT_SHUTDOWN_IMPLICIT_LOGO:
187 		node_printf(node, "%s received\n", efc_sm_event_name(evt));
188 		break;
189 	case EFC_EVT_DOMAIN_ATTACH_OK:
190 		/* don't care about domain_attach_ok */
191 		break;
192 	default:
193 		__efc_d_common(__func__, ctx, evt, arg);
194 	}
195 }
196 
197 void
198 __efc_d_initiate_shutdown(struct efc_sm_ctx *ctx,
199 			  enum efc_sm_event evt, void *arg)
200 {
201 	struct efc_node *node = ctx->app;
202 	struct efc *efc = node->efc;
203 
204 	efc_node_evt_set(ctx, evt, __func__);
205 
206 	node_sm_trace();
207 
208 	switch (evt) {
209 	case EFC_EVT_ENTER: {
210 		int rc = EFC_SCSI_CALL_COMPLETE;
211 
212 		/* assume no wait needed */
213 		node->els_io_enabled = false;
214 
215 		/* make necessary delete upcall(s) */
216 		if (node->init && !node->targ) {
217 			efc_log_info(node->efc,
218 				     "[%s] delete (initiator) WWPN %s WWNN %s\n",
219 				node->display_name,
220 				node->wwpn, node->wwnn);
221 			efc_node_transition(node,
222 					    __efc_d_wait_del_node,
223 					     NULL);
224 			if (node->nport->enable_tgt)
225 				rc = efc->tt.scsi_del_node(efc, node,
226 					EFC_SCSI_INITIATOR_DELETED);
227 
228 			if (rc == EFC_SCSI_CALL_COMPLETE || rc < 0)
229 				efc_node_post_event(node,
230 					EFC_EVT_NODE_DEL_INI_COMPLETE, NULL);
231 
232 		} else if (node->targ && !node->init) {
233 			efc_log_info(node->efc,
234 				     "[%s] delete (target) WWPN %s WWNN %s\n",
235 				node->display_name,
236 				node->wwpn, node->wwnn);
237 			efc_node_transition(node,
238 					    __efc_d_wait_del_node,
239 					     NULL);
240 			if (node->nport->enable_ini)
241 				rc = efc->tt.scsi_del_node(efc, node,
242 					EFC_SCSI_TARGET_DELETED);
243 
244 			if (rc == EFC_SCSI_CALL_COMPLETE)
245 				efc_node_post_event(node,
246 					EFC_EVT_NODE_DEL_TGT_COMPLETE, NULL);
247 
248 		} else if (node->init && node->targ) {
249 			efc_log_info(node->efc,
250 				     "[%s] delete (I+T) WWPN %s WWNN %s\n",
251 				node->display_name, node->wwpn, node->wwnn);
252 			efc_node_transition(node, __efc_d_wait_del_ini_tgt,
253 					    NULL);
254 			if (node->nport->enable_tgt)
255 				rc = efc->tt.scsi_del_node(efc, node,
256 						EFC_SCSI_INITIATOR_DELETED);
257 
258 			if (rc == EFC_SCSI_CALL_COMPLETE)
259 				efc_node_post_event(node,
260 					EFC_EVT_NODE_DEL_INI_COMPLETE, NULL);
261 			/* assume no wait needed */
262 			rc = EFC_SCSI_CALL_COMPLETE;
263 			if (node->nport->enable_ini)
264 				rc = efc->tt.scsi_del_node(efc, node,
265 						EFC_SCSI_TARGET_DELETED);
266 
267 			if (rc == EFC_SCSI_CALL_COMPLETE)
268 				efc_node_post_event(node,
269 					EFC_EVT_NODE_DEL_TGT_COMPLETE, NULL);
270 		}
271 
272 		/* we've initiated the upcalls as needed, now kick off the node
273 		 * detach to precipitate the aborting of outstanding exchanges
274 		 * associated with said node
275 		 *
276 		 * Beware: if we've made upcall(s), we've already transitioned
277 		 * to a new state by the time we execute this.
278 		 * consider doing this before the upcalls?
279 		 */
280 		if (node->attached) {
281 			/* issue hw node free; don't care if succeeds right
282 			 * away or sometime later, will check node->attached
283 			 * later in shutdown process
284 			 */
285 			rc = efc_cmd_node_detach(efc, &node->rnode);
286 			if (rc < 0)
287 				node_printf(node,
288 					    "Failed freeing HW node, rc=%d\n",
289 					rc);
290 		}
291 
292 		/* if neither initiator nor target, proceed to cleanup */
293 		if (!node->init && !node->targ) {
294 			/*
295 			 * node has either been detached or is in
296 			 * the process of being detached,
297 			 * call common node's initiate cleanup function
298 			 */
299 			efc_node_initiate_cleanup(node);
300 		}
301 		break;
302 	}
303 	case EFC_EVT_ALL_CHILD_NODES_FREE:
304 		/* Ignore, this can happen if an ELS is
305 		 * aborted while in a delay/retry state
306 		 */
307 		break;
308 	default:
309 		__efc_d_common(__func__, ctx, evt, arg);
310 	}
311 }
312 
313 void
314 __efc_d_wait_loop(struct efc_sm_ctx *ctx,
315 		  enum efc_sm_event evt, void *arg)
316 {
317 	struct efc_node *node = ctx->app;
318 
319 	efc_node_evt_set(ctx, evt, __func__);
320 
321 	node_sm_trace();
322 
323 	switch (evt) {
324 	case EFC_EVT_ENTER:
325 		efc_node_hold_frames(node);
326 		break;
327 
328 	case EFC_EVT_EXIT:
329 		efc_node_accept_frames(node);
330 		break;
331 
332 	case EFC_EVT_DOMAIN_ATTACH_OK: {
333 		/* send PLOGI automatically if initiator */
334 		efc_node_init_device(node, true);
335 		break;
336 	}
337 	default:
338 		__efc_d_common(__func__, ctx, evt, arg);
339 	}
340 }
341 
342 void
343 efc_send_ls_acc_after_attach(struct efc_node *node,
344 			     struct fc_frame_header *hdr,
345 			     enum efc_node_send_ls_acc ls)
346 {
347 	u16 ox_id = be16_to_cpu(hdr->fh_ox_id);
348 
349 	/* Save the OX_ID for sending LS_ACC sometime later */
350 	WARN_ON(node->send_ls_acc != EFC_NODE_SEND_LS_ACC_NONE);
351 
352 	node->ls_acc_oxid = ox_id;
353 	node->send_ls_acc = ls;
354 	node->ls_acc_did = ntoh24(hdr->fh_d_id);
355 }
356 
357 void
358 efc_process_prli_payload(struct efc_node *node, void *prli)
359 {
360 	struct {
361 		struct fc_els_prli prli;
362 		struct fc_els_spp sp;
363 	} *pp;
364 
365 	pp = prli;
366 	node->init = (pp->sp.spp_flags & FCP_SPPF_INIT_FCN) != 0;
367 	node->targ = (pp->sp.spp_flags & FCP_SPPF_TARG_FCN) != 0;
368 }
369 
370 void
371 __efc_d_wait_plogi_acc_cmpl(struct efc_sm_ctx *ctx,
372 			    enum efc_sm_event evt, void *arg)
373 {
374 	struct efc_node *node = ctx->app;
375 
376 	efc_node_evt_set(ctx, evt, __func__);
377 
378 	node_sm_trace();
379 
380 	switch (evt) {
381 	case EFC_EVT_ENTER:
382 		efc_node_hold_frames(node);
383 		break;
384 
385 	case EFC_EVT_EXIT:
386 		efc_node_accept_frames(node);
387 		break;
388 
389 	case EFC_EVT_SRRS_ELS_CMPL_FAIL:
390 		WARN_ON(!node->els_cmpl_cnt);
391 		node->els_cmpl_cnt--;
392 		node->shutdown_reason = EFC_NODE_SHUTDOWN_DEFAULT;
393 		efc_node_transition(node, __efc_d_initiate_shutdown, NULL);
394 		break;
395 
396 	case EFC_EVT_SRRS_ELS_CMPL_OK:	/* PLOGI ACC completions */
397 		WARN_ON(!node->els_cmpl_cnt);
398 		node->els_cmpl_cnt--;
399 		efc_node_transition(node, __efc_d_port_logged_in, NULL);
400 		break;
401 
402 	default:
403 		__efc_d_common(__func__, ctx, evt, arg);
404 	}
405 }
406 
407 void
408 __efc_d_wait_logo_rsp(struct efc_sm_ctx *ctx,
409 		      enum efc_sm_event evt, void *arg)
410 {
411 	struct efc_node *node = ctx->app;
412 
413 	efc_node_evt_set(ctx, evt, __func__);
414 
415 	node_sm_trace();
416 
417 	switch (evt) {
418 	case EFC_EVT_ENTER:
419 		efc_node_hold_frames(node);
420 		break;
421 
422 	case EFC_EVT_EXIT:
423 		efc_node_accept_frames(node);
424 		break;
425 
426 	case EFC_EVT_SRRS_ELS_REQ_OK:
427 	case EFC_EVT_SRRS_ELS_REQ_RJT:
428 	case EFC_EVT_SRRS_ELS_REQ_FAIL:
429 		/* LOGO response received, sent shutdown */
430 		if (efc_node_check_els_req(ctx, evt, arg, ELS_LOGO,
431 					   __efc_d_common, __func__))
432 			return;
433 
434 		WARN_ON(!node->els_req_cnt);
435 		node->els_req_cnt--;
436 		node_printf(node,
437 			    "LOGO sent (evt=%s), shutdown node\n",
438 			efc_sm_event_name(evt));
439 		/* sm: / post explicit logout */
440 		efc_node_post_event(node, EFC_EVT_SHUTDOWN_EXPLICIT_LOGO,
441 				    NULL);
442 		break;
443 
444 	default:
445 		__efc_d_common(__func__, ctx, evt, arg);
446 	}
447 }
448 
449 void
450 efc_node_init_device(struct efc_node *node, bool send_plogi)
451 {
452 	node->send_plogi = send_plogi;
453 	if ((node->efc->nodedb_mask & EFC_NODEDB_PAUSE_NEW_NODES) &&
454 	    (node->rnode.fc_id != FC_FID_DOM_MGR)) {
455 		node->nodedb_state = __efc_d_init;
456 		efc_node_transition(node, __efc_node_paused, NULL);
457 	} else {
458 		efc_node_transition(node, __efc_d_init, NULL);
459 	}
460 }
461 
462 static void
463 efc_d_check_plogi_topology(struct efc_node *node, u32 d_id)
464 {
465 	switch (node->nport->topology) {
466 	case EFC_NPORT_TOPO_P2P:
467 		/* we're not attached and nport is p2p,
468 		 * need to attach
469 		 */
470 		efc_domain_attach(node->nport->domain, d_id);
471 		efc_node_transition(node, __efc_d_wait_domain_attach, NULL);
472 		break;
473 	case EFC_NPORT_TOPO_FABRIC:
474 		/* we're not attached and nport is fabric, domain
475 		 * attach should have already been requested as part
476 		 * of the fabric state machine, wait for it
477 		 */
478 		efc_node_transition(node, __efc_d_wait_domain_attach, NULL);
479 		break;
480 	case EFC_NPORT_TOPO_UNKNOWN:
481 		/* Two possibilities:
482 		 * 1. received a PLOGI before our FLOGI has completed
483 		 *    (possible since completion comes in on another
484 		 *    CQ), thus we don't know what we're connected to
485 		 *    yet; transition to a state to wait for the
486 		 *    fabric node to tell us;
487 		 * 2. PLOGI received before link went down and we
488 		 * haven't performed domain attach yet.
489 		 * Note: we cannot distinguish between 1. and 2.
490 		 * so have to assume PLOGI
491 		 * was received after link back up.
492 		 */
493 		node_printf(node, "received PLOGI, unknown topology did=0x%x\n",
494 			    d_id);
495 		efc_node_transition(node, __efc_d_wait_topology_notify, NULL);
496 		break;
497 	default:
498 		node_printf(node, "received PLOGI, unexpected topology %d\n",
499 			    node->nport->topology);
500 	}
501 }
502 
503 void
504 __efc_d_init(struct efc_sm_ctx *ctx, enum efc_sm_event evt, void *arg)
505 {
506 	struct efc_node_cb *cbdata = arg;
507 	struct efc_node *node = ctx->app;
508 
509 	efc_node_evt_set(ctx, evt, __func__);
510 
511 	node_sm_trace();
512 
513 	/*
514 	 * This state is entered when a node is instantiated,
515 	 * either having been discovered from a name services query,
516 	 * or having received a PLOGI/FLOGI.
517 	 */
518 	switch (evt) {
519 	case EFC_EVT_ENTER:
520 		if (!node->send_plogi)
521 			break;
522 		/* only send if we have initiator capability,
523 		 * and domain is attached
524 		 */
525 		if (node->nport->enable_ini &&
526 		    node->nport->domain->attached) {
527 			efc_send_plogi(node);
528 
529 			efc_node_transition(node, __efc_d_wait_plogi_rsp, NULL);
530 		} else {
531 			node_printf(node, "not sending plogi nport.ini=%d,",
532 				    node->nport->enable_ini);
533 			node_printf(node, "domain attached=%d\n",
534 				    node->nport->domain->attached);
535 		}
536 		break;
537 	case EFC_EVT_PLOGI_RCVD: {
538 		/* T, or I+T */
539 		struct fc_frame_header *hdr = cbdata->header->dma.virt;
540 		int rc;
541 
542 		efc_node_save_sparms(node, cbdata->payload->dma.virt);
543 		efc_send_ls_acc_after_attach(node,
544 					     cbdata->header->dma.virt,
545 					     EFC_NODE_SEND_LS_ACC_PLOGI);
546 
547 		/* domain not attached; several possibilities: */
548 		if (!node->nport->domain->attached) {
549 			efc_d_check_plogi_topology(node, ntoh24(hdr->fh_d_id));
550 			break;
551 		}
552 
553 		/* domain already attached */
554 		rc = efc_node_attach(node);
555 		efc_node_transition(node, __efc_d_wait_node_attach, NULL);
556 		if (rc < 0)
557 			efc_node_post_event(node, EFC_EVT_NODE_ATTACH_FAIL, NULL);
558 
559 		break;
560 	}
561 
562 	case EFC_EVT_FDISC_RCVD: {
563 		__efc_d_common(__func__, ctx, evt, arg);
564 		break;
565 	}
566 
567 	case EFC_EVT_FLOGI_RCVD: {
568 		struct fc_frame_header *hdr = cbdata->header->dma.virt;
569 		u32 d_id = ntoh24(hdr->fh_d_id);
570 
571 		/* sm: / save sparams, send FLOGI acc */
572 		memcpy(node->nport->domain->flogi_service_params,
573 		       cbdata->payload->dma.virt,
574 		       sizeof(struct fc_els_flogi));
575 
576 		/* send FC LS_ACC response, override s_id */
577 		efc_fabric_set_topology(node, EFC_NPORT_TOPO_P2P);
578 
579 		efc_send_flogi_p2p_acc(node, be16_to_cpu(hdr->fh_ox_id), d_id);
580 
581 		if (efc_p2p_setup(node->nport)) {
582 			node_printf(node, "p2p failed, shutting down node\n");
583 			efc_node_post_event(node, EFC_EVT_SHUTDOWN, NULL);
584 			break;
585 		}
586 
587 		efc_node_transition(node,  __efc_p2p_wait_flogi_acc_cmpl, NULL);
588 		break;
589 	}
590 
591 	case EFC_EVT_LOGO_RCVD: {
592 		struct fc_frame_header *hdr = cbdata->header->dma.virt;
593 
594 		if (!node->nport->domain->attached) {
595 			/* most likely a frame left over from before a link
596 			 * down; drop and
597 			 * shut node down w/ "explicit logout" so pending
598 			 * frames are processed
599 			 */
600 			node_printf(node, "%s domain not attached, dropping\n",
601 				    efc_sm_event_name(evt));
602 			efc_node_post_event(node,
603 					EFC_EVT_SHUTDOWN_EXPLICIT_LOGO, NULL);
604 			break;
605 		}
606 
607 		efc_send_logo_acc(node, be16_to_cpu(hdr->fh_ox_id));
608 		efc_node_transition(node, __efc_d_wait_logo_acc_cmpl, NULL);
609 		break;
610 	}
611 
612 	case EFC_EVT_PRLI_RCVD:
613 	case EFC_EVT_PRLO_RCVD:
614 	case EFC_EVT_PDISC_RCVD:
615 	case EFC_EVT_ADISC_RCVD:
616 	case EFC_EVT_RSCN_RCVD: {
617 		struct fc_frame_header *hdr = cbdata->header->dma.virt;
618 
619 		if (!node->nport->domain->attached) {
620 			/* most likely a frame left over from before a link
621 			 * down; drop and shut node down w/ "explicit logout"
622 			 * so pending frames are processed
623 			 */
624 			node_printf(node, "%s domain not attached, dropping\n",
625 				    efc_sm_event_name(evt));
626 
627 			efc_node_post_event(node,
628 					    EFC_EVT_SHUTDOWN_EXPLICIT_LOGO,
629 					    NULL);
630 			break;
631 		}
632 		node_printf(node, "%s received, sending reject\n",
633 			    efc_sm_event_name(evt));
634 
635 		efc_send_ls_rjt(node, be16_to_cpu(hdr->fh_ox_id),
636 				ELS_RJT_UNAB, ELS_EXPL_PLOGI_REQD, 0);
637 
638 		break;
639 	}
640 
641 	case EFC_EVT_FCP_CMD_RCVD: {
642 		/* note: problem, we're now expecting an ELS REQ completion
643 		 * from both the LOGO and PLOGI
644 		 */
645 		if (!node->nport->domain->attached) {
646 			/* most likely a frame left over from before a
647 			 * link down; drop and
648 			 * shut node down w/ "explicit logout" so pending
649 			 * frames are processed
650 			 */
651 			node_printf(node, "%s domain not attached, dropping\n",
652 				    efc_sm_event_name(evt));
653 			efc_node_post_event(node,
654 					    EFC_EVT_SHUTDOWN_EXPLICIT_LOGO,
655 					    NULL);
656 			break;
657 		}
658 
659 		/* Send LOGO */
660 		node_printf(node, "FCP_CMND received, send LOGO\n");
661 		if (efc_send_logo(node)) {
662 			/*
663 			 * failed to send LOGO, go ahead and cleanup node
664 			 * anyways
665 			 */
666 			node_printf(node, "Failed to send LOGO\n");
667 			efc_node_post_event(node,
668 					    EFC_EVT_SHUTDOWN_EXPLICIT_LOGO,
669 					    NULL);
670 		} else {
671 			/* sent LOGO, wait for response */
672 			efc_node_transition(node,
673 					    __efc_d_wait_logo_rsp, NULL);
674 		}
675 		break;
676 	}
677 	case EFC_EVT_DOMAIN_ATTACH_OK:
678 		/* don't care about domain_attach_ok */
679 		break;
680 
681 	default:
682 		__efc_d_common(__func__, ctx, evt, arg);
683 	}
684 }
685 
686 void
687 __efc_d_wait_plogi_rsp(struct efc_sm_ctx *ctx,
688 		       enum efc_sm_event evt, void *arg)
689 {
690 	int rc;
691 	struct efc_node_cb *cbdata = arg;
692 	struct efc_node *node = ctx->app;
693 
694 	efc_node_evt_set(ctx, evt, __func__);
695 
696 	node_sm_trace();
697 
698 	switch (evt) {
699 	case EFC_EVT_PLOGI_RCVD: {
700 		/* T, or I+T */
701 		/* received PLOGI with svc parms, go ahead and attach node
702 		 * when PLOGI that was sent ultimately completes, it'll be a
703 		 * no-op
704 		 *
705 		 * If there is an outstanding PLOGI sent, can we set a flag
706 		 * to indicate that we don't want to retry it if it times out?
707 		 */
708 		efc_node_save_sparms(node, cbdata->payload->dma.virt);
709 		efc_send_ls_acc_after_attach(node,
710 					     cbdata->header->dma.virt,
711 				EFC_NODE_SEND_LS_ACC_PLOGI);
712 		/* sm: domain->attached / efc_node_attach */
713 		rc = efc_node_attach(node);
714 		efc_node_transition(node, __efc_d_wait_node_attach, NULL);
715 		if (rc < 0)
716 			efc_node_post_event(node,
717 					    EFC_EVT_NODE_ATTACH_FAIL, NULL);
718 
719 		break;
720 	}
721 
722 	case EFC_EVT_PRLI_RCVD:
723 		/* I, or I+T */
724 		/* sent PLOGI and before completion was seen, received the
725 		 * PRLI from the remote node (WCQEs and RCQEs come in on
726 		 * different queues and order of processing cannot be assumed)
727 		 * Save OXID so PRLI can be sent after the attach and continue
728 		 * to wait for PLOGI response
729 		 */
730 		efc_process_prli_payload(node, cbdata->payload->dma.virt);
731 		efc_send_ls_acc_after_attach(node,
732 					     cbdata->header->dma.virt,
733 				EFC_NODE_SEND_LS_ACC_PRLI);
734 		efc_node_transition(node, __efc_d_wait_plogi_rsp_recvd_prli,
735 				    NULL);
736 		break;
737 
738 	case EFC_EVT_LOGO_RCVD: /* why don't we do a shutdown here?? */
739 	case EFC_EVT_PRLO_RCVD:
740 	case EFC_EVT_PDISC_RCVD:
741 	case EFC_EVT_FDISC_RCVD:
742 	case EFC_EVT_ADISC_RCVD:
743 	case EFC_EVT_RSCN_RCVD:
744 	case EFC_EVT_SCR_RCVD: {
745 		struct fc_frame_header *hdr = cbdata->header->dma.virt;
746 
747 		node_printf(node, "%s received, sending reject\n",
748 			    efc_sm_event_name(evt));
749 
750 		efc_send_ls_rjt(node, be16_to_cpu(hdr->fh_ox_id),
751 				ELS_RJT_UNAB, ELS_EXPL_PLOGI_REQD, 0);
752 
753 		break;
754 	}
755 
756 	case EFC_EVT_SRRS_ELS_REQ_OK:	/* PLOGI response received */
757 		/* Completion from PLOGI sent */
758 		if (efc_node_check_els_req(ctx, evt, arg, ELS_PLOGI,
759 					   __efc_d_common, __func__))
760 			return;
761 
762 		WARN_ON(!node->els_req_cnt);
763 		node->els_req_cnt--;
764 		/* sm: / save sparams, efc_node_attach */
765 		efc_node_save_sparms(node, cbdata->els_rsp.virt);
766 		rc = efc_node_attach(node);
767 		efc_node_transition(node, __efc_d_wait_node_attach, NULL);
768 		if (rc < 0)
769 			efc_node_post_event(node,
770 					    EFC_EVT_NODE_ATTACH_FAIL, NULL);
771 
772 		break;
773 
774 	case EFC_EVT_SRRS_ELS_REQ_FAIL:	/* PLOGI response received */
775 		/* PLOGI failed, shutdown the node */
776 		if (efc_node_check_els_req(ctx, evt, arg, ELS_PLOGI,
777 					   __efc_d_common, __func__))
778 			return;
779 
780 		WARN_ON(!node->els_req_cnt);
781 		node->els_req_cnt--;
782 		efc_node_post_event(node, EFC_EVT_SHUTDOWN, NULL);
783 		break;
784 
785 	case EFC_EVT_SRRS_ELS_REQ_RJT:
786 		/* Our PLOGI was rejected, this is ok in some cases */
787 		if (efc_node_check_els_req(ctx, evt, arg, ELS_PLOGI,
788 					   __efc_d_common, __func__))
789 			return;
790 
791 		WARN_ON(!node->els_req_cnt);
792 		node->els_req_cnt--;
793 		break;
794 
795 	case EFC_EVT_FCP_CMD_RCVD: {
796 		/* not logged in yet and outstanding PLOGI so don't send LOGO,
797 		 * just drop
798 		 */
799 		node_printf(node, "FCP_CMND received, drop\n");
800 		break;
801 	}
802 
803 	default:
804 		__efc_d_common(__func__, ctx, evt, arg);
805 	}
806 }
807 
808 void
809 __efc_d_wait_plogi_rsp_recvd_prli(struct efc_sm_ctx *ctx,
810 				  enum efc_sm_event evt, void *arg)
811 {
812 	int rc;
813 	struct efc_node_cb *cbdata = arg;
814 	struct efc_node *node = ctx->app;
815 
816 	efc_node_evt_set(ctx, evt, __func__);
817 
818 	node_sm_trace();
819 
820 	switch (evt) {
821 	case EFC_EVT_ENTER:
822 		/*
823 		 * Since we've received a PRLI, we have a port login and will
824 		 * just need to wait for the PLOGI response to do the node
825 		 * attach and then we can send the LS_ACC for the PRLI. If,
826 		 * during this time, we receive FCP_CMNDs (which is possible
827 		 * since we've already sent a PRLI and our peer may have
828 		 * accepted). At this time, we are not waiting on any other
829 		 * unsolicited frames to continue with the login process. Thus,
830 		 * it will not hurt to hold frames here.
831 		 */
832 		efc_node_hold_frames(node);
833 		break;
834 
835 	case EFC_EVT_EXIT:
836 		efc_node_accept_frames(node);
837 		break;
838 
839 	case EFC_EVT_SRRS_ELS_REQ_OK:	/* PLOGI response received */
840 		/* Completion from PLOGI sent */
841 		if (efc_node_check_els_req(ctx, evt, arg, ELS_PLOGI,
842 					   __efc_d_common, __func__))
843 			return;
844 
845 		WARN_ON(!node->els_req_cnt);
846 		node->els_req_cnt--;
847 		/* sm: / save sparams, efc_node_attach */
848 		efc_node_save_sparms(node, cbdata->els_rsp.virt);
849 		rc = efc_node_attach(node);
850 		efc_node_transition(node, __efc_d_wait_node_attach, NULL);
851 		if (rc < 0)
852 			efc_node_post_event(node, EFC_EVT_NODE_ATTACH_FAIL,
853 					    NULL);
854 
855 		break;
856 
857 	case EFC_EVT_SRRS_ELS_REQ_FAIL:	/* PLOGI response received */
858 	case EFC_EVT_SRRS_ELS_REQ_RJT:
859 		/* PLOGI failed, shutdown the node */
860 		if (efc_node_check_els_req(ctx, evt, arg, ELS_PLOGI,
861 					   __efc_d_common, __func__))
862 			return;
863 
864 		WARN_ON(!node->els_req_cnt);
865 		node->els_req_cnt--;
866 		efc_node_post_event(node, EFC_EVT_SHUTDOWN, NULL);
867 		break;
868 
869 	default:
870 		__efc_d_common(__func__, ctx, evt, arg);
871 	}
872 }
873 
874 void
875 __efc_d_wait_domain_attach(struct efc_sm_ctx *ctx,
876 			   enum efc_sm_event evt, void *arg)
877 {
878 	int rc;
879 	struct efc_node *node = ctx->app;
880 
881 	efc_node_evt_set(ctx, evt, __func__);
882 
883 	node_sm_trace();
884 
885 	switch (evt) {
886 	case EFC_EVT_ENTER:
887 		efc_node_hold_frames(node);
888 		break;
889 
890 	case EFC_EVT_EXIT:
891 		efc_node_accept_frames(node);
892 		break;
893 
894 	case EFC_EVT_DOMAIN_ATTACH_OK:
895 		WARN_ON(!node->nport->domain->attached);
896 		/* sm: / efc_node_attach */
897 		rc = efc_node_attach(node);
898 		efc_node_transition(node, __efc_d_wait_node_attach, NULL);
899 		if (rc < 0)
900 			efc_node_post_event(node, EFC_EVT_NODE_ATTACH_FAIL,
901 					    NULL);
902 
903 		break;
904 
905 	default:
906 		__efc_d_common(__func__, ctx, evt, arg);
907 	}
908 }
909 
910 void
911 __efc_d_wait_topology_notify(struct efc_sm_ctx *ctx,
912 			     enum efc_sm_event evt, void *arg)
913 {
914 	int rc;
915 	struct efc_node *node = ctx->app;
916 
917 	efc_node_evt_set(ctx, evt, __func__);
918 
919 	node_sm_trace();
920 
921 	switch (evt) {
922 	case EFC_EVT_ENTER:
923 		efc_node_hold_frames(node);
924 		break;
925 
926 	case EFC_EVT_EXIT:
927 		efc_node_accept_frames(node);
928 		break;
929 
930 	case EFC_EVT_NPORT_TOPOLOGY_NOTIFY: {
931 		enum efc_nport_topology *topology = arg;
932 
933 		WARN_ON(node->nport->domain->attached);
934 
935 		WARN_ON(node->send_ls_acc != EFC_NODE_SEND_LS_ACC_PLOGI);
936 
937 		node_printf(node, "topology notification, topology=%d\n",
938 			    *topology);
939 
940 		/* At the time the PLOGI was received, the topology was unknown,
941 		 * so we didn't know which node would perform the domain attach:
942 		 * 1. The node from which the PLOGI was sent (p2p) or
943 		 * 2. The node to which the FLOGI was sent (fabric).
944 		 */
945 		if (*topology == EFC_NPORT_TOPO_P2P) {
946 			/* if this is p2p, need to attach to the domain using
947 			 * the d_id from the PLOGI received
948 			 */
949 			efc_domain_attach(node->nport->domain,
950 					  node->ls_acc_did);
951 		}
952 		/* else, if this is fabric, the domain attach
953 		 * should be performed by the fabric node (node sending FLOGI);
954 		 * just wait for attach to complete
955 		 */
956 
957 		efc_node_transition(node, __efc_d_wait_domain_attach, NULL);
958 		break;
959 	}
960 	case EFC_EVT_DOMAIN_ATTACH_OK:
961 		WARN_ON(!node->nport->domain->attached);
962 		node_printf(node, "domain attach ok\n");
963 		/* sm: / efc_node_attach */
964 		rc = efc_node_attach(node);
965 		efc_node_transition(node, __efc_d_wait_node_attach, NULL);
966 		if (rc < 0)
967 			efc_node_post_event(node,
968 					    EFC_EVT_NODE_ATTACH_FAIL, NULL);
969 
970 		break;
971 
972 	default:
973 		__efc_d_common(__func__, ctx, evt, arg);
974 	}
975 }
976 
977 void
978 __efc_d_wait_node_attach(struct efc_sm_ctx *ctx,
979 			 enum efc_sm_event evt, void *arg)
980 {
981 	struct efc_node *node = ctx->app;
982 
983 	efc_node_evt_set(ctx, evt, __func__);
984 
985 	node_sm_trace();
986 
987 	switch (evt) {
988 	case EFC_EVT_ENTER:
989 		efc_node_hold_frames(node);
990 		break;
991 
992 	case EFC_EVT_EXIT:
993 		efc_node_accept_frames(node);
994 		break;
995 
996 	case EFC_EVT_NODE_ATTACH_OK:
997 		node->attached = true;
998 		switch (node->send_ls_acc) {
999 		case EFC_NODE_SEND_LS_ACC_PLOGI: {
1000 			/* sm: send_plogi_acc is set / send PLOGI acc */
1001 			/* Normal case for T, or I+T */
1002 			efc_send_plogi_acc(node, node->ls_acc_oxid);
1003 			efc_node_transition(node, __efc_d_wait_plogi_acc_cmpl,
1004 					    NULL);
1005 			node->send_ls_acc = EFC_NODE_SEND_LS_ACC_NONE;
1006 			node->ls_acc_io = NULL;
1007 			break;
1008 		}
1009 		case EFC_NODE_SEND_LS_ACC_PRLI: {
1010 			efc_d_send_prli_rsp(node, node->ls_acc_oxid);
1011 			node->send_ls_acc = EFC_NODE_SEND_LS_ACC_NONE;
1012 			node->ls_acc_io = NULL;
1013 			break;
1014 		}
1015 		case EFC_NODE_SEND_LS_ACC_NONE:
1016 		default:
1017 			/* Normal case for I */
1018 			/* sm: send_plogi_acc is not set / send PLOGI acc */
1019 			efc_node_transition(node,
1020 					    __efc_d_port_logged_in, NULL);
1021 			break;
1022 		}
1023 		break;
1024 
1025 	case EFC_EVT_NODE_ATTACH_FAIL:
1026 		/* node attach failed, shutdown the node */
1027 		node->attached = false;
1028 		node_printf(node, "node attach failed\n");
1029 		node->shutdown_reason = EFC_NODE_SHUTDOWN_DEFAULT;
1030 		efc_node_transition(node, __efc_d_initiate_shutdown, NULL);
1031 		break;
1032 
1033 	/* Handle shutdown events */
1034 	case EFC_EVT_SHUTDOWN:
1035 		node_printf(node, "%s received\n", efc_sm_event_name(evt));
1036 		node->shutdown_reason = EFC_NODE_SHUTDOWN_DEFAULT;
1037 		efc_node_transition(node, __efc_d_wait_attach_evt_shutdown,
1038 				    NULL);
1039 		break;
1040 	case EFC_EVT_SHUTDOWN_EXPLICIT_LOGO:
1041 		node_printf(node, "%s received\n", efc_sm_event_name(evt));
1042 		node->shutdown_reason = EFC_NODE_SHUTDOWN_EXPLICIT_LOGO;
1043 		efc_node_transition(node, __efc_d_wait_attach_evt_shutdown,
1044 				    NULL);
1045 		break;
1046 	case EFC_EVT_SHUTDOWN_IMPLICIT_LOGO:
1047 		node_printf(node, "%s received\n", efc_sm_event_name(evt));
1048 		node->shutdown_reason = EFC_NODE_SHUTDOWN_IMPLICIT_LOGO;
1049 		efc_node_transition(node,
1050 				    __efc_d_wait_attach_evt_shutdown, NULL);
1051 		break;
1052 	default:
1053 		__efc_d_common(__func__, ctx, evt, arg);
1054 	}
1055 }
1056 
1057 void
1058 __efc_d_wait_attach_evt_shutdown(struct efc_sm_ctx *ctx,
1059 				 enum efc_sm_event evt, void *arg)
1060 {
1061 	struct efc_node *node = ctx->app;
1062 
1063 	efc_node_evt_set(ctx, evt, __func__);
1064 
1065 	node_sm_trace();
1066 
1067 	switch (evt) {
1068 	case EFC_EVT_ENTER:
1069 		efc_node_hold_frames(node);
1070 		break;
1071 
1072 	case EFC_EVT_EXIT:
1073 		efc_node_accept_frames(node);
1074 		break;
1075 
1076 	/* wait for any of these attach events and then shutdown */
1077 	case EFC_EVT_NODE_ATTACH_OK:
1078 		node->attached = true;
1079 		node_printf(node, "Attach evt=%s, proceed to shutdown\n",
1080 			    efc_sm_event_name(evt));
1081 		efc_node_transition(node, __efc_d_initiate_shutdown, NULL);
1082 		break;
1083 
1084 	case EFC_EVT_NODE_ATTACH_FAIL:
1085 		/* node attach failed, shutdown the node */
1086 		node->attached = false;
1087 		node_printf(node, "Attach evt=%s, proceed to shutdown\n",
1088 			    efc_sm_event_name(evt));
1089 		efc_node_transition(node, __efc_d_initiate_shutdown, NULL);
1090 		break;
1091 
1092 	/* ignore shutdown events as we're already in shutdown path */
1093 	case EFC_EVT_SHUTDOWN:
1094 		/* have default shutdown event take precedence */
1095 		node->shutdown_reason = EFC_NODE_SHUTDOWN_DEFAULT;
1096 		fallthrough;
1097 
1098 	case EFC_EVT_SHUTDOWN_EXPLICIT_LOGO:
1099 	case EFC_EVT_SHUTDOWN_IMPLICIT_LOGO:
1100 		node_printf(node, "%s received\n", efc_sm_event_name(evt));
1101 		break;
1102 
1103 	default:
1104 		__efc_d_common(__func__, ctx, evt, arg);
1105 	}
1106 }
1107 
1108 void
1109 __efc_d_port_logged_in(struct efc_sm_ctx *ctx,
1110 		       enum efc_sm_event evt, void *arg)
1111 {
1112 	struct efc_node_cb *cbdata = arg;
1113 	struct efc_node *node = ctx->app;
1114 
1115 	efc_node_evt_set(ctx, evt, __func__);
1116 
1117 	node_sm_trace();
1118 
1119 	switch (evt) {
1120 	case EFC_EVT_ENTER:
1121 		/* Normal case for I or I+T */
1122 		if (node->nport->enable_ini &&
1123 		    !(node->rnode.fc_id != FC_FID_DOM_MGR)) {
1124 			/* sm: if enable_ini / send PRLI */
1125 			efc_send_prli(node);
1126 			/* can now expect ELS_REQ_OK/FAIL/RJT */
1127 		}
1128 		break;
1129 
1130 	case EFC_EVT_FCP_CMD_RCVD: {
1131 		break;
1132 	}
1133 
1134 	case EFC_EVT_PRLI_RCVD: {
1135 		/* Normal case for T or I+T */
1136 		struct fc_frame_header *hdr = cbdata->header->dma.virt;
1137 		struct {
1138 			struct fc_els_prli prli;
1139 			struct fc_els_spp sp;
1140 		} *pp;
1141 
1142 		pp = cbdata->payload->dma.virt;
1143 		if (pp->sp.spp_type != FC_TYPE_FCP) {
1144 			/*Only FCP is supported*/
1145 			efc_send_ls_rjt(node, be16_to_cpu(hdr->fh_ox_id),
1146 					ELS_RJT_UNAB, ELS_EXPL_UNSUPR, 0);
1147 			break;
1148 		}
1149 
1150 		efc_process_prli_payload(node, cbdata->payload->dma.virt);
1151 		efc_d_send_prli_rsp(node, be16_to_cpu(hdr->fh_ox_id));
1152 		break;
1153 	}
1154 
1155 	case EFC_EVT_NODE_SESS_REG_OK:
1156 		if (node->send_ls_acc == EFC_NODE_SEND_LS_ACC_PRLI)
1157 			efc_send_prli_acc(node, node->ls_acc_oxid);
1158 
1159 		node->send_ls_acc = EFC_NODE_SEND_LS_ACC_NONE;
1160 		efc_node_transition(node, __efc_d_device_ready, NULL);
1161 		break;
1162 
1163 	case EFC_EVT_NODE_SESS_REG_FAIL:
1164 		efc_send_ls_rjt(node, node->ls_acc_oxid, ELS_RJT_UNAB,
1165 				ELS_EXPL_UNSUPR, 0);
1166 		node->send_ls_acc = EFC_NODE_SEND_LS_ACC_NONE;
1167 		break;
1168 
1169 	case EFC_EVT_SRRS_ELS_REQ_OK: {	/* PRLI response */
1170 		/* Normal case for I or I+T */
1171 		if (efc_node_check_els_req(ctx, evt, arg, ELS_PRLI,
1172 					   __efc_d_common, __func__))
1173 			return;
1174 
1175 		WARN_ON(!node->els_req_cnt);
1176 		node->els_req_cnt--;
1177 		/* sm: / process PRLI payload */
1178 		efc_process_prli_payload(node, cbdata->els_rsp.virt);
1179 		efc_node_transition(node, __efc_d_device_ready, NULL);
1180 		break;
1181 	}
1182 
1183 	case EFC_EVT_SRRS_ELS_REQ_FAIL: {	/* PRLI response failed */
1184 		/* I, I+T, assume some link failure, shutdown node */
1185 		if (efc_node_check_els_req(ctx, evt, arg, ELS_PRLI,
1186 					   __efc_d_common, __func__))
1187 			return;
1188 
1189 		WARN_ON(!node->els_req_cnt);
1190 		node->els_req_cnt--;
1191 		efc_node_post_event(node, EFC_EVT_SHUTDOWN, NULL);
1192 		break;
1193 	}
1194 
1195 	case EFC_EVT_SRRS_ELS_REQ_RJT: {
1196 		/* PRLI rejected by remote
1197 		 * Normal for I, I+T (connected to an I)
1198 		 * Node doesn't want to be a target, stay here and wait for a
1199 		 * PRLI from the remote node
1200 		 * if it really wants to connect to us as target
1201 		 */
1202 		if (efc_node_check_els_req(ctx, evt, arg, ELS_PRLI,
1203 					   __efc_d_common, __func__))
1204 			return;
1205 
1206 		WARN_ON(!node->els_req_cnt);
1207 		node->els_req_cnt--;
1208 		break;
1209 	}
1210 
1211 	case EFC_EVT_SRRS_ELS_CMPL_OK: {
1212 		/* Normal T, I+T, target-server rejected the process login */
1213 		/* This would be received only in the case where we sent
1214 		 * LS_RJT for the PRLI, so
1215 		 * do nothing.   (note: as T only we could shutdown the node)
1216 		 */
1217 		WARN_ON(!node->els_cmpl_cnt);
1218 		node->els_cmpl_cnt--;
1219 		break;
1220 	}
1221 
1222 	case EFC_EVT_PLOGI_RCVD: {
1223 		/*sm: / save sparams, set send_plogi_acc,
1224 		 *post implicit logout
1225 		 * Save plogi parameters
1226 		 */
1227 		efc_node_save_sparms(node, cbdata->payload->dma.virt);
1228 		efc_send_ls_acc_after_attach(node,
1229 					     cbdata->header->dma.virt,
1230 				EFC_NODE_SEND_LS_ACC_PLOGI);
1231 
1232 		/* Restart node attach with new service parameters,
1233 		 * and send ACC
1234 		 */
1235 		efc_node_post_event(node, EFC_EVT_SHUTDOWN_IMPLICIT_LOGO,
1236 				    NULL);
1237 		break;
1238 	}
1239 
1240 	case EFC_EVT_LOGO_RCVD: {
1241 		/* I, T, I+T */
1242 		struct fc_frame_header *hdr = cbdata->header->dma.virt;
1243 
1244 		node_printf(node, "%s received attached=%d\n",
1245 			    efc_sm_event_name(evt),
1246 					node->attached);
1247 		/* sm: / send LOGO acc */
1248 		efc_send_logo_acc(node, be16_to_cpu(hdr->fh_ox_id));
1249 		efc_node_transition(node, __efc_d_wait_logo_acc_cmpl, NULL);
1250 		break;
1251 	}
1252 
1253 	default:
1254 		__efc_d_common(__func__, ctx, evt, arg);
1255 	}
1256 }
1257 
1258 void
1259 __efc_d_wait_logo_acc_cmpl(struct efc_sm_ctx *ctx,
1260 			   enum efc_sm_event evt, void *arg)
1261 {
1262 	struct efc_node *node = ctx->app;
1263 
1264 	efc_node_evt_set(ctx, evt, __func__);
1265 
1266 	node_sm_trace();
1267 
1268 	switch (evt) {
1269 	case EFC_EVT_ENTER:
1270 		efc_node_hold_frames(node);
1271 		break;
1272 
1273 	case EFC_EVT_EXIT:
1274 		efc_node_accept_frames(node);
1275 		break;
1276 
1277 	case EFC_EVT_SRRS_ELS_CMPL_OK:
1278 	case EFC_EVT_SRRS_ELS_CMPL_FAIL:
1279 		/* sm: / post explicit logout */
1280 		WARN_ON(!node->els_cmpl_cnt);
1281 		node->els_cmpl_cnt--;
1282 		efc_node_post_event(node,
1283 				    EFC_EVT_SHUTDOWN_EXPLICIT_LOGO, NULL);
1284 		break;
1285 	default:
1286 		__efc_d_common(__func__, ctx, evt, arg);
1287 	}
1288 }
1289 
1290 void
1291 __efc_d_device_ready(struct efc_sm_ctx *ctx,
1292 		     enum efc_sm_event evt, void *arg)
1293 {
1294 	struct efc_node_cb *cbdata = arg;
1295 	struct efc_node *node = ctx->app;
1296 	struct efc *efc = node->efc;
1297 
1298 	efc_node_evt_set(ctx, evt, __func__);
1299 
1300 	if (evt != EFC_EVT_FCP_CMD_RCVD)
1301 		node_sm_trace();
1302 
1303 	switch (evt) {
1304 	case EFC_EVT_ENTER:
1305 		node->fcp_enabled = true;
1306 		if (node->targ) {
1307 			efc_log_info(efc,
1308 				     "[%s] found (target) WWPN %s WWNN %s\n",
1309 				node->display_name,
1310 				node->wwpn, node->wwnn);
1311 			if (node->nport->enable_ini)
1312 				efc->tt.scsi_new_node(efc, node);
1313 		}
1314 		break;
1315 
1316 	case EFC_EVT_EXIT:
1317 		node->fcp_enabled = false;
1318 		break;
1319 
1320 	case EFC_EVT_PLOGI_RCVD: {
1321 		/* sm: / save sparams, set send_plogi_acc, post implicit
1322 		 * logout
1323 		 * Save plogi parameters
1324 		 */
1325 		efc_node_save_sparms(node, cbdata->payload->dma.virt);
1326 		efc_send_ls_acc_after_attach(node,
1327 					     cbdata->header->dma.virt,
1328 				EFC_NODE_SEND_LS_ACC_PLOGI);
1329 
1330 		/*
1331 		 * Restart node attach with new service parameters,
1332 		 * and send ACC
1333 		 */
1334 		efc_node_post_event(node,
1335 				    EFC_EVT_SHUTDOWN_IMPLICIT_LOGO, NULL);
1336 		break;
1337 	}
1338 
1339 	case EFC_EVT_PRLI_RCVD: {
1340 		/* T, I+T: remote initiator is slow to get started */
1341 		struct fc_frame_header *hdr = cbdata->header->dma.virt;
1342 		struct {
1343 			struct fc_els_prli prli;
1344 			struct fc_els_spp sp;
1345 		} *pp;
1346 
1347 		pp = cbdata->payload->dma.virt;
1348 		if (pp->sp.spp_type != FC_TYPE_FCP) {
1349 			/*Only FCP is supported*/
1350 			efc_send_ls_rjt(node, be16_to_cpu(hdr->fh_ox_id),
1351 					ELS_RJT_UNAB, ELS_EXPL_UNSUPR, 0);
1352 			break;
1353 		}
1354 
1355 		efc_process_prli_payload(node, cbdata->payload->dma.virt);
1356 		efc_send_prli_acc(node, be16_to_cpu(hdr->fh_ox_id));
1357 		break;
1358 	}
1359 
1360 	case EFC_EVT_PRLO_RCVD: {
1361 		struct fc_frame_header *hdr = cbdata->header->dma.virt;
1362 		/* sm: / send PRLO acc */
1363 		efc_send_prlo_acc(node, be16_to_cpu(hdr->fh_ox_id));
1364 		/* need implicit logout? */
1365 		break;
1366 	}
1367 
1368 	case EFC_EVT_LOGO_RCVD: {
1369 		struct fc_frame_header *hdr = cbdata->header->dma.virt;
1370 
1371 		node_printf(node, "%s received attached=%d\n",
1372 			    efc_sm_event_name(evt), node->attached);
1373 		/* sm: / send LOGO acc */
1374 		efc_send_logo_acc(node, be16_to_cpu(hdr->fh_ox_id));
1375 		efc_node_transition(node, __efc_d_wait_logo_acc_cmpl, NULL);
1376 		break;
1377 	}
1378 
1379 	case EFC_EVT_ADISC_RCVD: {
1380 		struct fc_frame_header *hdr = cbdata->header->dma.virt;
1381 		/* sm: / send ADISC acc */
1382 		efc_send_adisc_acc(node, be16_to_cpu(hdr->fh_ox_id));
1383 		break;
1384 	}
1385 
1386 	case EFC_EVT_ABTS_RCVD:
1387 		/* sm: / process ABTS */
1388 		efc_log_err(efc, "Unexpected event:%s\n",
1389 			    efc_sm_event_name(evt));
1390 		break;
1391 
1392 	case EFC_EVT_NODE_ACTIVE_IO_LIST_EMPTY:
1393 		break;
1394 
1395 	case EFC_EVT_NODE_REFOUND:
1396 		break;
1397 
1398 	case EFC_EVT_NODE_MISSING:
1399 		if (node->nport->enable_rscn)
1400 			efc_node_transition(node, __efc_d_device_gone, NULL);
1401 
1402 		break;
1403 
1404 	case EFC_EVT_SRRS_ELS_CMPL_OK:
1405 		/* T, or I+T, PRLI accept completed ok */
1406 		WARN_ON(!node->els_cmpl_cnt);
1407 		node->els_cmpl_cnt--;
1408 		break;
1409 
1410 	case EFC_EVT_SRRS_ELS_CMPL_FAIL:
1411 		/* T, or I+T, PRLI accept failed to complete */
1412 		WARN_ON(!node->els_cmpl_cnt);
1413 		node->els_cmpl_cnt--;
1414 		node_printf(node, "Failed to send PRLI LS_ACC\n");
1415 		break;
1416 
1417 	default:
1418 		__efc_d_common(__func__, ctx, evt, arg);
1419 	}
1420 }
1421 
1422 void
1423 __efc_d_device_gone(struct efc_sm_ctx *ctx,
1424 		    enum efc_sm_event evt, void *arg)
1425 {
1426 	struct efc_node_cb *cbdata = arg;
1427 	struct efc_node *node = ctx->app;
1428 	struct efc *efc = node->efc;
1429 
1430 	efc_node_evt_set(ctx, evt, __func__);
1431 
1432 	node_sm_trace();
1433 
1434 	switch (evt) {
1435 	case EFC_EVT_ENTER: {
1436 		int rc = EFC_SCSI_CALL_COMPLETE;
1437 		int rc_2 = EFC_SCSI_CALL_COMPLETE;
1438 		static const char * const labels[] = {
1439 			"none", "initiator", "target", "initiator+target"
1440 		};
1441 
1442 		efc_log_info(efc, "[%s] missing (%s)    WWPN %s WWNN %s\n",
1443 			     node->display_name,
1444 				labels[(node->targ << 1) | (node->init)],
1445 						node->wwpn, node->wwnn);
1446 
1447 		switch (efc_node_get_enable(node)) {
1448 		case EFC_NODE_ENABLE_T_TO_T:
1449 		case EFC_NODE_ENABLE_I_TO_T:
1450 		case EFC_NODE_ENABLE_IT_TO_T:
1451 			rc = efc->tt.scsi_del_node(efc, node,
1452 				EFC_SCSI_TARGET_MISSING);
1453 			break;
1454 
1455 		case EFC_NODE_ENABLE_T_TO_I:
1456 		case EFC_NODE_ENABLE_I_TO_I:
1457 		case EFC_NODE_ENABLE_IT_TO_I:
1458 			rc = efc->tt.scsi_del_node(efc, node,
1459 				EFC_SCSI_INITIATOR_MISSING);
1460 			break;
1461 
1462 		case EFC_NODE_ENABLE_T_TO_IT:
1463 			rc = efc->tt.scsi_del_node(efc, node,
1464 				EFC_SCSI_INITIATOR_MISSING);
1465 			break;
1466 
1467 		case EFC_NODE_ENABLE_I_TO_IT:
1468 			rc = efc->tt.scsi_del_node(efc, node,
1469 						  EFC_SCSI_TARGET_MISSING);
1470 			break;
1471 
1472 		case EFC_NODE_ENABLE_IT_TO_IT:
1473 			rc = efc->tt.scsi_del_node(efc, node,
1474 				EFC_SCSI_INITIATOR_MISSING);
1475 			rc_2 = efc->tt.scsi_del_node(efc, node,
1476 				EFC_SCSI_TARGET_MISSING);
1477 			break;
1478 
1479 		default:
1480 			rc = EFC_SCSI_CALL_COMPLETE;
1481 			break;
1482 		}
1483 
1484 		if (rc == EFC_SCSI_CALL_COMPLETE &&
1485 		    rc_2 == EFC_SCSI_CALL_COMPLETE)
1486 			efc_node_post_event(node, EFC_EVT_SHUTDOWN, NULL);
1487 
1488 		break;
1489 	}
1490 	case EFC_EVT_NODE_REFOUND:
1491 		/* two approaches, reauthenticate with PLOGI/PRLI, or ADISC */
1492 
1493 		/* reauthenticate with PLOGI/PRLI */
1494 		/* efc_node_transition(node, __efc_d_discovered, NULL); */
1495 
1496 		/* reauthenticate with ADISC */
1497 		/* sm: / send ADISC */
1498 		efc_send_adisc(node);
1499 		efc_node_transition(node, __efc_d_wait_adisc_rsp, NULL);
1500 		break;
1501 
1502 	case EFC_EVT_PLOGI_RCVD: {
1503 		/* sm: / save sparams, set send_plogi_acc, post implicit
1504 		 * logout
1505 		 * Save plogi parameters
1506 		 */
1507 		efc_node_save_sparms(node, cbdata->payload->dma.virt);
1508 		efc_send_ls_acc_after_attach(node,
1509 					     cbdata->header->dma.virt,
1510 				EFC_NODE_SEND_LS_ACC_PLOGI);
1511 
1512 		/*
1513 		 * Restart node attach with new service parameters, and send
1514 		 * ACC
1515 		 */
1516 		efc_node_post_event(node, EFC_EVT_SHUTDOWN_IMPLICIT_LOGO,
1517 				    NULL);
1518 		break;
1519 	}
1520 
1521 	case EFC_EVT_FCP_CMD_RCVD: {
1522 		/* most likely a stale frame (received prior to link down),
1523 		 * if attempt to send LOGO, will probably timeout and eat
1524 		 * up 20s; thus, drop FCP_CMND
1525 		 */
1526 		node_printf(node, "FCP_CMND received, drop\n");
1527 		break;
1528 	}
1529 	case EFC_EVT_LOGO_RCVD: {
1530 		/* I, T, I+T */
1531 		struct fc_frame_header *hdr = cbdata->header->dma.virt;
1532 
1533 		node_printf(node, "%s received attached=%d\n",
1534 			    efc_sm_event_name(evt), node->attached);
1535 		/* sm: / send LOGO acc */
1536 		efc_send_logo_acc(node, be16_to_cpu(hdr->fh_ox_id));
1537 		efc_node_transition(node, __efc_d_wait_logo_acc_cmpl, NULL);
1538 		break;
1539 	}
1540 	default:
1541 		__efc_d_common(__func__, ctx, evt, arg);
1542 	}
1543 }
1544 
1545 void
1546 __efc_d_wait_adisc_rsp(struct efc_sm_ctx *ctx,
1547 		       enum efc_sm_event evt, void *arg)
1548 {
1549 	struct efc_node_cb *cbdata = arg;
1550 	struct efc_node *node = ctx->app;
1551 
1552 	efc_node_evt_set(ctx, evt, __func__);
1553 
1554 	node_sm_trace();
1555 
1556 	switch (evt) {
1557 	case EFC_EVT_SRRS_ELS_REQ_OK:
1558 		if (efc_node_check_els_req(ctx, evt, arg, ELS_ADISC,
1559 					   __efc_d_common, __func__))
1560 			return;
1561 
1562 		WARN_ON(!node->els_req_cnt);
1563 		node->els_req_cnt--;
1564 		efc_node_transition(node, __efc_d_device_ready, NULL);
1565 		break;
1566 
1567 	case EFC_EVT_SRRS_ELS_REQ_RJT:
1568 		/* received an LS_RJT, in this case, send shutdown
1569 		 * (explicit logo) event which will unregister the node,
1570 		 * and start over with PLOGI
1571 		 */
1572 		if (efc_node_check_els_req(ctx, evt, arg, ELS_ADISC,
1573 					   __efc_d_common, __func__))
1574 			return;
1575 
1576 		WARN_ON(!node->els_req_cnt);
1577 		node->els_req_cnt--;
1578 		/* sm: / post explicit logout */
1579 		efc_node_post_event(node,
1580 				    EFC_EVT_SHUTDOWN_EXPLICIT_LOGO,
1581 				     NULL);
1582 		break;
1583 
1584 	case EFC_EVT_LOGO_RCVD: {
1585 		/* In this case, we have the equivalent of an LS_RJT for
1586 		 * the ADISC, so we need to abort the ADISC, and re-login
1587 		 * with PLOGI
1588 		 */
1589 		/* sm: / request abort, send LOGO acc */
1590 		struct fc_frame_header *hdr = cbdata->header->dma.virt;
1591 
1592 		node_printf(node, "%s received attached=%d\n",
1593 			    efc_sm_event_name(evt), node->attached);
1594 
1595 		efc_send_logo_acc(node, be16_to_cpu(hdr->fh_ox_id));
1596 		efc_node_transition(node, __efc_d_wait_logo_acc_cmpl, NULL);
1597 		break;
1598 	}
1599 	default:
1600 		__efc_d_common(__func__, ctx, evt, arg);
1601 	}
1602 }
1603