drivers/scsi/elx/libefc/efc_device.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 /*
   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 }