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