efc_node.c

   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#include "efc.h"
   8
   9int
  10efc_remote_node_cb(void *arg, int event, void *data)
  11{
  12	struct efc *efc = arg;
  13	struct efc_remote_node *rnode = data;
  14	struct efc_node *node = rnode->node;
  15	unsigned long flags = 0;
  16
  17	spin_lock_irqsave(&efc->lock, flags);
  18	efc_node_post_event(node, event, NULL);
  19	spin_unlock_irqrestore(&efc->lock, flags);
  20
  21	return 0;
  22}
  23
  24struct efc_node *
  25efc_node_find(struct efc_nport *nport, u32 port_id)
  26{
  27	/* Find an FC node structure given the FC port ID */
  28	return xa_load(&nport->lookup, port_id);
  29}
  30
  31static void
  32_efc_node_free(struct kref *arg)
  33{
  34	struct efc_node *node = container_of(arg, struct efc_node, ref);
  35	struct efc *efc = node->efc;
  36	struct efc_dma *dma;
  37
  38	dma = &node->sparm_dma_buf;
  39	dma_pool_free(efc->node_dma_pool, dma->virt, dma->phys);
  40	memset(dma, 0, sizeof(struct efc_dma));
  41	mempool_free(node, efc->node_pool);
  42}
  43
  44struct efc_node *efc_node_alloc(struct efc_nport *nport,
  45				u32 port_id, bool init, bool targ)
  46{
  47	int rc;
  48	struct efc_node *node = NULL;
  49	struct efc *efc = nport->efc;
  50	struct efc_dma *dma;
  51
  52	if (nport->shutting_down) {
  53		efc_log_debug(efc, "node allocation when shutting down %06x",
  54			      port_id);
  55		return NULL;
  56	}
  57
  58	node = mempool_alloc(efc->node_pool, GFP_ATOMIC);
  59	if (!node) {
  60		efc_log_err(efc, "node allocation failed %06x", port_id);
  61		return NULL;
  62	}
  63	memset(node, 0, sizeof(*node));
  64
  65	dma = &node->sparm_dma_buf;
  66	dma->size = NODE_SPARAMS_SIZE;
  67	dma->virt = dma_pool_zalloc(efc->node_dma_pool, GFP_ATOMIC, &dma->phys);
  68	if (!dma->virt) {
  69		efc_log_err(efc, "node dma alloc failed\n");
  70		goto dma_fail;
  71	}
  72	node->rnode.indicator = U32_MAX;
  73	node->nport = nport;
  74
  75	node->efc = efc;
  76	node->init = init;
  77	node->targ = targ;
  78
  79	spin_lock_init(&node->pend_frames_lock);
  80	INIT_LIST_HEAD(&node->pend_frames);
  81	spin_lock_init(&node->els_ios_lock);
  82	INIT_LIST_HEAD(&node->els_ios_list);
  83	node->els_io_enabled = true;
  84
  85	rc = efc_cmd_node_alloc(efc, &node->rnode, port_id, nport);
  86	if (rc) {
  87		efc_log_err(efc, "efc_hw_node_alloc failed: %d\n", rc);
  88		goto hw_alloc_fail;
  89	}
  90
  91	node->rnode.node = node;
  92	node->sm.app = node;
  93	node->evtdepth = 0;
  94
  95	efc_node_update_display_name(node);
  96
  97	rc = xa_err(xa_store(&nport->lookup, port_id, node, GFP_ATOMIC));
  98	if (rc) {
  99		efc_log_err(efc, "Node lookup store failed: %d\n", rc);
 100		goto xa_fail;
 101	}
 102
 103	/* initialize refcount */
 104	kref_init(&node->ref);
 105	node->release = _efc_node_free;
 106	kref_get(&nport->ref);
 107
 108	return node;
 109
 110xa_fail:
 111	efc_node_free_resources(efc, &node->rnode);
 112hw_alloc_fail:
 113	dma_pool_free(efc->node_dma_pool, dma->virt, dma->phys);
 114dma_fail:
 115	mempool_free(node, efc->node_pool);
 116	return NULL;
 117}
 118
 119void
 120efc_node_free(struct efc_node *node)
 121{
 122	struct efc_nport *nport;
 123	struct efc *efc;
 124	int rc = 0;
 125	struct efc_node *ns = NULL;
 126
 127	nport = node->nport;
 128	efc = node->efc;
 129
 130	node_printf(node, "Free'd\n");
 131
 132	if (node->refound) {
 133		/*
 134		 * Save the name server node. We will send fake RSCN event at
 135		 * the end to handle ignored RSCN event during node deletion
 136		 */
 137		ns = efc_node_find(node->nport, FC_FID_DIR_SERV);
 138	}
 139
 140	if (!node->nport) {
 141		efc_log_err(efc, "Node already Freed\n");
 142		return;
 143	}
 144
 145	/* Free HW resources */
 146	rc = efc_node_free_resources(efc, &node->rnode);
 147	if (rc < 0)
 148		efc_log_err(efc, "efc_hw_node_free failed: %d\n", rc);
 149
 150	/* if the gidpt_delay_timer is still running, then delete it */
 151	if (timer_pending(&node->gidpt_delay_timer))
 152		timer_delete(&node->gidpt_delay_timer);
 153
 154	xa_erase(&nport->lookup, node->rnode.fc_id);
 155
 156	/*
 157	 * If the node_list is empty,
 158	 * then post a ALL_CHILD_NODES_FREE event to the nport,
 159	 * after the lock is released.
 160	 * The nport may be free'd as a result of the event.
 161	 */
 162	if (xa_empty(&nport->lookup))
 163		efc_sm_post_event(&nport->sm, EFC_EVT_ALL_CHILD_NODES_FREE,
 164				  NULL);
 165
 166	node->nport = NULL;
 167	node->sm.current_state = NULL;
 168
 169	kref_put(&nport->ref, nport->release);
 170	kref_put(&node->ref, node->release);
 171
 172	if (ns) {
 173		/* sending fake RSCN event to name server node */
 174		efc_node_post_event(ns, EFC_EVT_RSCN_RCVD, NULL);
 175	}
 176}
 177
 178static void
 179efc_dma_copy_in(struct efc_dma *dma, void *buffer, u32 buffer_length)
 180{
 181	if (!dma || !buffer || !buffer_length)
 182		return;
 183
 184	if (buffer_length > dma->size)
 185		buffer_length = dma->size;
 186
 187	memcpy(dma->virt, buffer, buffer_length);
 188	dma->len = buffer_length;
 189}
 190
 191int
 192efc_node_attach(struct efc_node *node)
 193{
 194	int rc = 0;
 195	struct efc_nport *nport = node->nport;
 196	struct efc_domain *domain = nport->domain;
 197	struct efc *efc = node->efc;
 198
 199	if (!domain->attached) {
 200		efc_log_err(efc, "Warning: unattached domain\n");
 201		return -EIO;
 202	}
 203	/* Update node->wwpn/wwnn */
 204
 205	efc_node_build_eui_name(node->wwpn, sizeof(node->wwpn),
 206				efc_node_get_wwpn(node));
 207	efc_node_build_eui_name(node->wwnn, sizeof(node->wwnn),
 208				efc_node_get_wwnn(node));
 209
 210	efc_dma_copy_in(&node->sparm_dma_buf, node->service_params + 4,
 211			sizeof(node->service_params) - 4);
 212
 213	/* take lock to protect node->rnode.attached */
 214	rc = efc_cmd_node_attach(efc, &node->rnode, &node->sparm_dma_buf);
 215	if (rc < 0)
 216		efc_log_debug(efc, "efc_hw_node_attach failed: %d\n", rc);
 217
 218	return rc;
 219}
 220
 221void
 222efc_node_fcid_display(u32 fc_id, char *buffer, u32 buffer_length)
 223{
 224	switch (fc_id) {
 225	case FC_FID_FLOGI:
 226		snprintf(buffer, buffer_length, "fabric");
 227		break;
 228	case FC_FID_FCTRL:
 229		snprintf(buffer, buffer_length, "fabctl");
 230		break;
 231	case FC_FID_DIR_SERV:
 232		snprintf(buffer, buffer_length, "nserve");
 233		break;
 234	default:
 235		if (fc_id == FC_FID_DOM_MGR) {
 236			snprintf(buffer, buffer_length, "dctl%02x",
 237				 (fc_id & 0x0000ff));
 238		} else {
 239			snprintf(buffer, buffer_length, "%06x", fc_id);
 240		}
 241		break;
 242	}
 243}
 244
 245void
 246efc_node_update_display_name(struct efc_node *node)
 247{
 248	u32 port_id = node->rnode.fc_id;
 249	struct efc_nport *nport = node->nport;
 250	char portid_display[16];
 251
 252	efc_node_fcid_display(port_id, portid_display, sizeof(portid_display));
 253
 254	snprintf(node->display_name, sizeof(node->display_name), "%s.%s",
 255		 nport->display_name, portid_display);
 256}
 257
 258void
 259efc_node_send_ls_io_cleanup(struct efc_node *node)
 260{
 261	if (node->send_ls_acc != EFC_NODE_SEND_LS_ACC_NONE) {
 262		efc_log_debug(node->efc, "[%s] cleaning up LS_ACC oxid=0x%x\n",
 263			      node->display_name, node->ls_acc_oxid);
 264
 265		node->send_ls_acc = EFC_NODE_SEND_LS_ACC_NONE;
 266		node->ls_acc_io = NULL;
 267	}
 268}
 269
 270static void efc_node_handle_implicit_logo(struct efc_node *node)
 271{
 272	int rc;
 273
 274	/*
 275	 * currently, only case for implicit logo is PLOGI
 276	 * recvd. Thus, node's ELS IO pending list won't be
 277	 * empty (PLOGI will be on it)
 278	 */
 279	WARN_ON(node->send_ls_acc != EFC_NODE_SEND_LS_ACC_PLOGI);
 280	node_printf(node, "Reason: implicit logout, re-authenticate\n");
 281
 282	/* Re-attach node with the same HW node resources */
 283	node->req_free = false;
 284	rc = efc_node_attach(node);
 285	efc_node_transition(node, __efc_d_wait_node_attach, NULL);
 286	node->els_io_enabled = true;
 287
 288	if (rc < 0)
 289		efc_node_post_event(node, EFC_EVT_NODE_ATTACH_FAIL, NULL);
 290}
 291
 292static void efc_node_handle_explicit_logo(struct efc_node *node)
 293{
 294	s8 pend_frames_empty;
 295	unsigned long flags = 0;
 296
 297	/* cleanup any pending LS_ACC ELSs */
 298	efc_node_send_ls_io_cleanup(node);
 299
 300	spin_lock_irqsave(&node->pend_frames_lock, flags);
 301	pend_frames_empty = list_empty(&node->pend_frames);
 302	spin_unlock_irqrestore(&node->pend_frames_lock, flags);
 303
 304	/*
 305	 * there are two scenarios where we want to keep
 306	 * this node alive:
 307	 * 1. there are pending frames that need to be
 308	 *    processed or
 309	 * 2. we're an initiator and the remote node is
 310	 *    a target and we need to re-authenticate
 311	 */
 312	node_printf(node, "Shutdown: explicit logo pend=%d ", !pend_frames_empty);
 313	node_printf(node, "nport.ini=%d node.tgt=%d\n",
 314		    node->nport->enable_ini, node->targ);
 315	if (!pend_frames_empty || (node->nport->enable_ini && node->targ)) {
 316		u8 send_plogi = false;
 317
 318		if (node->nport->enable_ini && node->targ) {
 319			/*
 320			 * we're an initiator and
 321			 * node shutting down is a target;
 322			 * we'll need to re-authenticate in
 323			 * initial state
 324			 */
 325			send_plogi = true;
 326		}
 327
 328		/*
 329		 * transition to __efc_d_init
 330		 * (will retain HW node resources)
 331		 */
 332		node->els_io_enabled = true;
 333		node->req_free = false;
 334
 335		/*
 336		 * either pending frames exist or we are re-authenticating
 337		 * with PLOGI (or both); in either case, return to initial
 338		 * state
 339		 */
 340		efc_node_init_device(node, send_plogi);
 341	}
 342	/* else: let node shutdown occur */
 343}
 344
 345static void
 346efc_node_purge_pending(struct efc_node *node)
 347{
 348	struct efc *efc = node->efc;
 349	struct efc_hw_sequence *frame, *next;
 350	unsigned long flags = 0;
 351
 352	spin_lock_irqsave(&node->pend_frames_lock, flags);
 353
 354	list_for_each_entry_safe(frame, next, &node->pend_frames, list_entry) {
 355		list_del(&frame->list_entry);
 356		efc->tt.hw_seq_free(efc, frame);
 357	}
 358
 359	spin_unlock_irqrestore(&node->pend_frames_lock, flags);
 360}
 361
 362void
 363__efc_node_shutdown(struct efc_sm_ctx *ctx,
 364		    enum efc_sm_event evt, void *arg)
 365{
 366	struct efc_node *node = ctx->app;
 367
 368	efc_node_evt_set(ctx, evt, __func__);
 369
 370	node_sm_trace();
 371
 372	switch (evt) {
 373	case EFC_EVT_ENTER: {
 374		efc_node_hold_frames(node);
 375		WARN_ON(!efc_els_io_list_empty(node, &node->els_ios_list));
 376		/* by default, we will be freeing node after we unwind */
 377		node->req_free = true;
 378
 379		switch (node->shutdown_reason) {
 380		case EFC_NODE_SHUTDOWN_IMPLICIT_LOGO:
 381			/* Node shutdown b/c of PLOGI received when node
 382			 * already logged in. We have PLOGI service
 383			 * parameters, so submit node attach; we won't be
 384			 * freeing this node
 385			 */
 386
 387			efc_node_handle_implicit_logo(node);
 388			break;
 389
 390		case EFC_NODE_SHUTDOWN_EXPLICIT_LOGO:
 391			efc_node_handle_explicit_logo(node);
 392			break;
 393
 394		case EFC_NODE_SHUTDOWN_DEFAULT:
 395		default: {
 396			/*
 397			 * shutdown due to link down,
 398			 * node going away (xport event) or
 399			 * nport shutdown, purge pending and
 400			 * proceed to cleanup node
 401			 */
 402
 403			/* cleanup any pending LS_ACC ELSs */
 404			efc_node_send_ls_io_cleanup(node);
 405
 406			node_printf(node,
 407				    "Shutdown reason: default, purge pending\n");
 408			efc_node_purge_pending(node);
 409			break;
 410		}
 411		}
 412
 413		break;
 414	}
 415	case EFC_EVT_EXIT:
 416		efc_node_accept_frames(node);
 417		break;
 418
 419	default:
 420		__efc_node_common(__func__, ctx, evt, arg);
 421	}
 422}
 423
 424static bool
 425efc_node_check_els_quiesced(struct efc_node *node)
 426{
 427	/* check to see if ELS requests, completions are quiesced */
 428	if (node->els_req_cnt == 0 && node->els_cmpl_cnt == 0 &&
 429	    efc_els_io_list_empty(node, &node->els_ios_list)) {
 430		if (!node->attached) {
 431			/* hw node detach already completed, proceed */
 432			node_printf(node, "HW node not attached\n");
 433			efc_node_transition(node,
 434					    __efc_node_wait_ios_shutdown,
 435					     NULL);
 436		} else {
 437			/*
 438			 * hw node detach hasn't completed,
 439			 * transition and wait
 440			 */
 441			node_printf(node, "HW node still attached\n");
 442			efc_node_transition(node, __efc_node_wait_node_free,
 443					    NULL);
 444		}
 445		return true;
 446	}
 447	return false;
 448}
 449
 450void
 451efc_node_initiate_cleanup(struct efc_node *node)
 452{
 453	/*
 454	 * if ELS's have already been quiesced, will move to next state
 455	 * if ELS's have not been quiesced, abort them
 456	 */
 457	if (!efc_node_check_els_quiesced(node)) {
 458		efc_node_hold_frames(node);
 459		efc_node_transition(node, __efc_node_wait_els_shutdown, NULL);
 460	}
 461}
 462
 463void
 464__efc_node_wait_els_shutdown(struct efc_sm_ctx *ctx,
 465			     enum efc_sm_event evt, void *arg)
 466{
 467	bool check_quiesce = false;
 468	struct efc_node *node = ctx->app;
 469
 470	efc_node_evt_set(ctx, evt, __func__);
 471
 472	node_sm_trace();
 473	/* Node state machine: Wait for all ELSs to complete */
 474	switch (evt) {
 475	case EFC_EVT_ENTER:
 476		efc_node_hold_frames(node);
 477		if (efc_els_io_list_empty(node, &node->els_ios_list)) {
 478			node_printf(node, "All ELS IOs complete\n");
 479			check_quiesce = true;
 480		}
 481		break;
 482	case EFC_EVT_EXIT:
 483		efc_node_accept_frames(node);
 484		break;
 485
 486	case EFC_EVT_SRRS_ELS_REQ_OK:
 487	case EFC_EVT_SRRS_ELS_REQ_FAIL:
 488	case EFC_EVT_SRRS_ELS_REQ_RJT:
 489	case EFC_EVT_ELS_REQ_ABORTED:
 490		if (WARN_ON(!node->els_req_cnt))
 491			break;
 492		node->els_req_cnt--;
 493		check_quiesce = true;
 494		break;
 495
 496	case EFC_EVT_SRRS_ELS_CMPL_OK:
 497	case EFC_EVT_SRRS_ELS_CMPL_FAIL:
 498		if (WARN_ON(!node->els_cmpl_cnt))
 499			break;
 500		node->els_cmpl_cnt--;
 501		check_quiesce = true;
 502		break;
 503
 504	case EFC_EVT_ALL_CHILD_NODES_FREE:
 505		/* all ELS IO's complete */
 506		node_printf(node, "All ELS IOs complete\n");
 507		WARN_ON(!efc_els_io_list_empty(node, &node->els_ios_list));
 508		check_quiesce = true;
 509		break;
 510
 511	case EFC_EVT_NODE_ACTIVE_IO_LIST_EMPTY:
 512		check_quiesce = true;
 513		break;
 514
 515	case EFC_EVT_DOMAIN_ATTACH_OK:
 516		/* don't care about domain_attach_ok */
 517		break;
 518
 519	/* ignore shutdown events as we're already in shutdown path */
 520	case EFC_EVT_SHUTDOWN:
 521		/* have default shutdown event take precedence */
 522		node->shutdown_reason = EFC_NODE_SHUTDOWN_DEFAULT;
 523		fallthrough;
 524
 525	case EFC_EVT_SHUTDOWN_EXPLICIT_LOGO:
 526	case EFC_EVT_SHUTDOWN_IMPLICIT_LOGO:
 527		node_printf(node, "%s received\n", efc_sm_event_name(evt));
 528		break;
 529
 530	default:
 531		__efc_node_common(__func__, ctx, evt, arg);
 532	}
 533
 534	if (check_quiesce)
 535		efc_node_check_els_quiesced(node);
 536}
 537
 538void
 539__efc_node_wait_node_free(struct efc_sm_ctx *ctx,
 540			  enum efc_sm_event evt, void *arg)
 541{
 542	struct efc_node *node = ctx->app;
 543
 544	efc_node_evt_set(ctx, evt, __func__);
 545
 546	node_sm_trace();
 547
 548	switch (evt) {
 549	case EFC_EVT_ENTER:
 550		efc_node_hold_frames(node);
 551		break;
 552
 553	case EFC_EVT_EXIT:
 554		efc_node_accept_frames(node);
 555		break;
 556
 557	case EFC_EVT_NODE_FREE_OK:
 558		/* node is officially no longer attached */
 559		node->attached = false;
 560		efc_node_transition(node, __efc_node_wait_ios_shutdown, NULL);
 561		break;
 562
 563	case EFC_EVT_ALL_CHILD_NODES_FREE:
 564	case EFC_EVT_NODE_ACTIVE_IO_LIST_EMPTY:
 565		/* As IOs and ELS IO's complete we expect to get these events */
 566		break;
 567
 568	case EFC_EVT_DOMAIN_ATTACH_OK:
 569		/* don't care about domain_attach_ok */
 570		break;
 571
 572	/* ignore shutdown events as we're already in shutdown path */
 573	case EFC_EVT_SHUTDOWN:
 574		/* have default shutdown event take precedence */
 575		node->shutdown_reason = EFC_NODE_SHUTDOWN_DEFAULT;
 576		fallthrough;
 577
 578	case EFC_EVT_SHUTDOWN_EXPLICIT_LOGO:
 579	case EFC_EVT_SHUTDOWN_IMPLICIT_LOGO:
 580		node_printf(node, "%s received\n", efc_sm_event_name(evt));
 581		break;
 582	default:
 583		__efc_node_common(__func__, ctx, evt, arg);
 584	}
 585}
 586
 587void
 588__efc_node_wait_ios_shutdown(struct efc_sm_ctx *ctx,
 589			     enum efc_sm_event evt, void *arg)
 590{
 591	struct efc_node *node = ctx->app;
 592	struct efc *efc = node->efc;
 593
 594	efc_node_evt_set(ctx, evt, __func__);
 595
 596	node_sm_trace();
 597
 598	switch (evt) {
 599	case EFC_EVT_ENTER:
 600		efc_node_hold_frames(node);
 601
 602		/* first check to see if no ELS IOs are outstanding */
 603		if (efc_els_io_list_empty(node, &node->els_ios_list))
 604			/* If there are any active IOS, Free them. */
 605			efc_node_transition(node, __efc_node_shutdown, NULL);
 606		break;
 607
 608	case EFC_EVT_NODE_ACTIVE_IO_LIST_EMPTY:
 609	case EFC_EVT_ALL_CHILD_NODES_FREE:
 610		if (efc_els_io_list_empty(node, &node->els_ios_list))
 611			efc_node_transition(node, __efc_node_shutdown, NULL);
 612		break;
 613
 614	case EFC_EVT_EXIT:
 615		efc_node_accept_frames(node);
 616		break;
 617
 618	case EFC_EVT_SRRS_ELS_REQ_FAIL:
 619		/* Can happen as ELS IO IO's complete */
 620		if (WARN_ON(!node->els_req_cnt))
 621			break;
 622		node->els_req_cnt--;
 623		break;
 624
 625	/* ignore shutdown events as we're already in shutdown path */
 626	case EFC_EVT_SHUTDOWN:
 627		/* have default shutdown event take precedence */
 628		node->shutdown_reason = EFC_NODE_SHUTDOWN_DEFAULT;
 629		fallthrough;
 630
 631	case EFC_EVT_SHUTDOWN_EXPLICIT_LOGO:
 632	case EFC_EVT_SHUTDOWN_IMPLICIT_LOGO:
 633		efc_log_debug(efc, "[%s] %-20s\n", node->display_name,
 634			      efc_sm_event_name(evt));
 635		break;
 636	case EFC_EVT_DOMAIN_ATTACH_OK:
 637		/* don't care about domain_attach_ok */
 638		break;
 639	default:
 640		__efc_node_common(__func__, ctx, evt, arg);
 641	}
 642}
 643
 644void
 645__efc_node_common(const char *funcname, struct efc_sm_ctx *ctx,
 646		  enum efc_sm_event evt, void *arg)
 647{
 648	struct efc_node *node = NULL;
 649	struct efc *efc = NULL;
 650	struct efc_node_cb *cbdata = arg;
 651
 652	node = ctx->app;
 653	efc = node->efc;
 654
 655	switch (evt) {
 656	case EFC_EVT_ENTER:
 657	case EFC_EVT_REENTER:
 658	case EFC_EVT_EXIT:
 659	case EFC_EVT_NPORT_TOPOLOGY_NOTIFY:
 660	case EFC_EVT_NODE_MISSING:
 661	case EFC_EVT_FCP_CMD_RCVD:
 662		break;
 663
 664	case EFC_EVT_NODE_REFOUND:
 665		node->refound = true;
 666		break;
 667
 668	/*
 669	 * node->attached must be set appropriately
 670	 * for all node attach/detach events
 671	 */
 672	case EFC_EVT_NODE_ATTACH_OK:
 673		node->attached = true;
 674		break;
 675
 676	case EFC_EVT_NODE_FREE_OK:
 677	case EFC_EVT_NODE_ATTACH_FAIL:
 678		node->attached = false;
 679		break;
 680
 681	/*
 682	 * handle any ELS completions that
 683	 * other states either didn't care about
 684	 * or forgot about
 685	 */
 686	case EFC_EVT_SRRS_ELS_CMPL_OK:
 687	case EFC_EVT_SRRS_ELS_CMPL_FAIL:
 688		if (WARN_ON(!node->els_cmpl_cnt))
 689			break;
 690		node->els_cmpl_cnt--;
 691		break;
 692
 693	/*
 694	 * handle any ELS request completions that
 695	 * other states either didn't care about
 696	 * or forgot about
 697	 */
 698	case EFC_EVT_SRRS_ELS_REQ_OK:
 699	case EFC_EVT_SRRS_ELS_REQ_FAIL:
 700	case EFC_EVT_SRRS_ELS_REQ_RJT:
 701	case EFC_EVT_ELS_REQ_ABORTED:
 702		if (WARN_ON(!node->els_req_cnt))
 703			break;
 704		node->els_req_cnt--;
 705		break;
 706
 707	case EFC_EVT_ELS_RCVD: {
 708		struct fc_frame_header *hdr = cbdata->header->dma.virt;
 709
 710		/*
 711		 * Unsupported ELS was received,
 712		 * send LS_RJT, command not supported
 713		 */
 714		efc_log_debug(efc,
 715			      "[%s] (%s) ELS x%02x, LS_RJT not supported\n",
 716			      node->display_name, funcname,
 717			      ((u8 *)cbdata->payload->dma.virt)[0]);
 718
 719		efc_send_ls_rjt(node, be16_to_cpu(hdr->fh_ox_id),
 720				ELS_RJT_UNSUP, ELS_EXPL_NONE, 0);
 721		break;
 722	}
 723
 724	case EFC_EVT_PLOGI_RCVD:
 725	case EFC_EVT_FLOGI_RCVD:
 726	case EFC_EVT_LOGO_RCVD:
 727	case EFC_EVT_PRLI_RCVD:
 728	case EFC_EVT_PRLO_RCVD:
 729	case EFC_EVT_PDISC_RCVD:
 730	case EFC_EVT_FDISC_RCVD:
 731	case EFC_EVT_ADISC_RCVD:
 732	case EFC_EVT_RSCN_RCVD:
 733	case EFC_EVT_SCR_RCVD: {
 734		struct fc_frame_header *hdr = cbdata->header->dma.virt;
 735
 736		/* sm: / send ELS_RJT */
 737		efc_log_debug(efc, "[%s] (%s) %s sending ELS_RJT\n",
 738			      node->display_name, funcname,
 739			      efc_sm_event_name(evt));
 740		/* if we didn't catch this in a state, send generic LS_RJT */
 741		efc_send_ls_rjt(node, be16_to_cpu(hdr->fh_ox_id),
 742				ELS_RJT_UNAB, ELS_EXPL_NONE, 0);
 743		break;
 744	}
 745	case EFC_EVT_ABTS_RCVD: {
 746		efc_log_debug(efc, "[%s] (%s) %s sending BA_ACC\n",
 747			      node->display_name, funcname,
 748			      efc_sm_event_name(evt));
 749
 750		/* sm: / send BA_ACC */
 751		efc_send_bls_acc(node, cbdata->header->dma.virt);
 752		break;
 753	}
 754
 755	default:
 756		efc_log_debug(node->efc, "[%s] %-20s %-20s not handled\n",
 757			      node->display_name, funcname,
 758			      efc_sm_event_name(evt));
 759	}
 760}
 761
 762void
 763efc_node_save_sparms(struct efc_node *node, void *payload)
 764{
 765	memcpy(node->service_params, payload, sizeof(node->service_params));
 766}
 767
 768void
 769efc_node_post_event(struct efc_node *node,
 770		    enum efc_sm_event evt, void *arg)
 771{
 772	bool free_node = false;
 773
 774	node->evtdepth++;
 775
 776	efc_sm_post_event(&node->sm, evt, arg);
 777
 778	/* If our event call depth is one and
 779	 * we're not holding frames
 780	 * then we can dispatch any pending frames.
 781	 * We don't want to allow the efc_process_node_pending()
 782	 * call to recurse.
 783	 */
 784	if (!node->hold_frames && node->evtdepth == 1)
 785		efc_process_node_pending(node);
 786
 787	node->evtdepth--;
 788
 789	/*
 790	 * Free the node object if so requested,
 791	 * and we're at an event call depth of zero
 792	 */
 793	if (node->evtdepth == 0 && node->req_free)
 794		free_node = true;
 795
 796	if (free_node)
 797		efc_node_free(node);
 798}
 799
 800void
 801efc_node_transition(struct efc_node *node,
 802		    void (*state)(struct efc_sm_ctx *,
 803				  enum efc_sm_event, void *), void *data)
 804{
 805	struct efc_sm_ctx *ctx = &node->sm;
 806
 807	if (ctx->current_state == state) {
 808		efc_node_post_event(node, EFC_EVT_REENTER, data);
 809	} else {
 810		efc_node_post_event(node, EFC_EVT_EXIT, data);
 811		ctx->current_state = state;
 812		efc_node_post_event(node, EFC_EVT_ENTER, data);
 813	}
 814}
 815
 816void
 817efc_node_build_eui_name(char *buf, u32 buf_len, uint64_t eui_name)
 818{
 819	memset(buf, 0, buf_len);
 820
 821	snprintf(buf, buf_len, "eui.%016llX", (unsigned long long)eui_name);
 822}
 823
 824u64
 825efc_node_get_wwpn(struct efc_node *node)
 826{
 827	struct fc_els_flogi *sp =
 828			(struct fc_els_flogi *)node->service_params;
 829
 830	return be64_to_cpu(sp->fl_wwpn);
 831}
 832
 833u64
 834efc_node_get_wwnn(struct efc_node *node)
 835{
 836	struct fc_els_flogi *sp =
 837			(struct fc_els_flogi *)node->service_params;
 838
 839	return be64_to_cpu(sp->fl_wwnn);
 840}
 841
 842int
 843efc_node_check_els_req(struct efc_sm_ctx *ctx, enum efc_sm_event evt, void *arg,
 844		u8 cmd, void (*efc_node_common_func)(const char *,
 845				struct efc_sm_ctx *, enum efc_sm_event, void *),
 846		const char *funcname)
 847{
 848	return 0;
 849}
 850
 851int
 852efc_node_check_ns_req(struct efc_sm_ctx *ctx, enum efc_sm_event evt, void *arg,
 853		u16 cmd, void (*efc_node_common_func)(const char *,
 854				struct efc_sm_ctx *, enum efc_sm_event, void *),
 855		const char *funcname)
 856{
 857	return 0;
 858}
 859
 860int
 861efc_els_io_list_empty(struct efc_node *node, struct list_head *list)
 862{
 863	int empty;
 864	unsigned long flags = 0;
 865
 866	spin_lock_irqsave(&node->els_ios_lock, flags);
 867	empty = list_empty(list);
 868	spin_unlock_irqrestore(&node->els_ios_lock, flags);
 869	return empty;
 870}
 871
 872void
 873efc_node_pause(struct efc_node *node,
 874	       void (*state)(struct efc_sm_ctx *,
 875			     enum efc_sm_event, void *))
 876
 877{
 878	node->nodedb_state = state;
 879	efc_node_transition(node, __efc_node_paused, NULL);
 880}
 881
 882void
 883__efc_node_paused(struct efc_sm_ctx *ctx,
 884		  enum efc_sm_event evt, void *arg)
 885{
 886	struct efc_node *node = ctx->app;
 887
 888	efc_node_evt_set(ctx, evt, __func__);
 889
 890	node_sm_trace();
 891
 892	/*
 893	 * This state is entered when a state is "paused". When resumed, the
 894	 * node is transitioned to a previously saved state (node->ndoedb_state)
 895	 */
 896	switch (evt) {
 897	case EFC_EVT_ENTER:
 898		node_printf(node, "Paused\n");
 899		break;
 900
 901	case EFC_EVT_RESUME: {
 902		void (*pf)(struct efc_sm_ctx *ctx,
 903			   enum efc_sm_event evt, void *arg);
 904
 905		pf = node->nodedb_state;
 906
 907		node->nodedb_state = NULL;
 908		efc_node_transition(node, pf, NULL);
 909		break;
 910	}
 911
 912	case EFC_EVT_DOMAIN_ATTACH_OK:
 913		break;
 914
 915	case EFC_EVT_SHUTDOWN:
 916		node->req_free = true;
 917		break;
 918
 919	default:
 920		__efc_node_common(__func__, ctx, evt, arg);
 921	}
 922}
 923
 924void
 925efc_node_recv_els_frame(struct efc_node *node,
 926			struct efc_hw_sequence *seq)
 927{
 928	u32 prli_size = sizeof(struct fc_els_prli) + sizeof(struct fc_els_spp);
 929	struct {
 930		u32 cmd;
 931		enum efc_sm_event evt;
 932		u32 payload_size;
 933	} els_cmd_list[] = {
 934		{ELS_PLOGI, EFC_EVT_PLOGI_RCVD,	sizeof(struct fc_els_flogi)},
 935		{ELS_FLOGI, EFC_EVT_FLOGI_RCVD,	sizeof(struct fc_els_flogi)},
 936		{ELS_LOGO, EFC_EVT_LOGO_RCVD, sizeof(struct fc_els_ls_acc)},
 937		{ELS_PRLI, EFC_EVT_PRLI_RCVD, prli_size},
 938		{ELS_PRLO, EFC_EVT_PRLO_RCVD, prli_size},
 939		{ELS_PDISC, EFC_EVT_PDISC_RCVD,	MAX_ACC_REJECT_PAYLOAD},
 940		{ELS_FDISC, EFC_EVT_FDISC_RCVD,	MAX_ACC_REJECT_PAYLOAD},
 941		{ELS_ADISC, EFC_EVT_ADISC_RCVD,	sizeof(struct fc_els_adisc)},
 942		{ELS_RSCN, EFC_EVT_RSCN_RCVD, MAX_ACC_REJECT_PAYLOAD},
 943		{ELS_SCR, EFC_EVT_SCR_RCVD, MAX_ACC_REJECT_PAYLOAD},
 944	};
 945	struct efc_node_cb cbdata;
 946	u8 *buf = seq->payload->dma.virt;
 947	enum efc_sm_event evt = EFC_EVT_ELS_RCVD;
 948	u32 i;
 949
 950	memset(&cbdata, 0, sizeof(cbdata));
 951	cbdata.header = seq->header;
 952	cbdata.payload = seq->payload;
 953
 954	/* find a matching event for the ELS command */
 955	for (i = 0; i < ARRAY_SIZE(els_cmd_list); i++) {
 956		if (els_cmd_list[i].cmd == buf[0]) {
 957			evt = els_cmd_list[i].evt;
 958			break;
 959		}
 960	}
 961
 962	efc_node_post_event(node, evt, &cbdata);
 963}
 964
 965void
 966efc_node_recv_ct_frame(struct efc_node *node,
 967		       struct efc_hw_sequence *seq)
 968{
 969	struct fc_ct_hdr *iu = seq->payload->dma.virt;
 970	struct fc_frame_header *hdr = seq->header->dma.virt;
 971	struct efc *efc = node->efc;
 972	u16 gscmd = be16_to_cpu(iu->ct_cmd);
 973
 974	efc_log_err(efc, "[%s] Received cmd :%x sending CT_REJECT\n",
 975		    node->display_name, gscmd);
 976	efc_send_ct_rsp(efc, node, be16_to_cpu(hdr->fh_ox_id), iu,
 977			FC_FS_RJT, FC_FS_RJT_UNSUP, 0);
 978}
 979
 980void
 981efc_node_recv_fcp_cmd(struct efc_node *node, struct efc_hw_sequence *seq)
 982{
 983	struct efc_node_cb cbdata;
 984
 985	memset(&cbdata, 0, sizeof(cbdata));
 986	cbdata.header = seq->header;
 987	cbdata.payload = seq->payload;
 988
 989	efc_node_post_event(node, EFC_EVT_FCP_CMD_RCVD, &cbdata);
 990}
 991
 992void
 993efc_process_node_pending(struct efc_node *node)
 994{
 995	struct efc *efc = node->efc;
 996	struct efc_hw_sequence *seq = NULL;
 997	u32 pend_frames_processed = 0;
 998	unsigned long flags = 0;
 999
1000	for (;;) {
1001		/* need to check for hold frames condition after each frame
1002		 * processed because any given frame could cause a transition
1003		 * to a state that holds frames
1004		 */
1005		if (node->hold_frames)
1006			break;
1007
1008		seq = NULL;
1009		/* Get next frame/sequence */
1010		spin_lock_irqsave(&node->pend_frames_lock, flags);
1011
1012		if (!list_empty(&node->pend_frames)) {
1013			seq = list_first_entry(&node->pend_frames,
1014					struct efc_hw_sequence, list_entry);
1015			list_del(&seq->list_entry);
1016		}
1017		spin_unlock_irqrestore(&node->pend_frames_lock, flags);
1018
1019		if (!seq) {
1020			pend_frames_processed =	node->pend_frames_processed;
1021			node->pend_frames_processed = 0;
1022			break;
1023		}
1024		node->pend_frames_processed++;
1025
1026		/* now dispatch frame(s) to dispatch function */
1027		efc_node_dispatch_frame(node, seq);
1028		efc->tt.hw_seq_free(efc, seq);
1029	}
1030
1031	if (pend_frames_processed != 0)
1032		efc_log_debug(efc, "%u node frames held and processed\n",
1033			      pend_frames_processed);
1034}
1035
1036void
1037efc_scsi_sess_reg_complete(struct efc_node *node, u32 status)
1038{
1039	unsigned long flags = 0;
1040	enum efc_sm_event evt = EFC_EVT_NODE_SESS_REG_OK;
1041	struct efc *efc = node->efc;
1042
1043	if (status)
1044		evt = EFC_EVT_NODE_SESS_REG_FAIL;
1045
1046	spin_lock_irqsave(&efc->lock, flags);
1047	/* Notify the node to resume */
1048	efc_node_post_event(node, evt, NULL);
1049	spin_unlock_irqrestore(&efc->lock, flags);
1050}
1051
1052void
1053efc_scsi_del_initiator_complete(struct efc *efc, struct efc_node *node)
1054{
1055	unsigned long flags = 0;
1056
1057	spin_lock_irqsave(&efc->lock, flags);
1058	/* Notify the node to resume */
1059	efc_node_post_event(node, EFC_EVT_NODE_DEL_INI_COMPLETE, NULL);
1060	spin_unlock_irqrestore(&efc->lock, flags);
1061}
1062
1063void
1064efc_scsi_del_target_complete(struct efc *efc, struct efc_node *node)
1065{
1066	unsigned long flags = 0;
1067
1068	spin_lock_irqsave(&efc->lock, flags);
1069	/* Notify the node to resume */
1070	efc_node_post_event(node, EFC_EVT_NODE_DEL_TGT_COMPLETE, NULL);
1071	spin_unlock_irqrestore(&efc->lock, flags);
1072}
1073
1074void
1075efc_scsi_io_list_empty(struct efc *efc, struct efc_node *node)
1076{
1077	unsigned long flags = 0;
1078
1079	spin_lock_irqsave(&efc->lock, flags);
1080	efc_node_post_event(node, EFC_EVT_NODE_ACTIVE_IO_LIST_EMPTY, NULL);
1081	spin_unlock_irqrestore(&efc->lock, flags);
1082}
1083
1084void efc_node_post_els_resp(struct efc_node *node, u32 evt, void *arg)
1085{
1086	struct efc *efc = node->efc;
1087	unsigned long flags = 0;
1088
1089	spin_lock_irqsave(&efc->lock, flags);
1090	efc_node_post_event(node, evt, arg);
1091	spin_unlock_irqrestore(&efc->lock, flags);
1092}
1093
1094void efc_node_post_shutdown(struct efc_node *node, void *arg)
1095{
1096	unsigned long flags = 0;
1097	struct efc *efc = node->efc;
1098
1099	spin_lock_irqsave(&efc->lock, flags);
1100	efc_node_post_event(node, EFC_EVT_SHUTDOWN, arg);
1101	spin_unlock_irqrestore(&efc->lock, flags);
1102}