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 * domain_sm Domain State Machine: States 9 */ 10 11#include "efc.h" 12 13int 14efc_domain_cb(void *arg, int event, void *data) 15{ 16 struct efc *efc = arg; 17 struct efc_domain *domain = NULL; 18 int rc = 0; 19 unsigned long flags = 0; 20 21 if (event != EFC_HW_DOMAIN_FOUND) 22 domain = data; 23 24 /* Accept domain callback events from the user driver */ 25 spin_lock_irqsave(&efc->lock, flags); 26 switch (event) { 27 case EFC_HW_DOMAIN_FOUND: { 28 u64 fcf_wwn = 0; 29 struct efc_domain_record *drec = data; 30 31 /* extract the fcf_wwn */ 32 fcf_wwn = be64_to_cpu(*((__be64 *)drec->wwn)); 33 34 efc_log_debug(efc, "Domain found: wwn %016llX\n", fcf_wwn); 35 36 /* lookup domain, or allocate a new one */ 37 domain = efc->domain; 38 if (!domain) { 39 domain = efc_domain_alloc(efc, fcf_wwn); 40 if (!domain) { 41 efc_log_err(efc, "efc_domain_alloc() failed\n"); 42 rc = -1; 43 break; 44 } 45 efc_sm_transition(&domain->drvsm, __efc_domain_init, 46 NULL); 47 } 48 efc_domain_post_event(domain, EFC_EVT_DOMAIN_FOUND, drec); 49 break; 50 } 51 52 case EFC_HW_DOMAIN_LOST: 53 domain_trace(domain, "EFC_HW_DOMAIN_LOST:\n"); 54 efc->hold_frames = true; 55 efc_domain_post_event(domain, EFC_EVT_DOMAIN_LOST, NULL); 56 break; 57 58 case EFC_HW_DOMAIN_ALLOC_OK: 59 domain_trace(domain, "EFC_HW_DOMAIN_ALLOC_OK:\n"); 60 efc_domain_post_event(domain, EFC_EVT_DOMAIN_ALLOC_OK, NULL); 61 break; 62 63 case EFC_HW_DOMAIN_ALLOC_FAIL: 64 domain_trace(domain, "EFC_HW_DOMAIN_ALLOC_FAIL:\n"); 65 efc_domain_post_event(domain, EFC_EVT_DOMAIN_ALLOC_FAIL, 66 NULL); 67 break; 68 69 case EFC_HW_DOMAIN_ATTACH_OK: 70 domain_trace(domain, "EFC_HW_DOMAIN_ATTACH_OK:\n"); 71 efc_domain_post_event(domain, EFC_EVT_DOMAIN_ATTACH_OK, NULL); 72 break; 73 74 case EFC_HW_DOMAIN_ATTACH_FAIL: 75 domain_trace(domain, "EFC_HW_DOMAIN_ATTACH_FAIL:\n"); 76 efc_domain_post_event(domain, 77 EFC_EVT_DOMAIN_ATTACH_FAIL, NULL); 78 break; 79 80 case EFC_HW_DOMAIN_FREE_OK: 81 domain_trace(domain, "EFC_HW_DOMAIN_FREE_OK:\n"); 82 efc_domain_post_event(domain, EFC_EVT_DOMAIN_FREE_OK, NULL); 83 break; 84 85 case EFC_HW_DOMAIN_FREE_FAIL: 86 domain_trace(domain, "EFC_HW_DOMAIN_FREE_FAIL:\n"); 87 efc_domain_post_event(domain, EFC_EVT_DOMAIN_FREE_FAIL, NULL); 88 break; 89 90 default: 91 efc_log_warn(efc, "unsupported event %#x\n", event); 92 } 93 spin_unlock_irqrestore(&efc->lock, flags); 94 95 if (efc->domain && domain->req_accept_frames) { 96 domain->req_accept_frames = false; 97 efc->hold_frames = false; 98 } 99 100 return rc; 101} 102 103static void 104_efc_domain_free(struct kref *arg) 105{ 106 struct efc_domain *domain = container_of(arg, struct efc_domain, ref); 107 struct efc *efc = domain->efc; 108 109 if (efc->domain_free_cb) 110 (*efc->domain_free_cb)(efc, efc->domain_free_cb_arg); 111 112 kfree(domain); 113} 114 115void 116efc_domain_free(struct efc_domain *domain) 117{ 118 struct efc *efc; 119 120 efc = domain->efc; 121 122 /* Hold frames to clear the domain pointer from the xport lookup */ 123 efc->hold_frames = false; 124 125 efc_log_debug(efc, "Domain free: wwn %016llX\n", domain->fcf_wwn); 126 127 xa_destroy(&domain->lookup); 128 efc->domain = NULL; 129 kref_put(&domain->ref, domain->release); 130} 131 132struct efc_domain * 133efc_domain_alloc(struct efc *efc, uint64_t fcf_wwn) 134{ 135 struct efc_domain *domain; 136 137 domain = kzalloc(sizeof(*domain), GFP_ATOMIC); 138 if (!domain) 139 return NULL; 140 141 domain->efc = efc; 142 domain->drvsm.app = domain; 143 144 /* initialize refcount */ 145 kref_init(&domain->ref); 146 domain->release = _efc_domain_free; 147 148 xa_init(&domain->lookup); 149 150 INIT_LIST_HEAD(&domain->nport_list); 151 efc->domain = domain; 152 domain->fcf_wwn = fcf_wwn; 153 efc_log_debug(efc, "Domain allocated: wwn %016llX\n", domain->fcf_wwn); 154 155 return domain; 156} 157 158void 159efc_register_domain_free_cb(struct efc *efc, 160 void (*callback)(struct efc *efc, void *arg), 161 void *arg) 162{ 163 /* Register a callback to be called when the domain is freed */ 164 efc->domain_free_cb = callback; 165 efc->domain_free_cb_arg = arg; 166 if (!efc->domain && callback) 167 (*callback)(efc, arg); 168} 169 170static void 171__efc_domain_common(const char *funcname, struct efc_sm_ctx *ctx, 172 enum efc_sm_event evt, void *arg) 173{ 174 struct efc_domain *domain = ctx->app; 175 176 switch (evt) { 177 case EFC_EVT_ENTER: 178 case EFC_EVT_REENTER: 179 case EFC_EVT_EXIT: 180 case EFC_EVT_ALL_CHILD_NODES_FREE: 181 /* 182 * this can arise if an FLOGI fails on the NPORT, 183 * and the NPORT is shutdown 184 */ 185 break; 186 default: 187 efc_log_warn(domain->efc, "%-20s %-20s not handled\n", 188 funcname, efc_sm_event_name(evt)); 189 } 190} 191 192static void 193__efc_domain_common_shutdown(const char *funcname, struct efc_sm_ctx *ctx, 194 enum efc_sm_event evt, void *arg) 195{ 196 struct efc_domain *domain = ctx->app; 197 198 switch (evt) { 199 case EFC_EVT_ENTER: 200 case EFC_EVT_REENTER: 201 case EFC_EVT_EXIT: 202 break; 203 case EFC_EVT_DOMAIN_FOUND: 204 /* save drec, mark domain_found_pending */ 205 memcpy(&domain->pending_drec, arg, 206 sizeof(domain->pending_drec)); 207 domain->domain_found_pending = true; 208 break; 209 case EFC_EVT_DOMAIN_LOST: 210 /* unmark domain_found_pending */ 211 domain->domain_found_pending = false; 212 break; 213 214 default: 215 efc_log_warn(domain->efc, "%-20s %-20s not handled\n", 216 funcname, efc_sm_event_name(evt)); 217 } 218} 219 220#define std_domain_state_decl(...)\ 221 struct efc_domain *domain = NULL;\ 222 struct efc *efc = NULL;\ 223 \ 224 WARN_ON(!ctx || !ctx->app);\ 225 domain = ctx->app;\ 226 WARN_ON(!domain->efc);\ 227 efc = domain->efc 228 229void 230__efc_domain_init(struct efc_sm_ctx *ctx, enum efc_sm_event evt, 231 void *arg) 232{ 233 std_domain_state_decl(); 234 235 domain_sm_trace(domain); 236 237 switch (evt) { 238 case EFC_EVT_ENTER: 239 domain->attached = false; 240 break; 241 242 case EFC_EVT_DOMAIN_FOUND: { 243 u32 i; 244 struct efc_domain_record *drec = arg; 245 struct efc_nport *nport; 246 247 u64 my_wwnn = efc->req_wwnn; 248 u64 my_wwpn = efc->req_wwpn; 249 __be64 bewwpn; 250 251 if (my_wwpn == 0 || my_wwnn == 0) { 252 efc_log_debug(efc, "using default hardware WWN config\n"); 253 my_wwpn = efc->def_wwpn; 254 my_wwnn = efc->def_wwnn; 255 } 256 257 efc_log_debug(efc, "Create nport WWPN %016llX WWNN %016llX\n", 258 my_wwpn, my_wwnn); 259 260 /* Allocate a nport and transition to __efc_nport_allocated */ 261 nport = efc_nport_alloc(domain, my_wwpn, my_wwnn, U32_MAX, 262 efc->enable_ini, efc->enable_tgt); 263 264 if (!nport) { 265 efc_log_err(efc, "efc_nport_alloc() failed\n"); 266 break; 267 } 268 efc_sm_transition(&nport->sm, __efc_nport_allocated, NULL); 269 270 bewwpn = cpu_to_be64(nport->wwpn); 271 272 /* allocate struct efc_nport object for local port 273 * Note: drec->fc_id is ALPA from read_topology only if loop 274 */ 275 if (efc_cmd_nport_alloc(efc, nport, NULL, (uint8_t *)&bewwpn)) { 276 efc_log_err(efc, "Can't allocate port\n"); 277 efc_nport_free(nport); 278 break; 279 } 280 281 domain->is_loop = drec->is_loop; 282 283 /* 284 * If the loop position map includes ALPA == 0, 285 * then we are in a public loop (NL_PORT) 286 * Note that the first element of the loopmap[] 287 * contains the count of elements, and if 288 * ALPA == 0 is present, it will occupy the first 289 * location after the count. 290 */ 291 domain->is_nlport = drec->map.loop[1] == 0x00; 292 293 if (!domain->is_loop) { 294 /* Initiate HW domain alloc */ 295 if (efc_cmd_domain_alloc(efc, domain, drec->index)) { 296 efc_log_err(efc, 297 "Failed to initiate HW domain allocation\n"); 298 break; 299 } 300 efc_sm_transition(ctx, __efc_domain_wait_alloc, arg); 301 break; 302 } 303 304 efc_log_debug(efc, "%s fc_id=%#x speed=%d\n", 305 drec->is_loop ? 306 (domain->is_nlport ? 307 "public-loop" : "loop") : "other", 308 drec->fc_id, drec->speed); 309 310 nport->fc_id = drec->fc_id; 311 nport->topology = EFC_NPORT_TOPO_FC_AL; 312 snprintf(nport->display_name, sizeof(nport->display_name), 313 "s%06x", drec->fc_id); 314 315 if (efc->enable_ini) { 316 u32 count = drec->map.loop[0]; 317 318 efc_log_debug(efc, "%d position map entries\n", 319 count); 320 for (i = 1; i <= count; i++) { 321 if (drec->map.loop[i] != drec->fc_id) { 322 struct efc_node *node; 323 324 efc_log_debug(efc, "%#x -> %#x\n", 325 drec->fc_id, 326 drec->map.loop[i]); 327 node = efc_node_alloc(nport, 328 drec->map.loop[i], 329 false, true); 330 if (!node) { 331 efc_log_err(efc, 332 "efc_node_alloc() failed\n"); 333 break; 334 } 335 efc_node_transition(node, 336 __efc_d_wait_loop, 337 NULL); 338 } 339 } 340 } 341 342 /* Initiate HW domain alloc */ 343 if (efc_cmd_domain_alloc(efc, domain, drec->index)) { 344 efc_log_err(efc, 345 "Failed to initiate HW domain allocation\n"); 346 break; 347 } 348 efc_sm_transition(ctx, __efc_domain_wait_alloc, arg); 349 break; 350 } 351 default: 352 __efc_domain_common(__func__, ctx, evt, arg); 353 } 354} 355 356void 357__efc_domain_wait_alloc(struct efc_sm_ctx *ctx, 358 enum efc_sm_event evt, void *arg) 359{ 360 std_domain_state_decl(); 361 362 domain_sm_trace(domain); 363 364 switch (evt) { 365 case EFC_EVT_DOMAIN_ALLOC_OK: { 366 struct fc_els_flogi *sp; 367 struct efc_nport *nport; 368 369 nport = domain->nport; 370 if (WARN_ON(!nport)) 371 return; 372 373 sp = (struct fc_els_flogi *)nport->service_params; 374 375 /* Save the domain service parameters */ 376 memcpy(domain->service_params + 4, domain->dma.virt, 377 sizeof(struct fc_els_flogi) - 4); 378 memcpy(nport->service_params + 4, domain->dma.virt, 379 sizeof(struct fc_els_flogi) - 4); 380 381 /* 382 * Update the nport's service parameters, 383 * user might have specified non-default names 384 */ 385 sp->fl_wwpn = cpu_to_be64(nport->wwpn); 386 sp->fl_wwnn = cpu_to_be64(nport->wwnn); 387 388 /* 389 * Take the loop topology path, 390 * unless we are an NL_PORT (public loop) 391 */ 392 if (domain->is_loop && !domain->is_nlport) { 393 /* 394 * For loop, we already have our FC ID 395 * and don't need fabric login. 396 * Transition to the allocated state and 397 * post an event to attach to 398 * the domain. Note that this breaks the 399 * normal action/transition 400 * pattern here to avoid a race with the 401 * domain attach callback. 402 */ 403 /* sm: is_loop / domain_attach */ 404 efc_sm_transition(ctx, __efc_domain_allocated, NULL); 405 __efc_domain_attach_internal(domain, nport->fc_id); 406 break; 407 } 408 { 409 struct efc_node *node; 410 411 /* alloc fabric node, send FLOGI */ 412 node = efc_node_find(nport, FC_FID_FLOGI); 413 if (node) { 414 efc_log_err(efc, 415 "Fabric Controller node already exists\n"); 416 break; 417 } 418 node = efc_node_alloc(nport, FC_FID_FLOGI, 419 false, false); 420 if (!node) { 421 efc_log_err(efc, 422 "Error: efc_node_alloc() failed\n"); 423 } else { 424 efc_node_transition(node, 425 __efc_fabric_init, NULL); 426 } 427 /* Accept frames */ 428 domain->req_accept_frames = true; 429 } 430 /* sm: / start fabric logins */ 431 efc_sm_transition(ctx, __efc_domain_allocated, NULL); 432 break; 433 } 434 435 case EFC_EVT_DOMAIN_ALLOC_FAIL: 436 efc_log_err(efc, "%s recv'd waiting for DOMAIN_ALLOC_OK;", 437 efc_sm_event_name(evt)); 438 efc_log_err(efc, "shutting down domain\n"); 439 domain->req_domain_free = true; 440 break; 441 442 case EFC_EVT_DOMAIN_FOUND: 443 /* Should not happen */ 444 break; 445 446 case EFC_EVT_DOMAIN_LOST: 447 efc_log_debug(efc, 448 "%s received while waiting for hw_domain_alloc()\n", 449 efc_sm_event_name(evt)); 450 efc_sm_transition(ctx, __efc_domain_wait_domain_lost, NULL); 451 break; 452 453 default: 454 __efc_domain_common(__func__, ctx, evt, arg); 455 } 456} 457 458void 459__efc_domain_allocated(struct efc_sm_ctx *ctx, 460 enum efc_sm_event evt, void *arg) 461{ 462 std_domain_state_decl(); 463 464 domain_sm_trace(domain); 465 466 switch (evt) { 467 case EFC_EVT_DOMAIN_REQ_ATTACH: { 468 int rc = 0; 469 u32 fc_id; 470 471 if (WARN_ON(!arg)) 472 return; 473 474 fc_id = *((u32 *)arg); 475 efc_log_debug(efc, "Requesting hw domain attach fc_id x%x\n", 476 fc_id); 477 /* Update nport lookup */ 478 rc = xa_err(xa_store(&domain->lookup, fc_id, domain->nport, 479 GFP_ATOMIC)); 480 if (rc) { 481 efc_log_err(efc, "Sport lookup store failed: %d\n", rc); 482 return; 483 } 484 485 /* Update display name for the nport */ 486 efc_node_fcid_display(fc_id, domain->nport->display_name, 487 sizeof(domain->nport->display_name)); 488 489 /* Issue domain attach call */ 490 rc = efc_cmd_domain_attach(efc, domain, fc_id); 491 if (rc) { 492 efc_log_err(efc, "efc_hw_domain_attach failed: %d\n", 493 rc); 494 return; 495 } 496 /* sm: / domain_attach */ 497 efc_sm_transition(ctx, __efc_domain_wait_attach, NULL); 498 break; 499 } 500 501 case EFC_EVT_DOMAIN_FOUND: 502 /* Should not happen */ 503 efc_log_err(efc, "%s: evt: %d should not happen\n", 504 __func__, evt); 505 break; 506 507 case EFC_EVT_DOMAIN_LOST: { 508 efc_log_debug(efc, 509 "%s received while in EFC_EVT_DOMAIN_REQ_ATTACH\n", 510 efc_sm_event_name(evt)); 511 if (!list_empty(&domain->nport_list)) { 512 /* 513 * if there are nports, transition to 514 * wait state and send shutdown to each 515 * nport 516 */ 517 struct efc_nport *nport = NULL, *nport_next = NULL; 518 519 efc_sm_transition(ctx, __efc_domain_wait_nports_free, 520 NULL); 521 list_for_each_entry_safe(nport, nport_next, 522 &domain->nport_list, 523 list_entry) { 524 efc_sm_post_event(&nport->sm, 525 EFC_EVT_SHUTDOWN, NULL); 526 } 527 } else { 528 /* no nports exist, free domain */ 529 efc_sm_transition(ctx, __efc_domain_wait_shutdown, 530 NULL); 531 if (efc_cmd_domain_free(efc, domain)) 532 efc_log_err(efc, "hw_domain_free failed\n"); 533 } 534 535 break; 536 } 537 538 default: 539 __efc_domain_common(__func__, ctx, evt, arg); 540 } 541} 542 543void 544__efc_domain_wait_attach(struct efc_sm_ctx *ctx, 545 enum efc_sm_event evt, void *arg) 546{ 547 std_domain_state_decl(); 548 549 domain_sm_trace(domain); 550 551 switch (evt) { 552 case EFC_EVT_DOMAIN_ATTACH_OK: { 553 struct efc_node *node = NULL; 554 struct efc_nport *nport, *next_nport; 555 unsigned long index; 556 557 /* 558 * Set domain notify pending state to avoid 559 * duplicate domain event post 560 */ 561 domain->domain_notify_pend = true; 562 563 /* Mark as attached */ 564 domain->attached = true; 565 566 /* Transition to ready */ 567 /* sm: / forward event to all nports and nodes */ 568 efc_sm_transition(ctx, __efc_domain_ready, NULL); 569 570 /* We have an FCFI, so we can accept frames */ 571 domain->req_accept_frames = true; 572 573 /* 574 * Notify all nodes that the domain attach request 575 * has completed 576 * Note: nport will have already received notification 577 * of nport attached as a result of the HW's port attach. 578 */ 579 list_for_each_entry_safe(nport, next_nport, 580 &domain->nport_list, list_entry) { 581 xa_for_each(&nport->lookup, index, node) { 582 efc_node_post_event(node, 583 EFC_EVT_DOMAIN_ATTACH_OK, 584 NULL); 585 } 586 } 587 domain->domain_notify_pend = false; 588 break; 589 } 590 591 case EFC_EVT_DOMAIN_ATTACH_FAIL: 592 efc_log_debug(efc, 593 "%s received while waiting for hw attach\n", 594 efc_sm_event_name(evt)); 595 break; 596 597 case EFC_EVT_DOMAIN_FOUND: 598 /* Should not happen */ 599 efc_log_err(efc, "%s: evt: %d should not happen\n", 600 __func__, evt); 601 break; 602 603 case EFC_EVT_DOMAIN_LOST: 604 /* 605 * Domain lost while waiting for an attach to complete, 606 * go to a state that waits for the domain attach to 607 * complete, then handle domain lost 608 */ 609 efc_sm_transition(ctx, __efc_domain_wait_domain_lost, NULL); 610 break; 611 612 case EFC_EVT_DOMAIN_REQ_ATTACH: 613 /* 614 * In P2P we can get an attach request from 615 * the other FLOGI path, so drop this one 616 */ 617 break; 618 619 default: 620 __efc_domain_common(__func__, ctx, evt, arg); 621 } 622} 623 624void 625__efc_domain_ready(struct efc_sm_ctx *ctx, enum efc_sm_event evt, void *arg) 626{ 627 std_domain_state_decl(); 628 629 domain_sm_trace(domain); 630 631 switch (evt) { 632 case EFC_EVT_ENTER: { 633 /* start any pending vports */ 634 if (efc_vport_start(domain)) { 635 efc_log_debug(domain->efc, 636 "efc_vport_start didn't start vports\n"); 637 } 638 break; 639 } 640 case EFC_EVT_DOMAIN_LOST: { 641 if (!list_empty(&domain->nport_list)) { 642 /* 643 * if there are nports, transition to wait state 644 * and send shutdown to each nport 645 */ 646 struct efc_nport *nport = NULL, *nport_next = NULL; 647 648 efc_sm_transition(ctx, __efc_domain_wait_nports_free, 649 NULL); 650 list_for_each_entry_safe(nport, nport_next, 651 &domain->nport_list, 652 list_entry) { 653 efc_sm_post_event(&nport->sm, 654 EFC_EVT_SHUTDOWN, NULL); 655 } 656 } else { 657 /* no nports exist, free domain */ 658 efc_sm_transition(ctx, __efc_domain_wait_shutdown, 659 NULL); 660 if (efc_cmd_domain_free(efc, domain)) 661 efc_log_err(efc, "hw_domain_free failed\n"); 662 } 663 break; 664 } 665 666 case EFC_EVT_DOMAIN_FOUND: 667 /* Should not happen */ 668 efc_log_err(efc, "%s: evt: %d should not happen\n", 669 __func__, evt); 670 break; 671 672 case EFC_EVT_DOMAIN_REQ_ATTACH: { 673 /* can happen during p2p */ 674 u32 fc_id; 675 676 fc_id = *((u32 *)arg); 677 678 /* Assume that the domain is attached */ 679 WARN_ON(!domain->attached); 680 681 /* 682 * Verify that the requested FC_ID 683 * is the same as the one we're working with 684 */ 685 WARN_ON(domain->nport->fc_id != fc_id); 686 break; 687 } 688 689 default: 690 __efc_domain_common(__func__, ctx, evt, arg); 691 } 692} 693 694void 695__efc_domain_wait_nports_free(struct efc_sm_ctx *ctx, enum efc_sm_event evt, 696 void *arg) 697{ 698 std_domain_state_decl(); 699 700 domain_sm_trace(domain); 701 702 /* Wait for nodes to free prior to the domain shutdown */ 703 switch (evt) { 704 case EFC_EVT_ALL_CHILD_NODES_FREE: { 705 int rc; 706 707 /* sm: / efc_hw_domain_free */ 708 efc_sm_transition(ctx, __efc_domain_wait_shutdown, NULL); 709 710 /* Request efc_hw_domain_free and wait for completion */ 711 rc = efc_cmd_domain_free(efc, domain); 712 if (rc) { 713 efc_log_err(efc, "efc_hw_domain_free() failed: %d\n", 714 rc); 715 } 716 break; 717 } 718 default: 719 __efc_domain_common_shutdown(__func__, ctx, evt, arg); 720 } 721} 722 723void 724__efc_domain_wait_shutdown(struct efc_sm_ctx *ctx, 725 enum efc_sm_event evt, void *arg) 726{ 727 std_domain_state_decl(); 728 729 domain_sm_trace(domain); 730 731 switch (evt) { 732 case EFC_EVT_DOMAIN_FREE_OK: 733 /* sm: / domain_free */ 734 if (domain->domain_found_pending) { 735 /* 736 * save fcf_wwn and drec from this domain, 737 * free current domain and allocate 738 * a new one with the same fcf_wwn 739 * could use a SLI-4 "re-register VPI" 740 * operation here? 741 */ 742 u64 fcf_wwn = domain->fcf_wwn; 743 struct efc_domain_record drec = domain->pending_drec; 744 745 efc_log_debug(efc, "Reallocating domain\n"); 746 domain->req_domain_free = true; 747 domain = efc_domain_alloc(efc, fcf_wwn); 748 749 if (!domain) { 750 efc_log_err(efc, 751 "efc_domain_alloc() failed\n"); 752 return; 753 } 754 /* 755 * got a new domain; at this point, 756 * there are at least two domains 757 * once the req_domain_free flag is processed, 758 * the associated domain will be removed. 759 */ 760 efc_sm_transition(&domain->drvsm, __efc_domain_init, 761 NULL); 762 efc_sm_post_event(&domain->drvsm, 763 EFC_EVT_DOMAIN_FOUND, &drec); 764 } else { 765 domain->req_domain_free = true; 766 } 767 break; 768 default: 769 __efc_domain_common_shutdown(__func__, ctx, evt, arg); 770 } 771} 772 773void 774__efc_domain_wait_domain_lost(struct efc_sm_ctx *ctx, 775 enum efc_sm_event evt, void *arg) 776{ 777 std_domain_state_decl(); 778 779 domain_sm_trace(domain); 780 781 /* 782 * Wait for the domain alloc/attach completion 783 * after receiving a domain lost. 784 */ 785 switch (evt) { 786 case EFC_EVT_DOMAIN_ALLOC_OK: 787 case EFC_EVT_DOMAIN_ATTACH_OK: { 788 if (!list_empty(&domain->nport_list)) { 789 /* 790 * if there are nports, transition to 791 * wait state and send shutdown to each nport 792 */ 793 struct efc_nport *nport = NULL, *nport_next = NULL; 794 795 efc_sm_transition(ctx, __efc_domain_wait_nports_free, 796 NULL); 797 list_for_each_entry_safe(nport, nport_next, 798 &domain->nport_list, 799 list_entry) { 800 efc_sm_post_event(&nport->sm, 801 EFC_EVT_SHUTDOWN, NULL); 802 } 803 } else { 804 /* no nports exist, free domain */ 805 efc_sm_transition(ctx, __efc_domain_wait_shutdown, 806 NULL); 807 if (efc_cmd_domain_free(efc, domain)) 808 efc_log_err(efc, "hw_domain_free() failed\n"); 809 } 810 break; 811 } 812 case EFC_EVT_DOMAIN_ALLOC_FAIL: 813 case EFC_EVT_DOMAIN_ATTACH_FAIL: 814 efc_log_err(efc, "[domain] %-20s: failed\n", 815 efc_sm_event_name(evt)); 816 break; 817 818 default: 819 __efc_domain_common_shutdown(__func__, ctx, evt, arg); 820 } 821} 822 823void 824__efc_domain_attach_internal(struct efc_domain *domain, u32 s_id) 825{ 826 memcpy(domain->dma.virt, 827 ((uint8_t *)domain->flogi_service_params) + 4, 828 sizeof(struct fc_els_flogi) - 4); 829 (void)efc_sm_post_event(&domain->drvsm, EFC_EVT_DOMAIN_REQ_ATTACH, 830 &s_id); 831} 832 833void 834efc_domain_attach(struct efc_domain *domain, u32 s_id) 835{ 836 __efc_domain_attach_internal(domain, s_id); 837} 838 839int 840efc_domain_post_event(struct efc_domain *domain, 841 enum efc_sm_event event, void *arg) 842{ 843 int rc; 844 bool req_domain_free; 845 846 rc = efc_sm_post_event(&domain->drvsm, event, arg); 847 848 req_domain_free = domain->req_domain_free; 849 domain->req_domain_free = false; 850 851 if (req_domain_free) 852 efc_domain_free(domain); 853 854 return rc; 855} 856 857static void 858efct_domain_process_pending(struct efc_domain *domain) 859{ 860 struct efc *efc = domain->efc; 861 struct efc_hw_sequence *seq = NULL; 862 u32 processed = 0; 863 unsigned long flags = 0; 864 865 for (;;) { 866 /* need to check for hold frames condition after each frame 867 * processed because any given frame could cause a transition 868 * to a state that holds frames 869 */ 870 if (efc->hold_frames) 871 break; 872 873 /* Get next frame/sequence */ 874 spin_lock_irqsave(&efc->pend_frames_lock, flags); 875 876 if (!list_empty(&efc->pend_frames)) { 877 seq = list_first_entry(&efc->pend_frames, 878 struct efc_hw_sequence, list_entry); 879 list_del(&seq->list_entry); 880 } 881 882 if (!seq) { 883 processed = efc->pend_frames_processed; 884 efc->pend_frames_processed = 0; 885 spin_unlock_irqrestore(&efc->pend_frames_lock, flags); 886 break; 887 } 888 efc->pend_frames_processed++; 889 890 spin_unlock_irqrestore(&efc->pend_frames_lock, flags); 891 892 /* now dispatch frame(s) to dispatch function */ 893 if (efc_domain_dispatch_frame(domain, seq)) 894 efc->tt.hw_seq_free(efc, seq); 895 896 seq = NULL; 897 } 898 899 if (processed != 0) 900 efc_log_debug(efc, "%u domain frames held and processed\n", 901 processed); 902} 903 904void 905efc_dispatch_frame(struct efc *efc, struct efc_hw_sequence *seq) 906{ 907 struct efc_domain *domain = efc->domain; 908 909 /* 910 * If we are holding frames or the domain is not yet registered or 911 * there's already frames on the pending list, 912 * then add the new frame to pending list 913 */ 914 if (!domain || efc->hold_frames || !list_empty(&efc->pend_frames)) { 915 unsigned long flags = 0; 916 917 spin_lock_irqsave(&efc->pend_frames_lock, flags); 918 INIT_LIST_HEAD(&seq->list_entry); 919 list_add_tail(&seq->list_entry, &efc->pend_frames); 920 spin_unlock_irqrestore(&efc->pend_frames_lock, flags); 921 922 if (domain) { 923 /* immediately process pending frames */ 924 efct_domain_process_pending(domain); 925 } 926 } else { 927 /* 928 * We are not holding frames and pending list is empty, 929 * just process frame. A non-zero return means the frame 930 * was not handled - so cleanup 931 */ 932 if (efc_domain_dispatch_frame(domain, seq)) 933 efc->tt.hw_seq_free(efc, seq); 934 } 935} 936 937int 938efc_domain_dispatch_frame(void *arg, struct efc_hw_sequence *seq) 939{ 940 struct efc_domain *domain = (struct efc_domain *)arg; 941 struct efc *efc = domain->efc; 942 struct fc_frame_header *hdr; 943 struct efc_node *node = NULL; 944 struct efc_nport *nport = NULL; 945 unsigned long flags = 0; 946 u32 s_id, d_id, rc = EFC_HW_SEQ_FREE; 947 948 if (!seq->header || !seq->header->dma.virt || !seq->payload->dma.virt) { 949 efc_log_err(efc, "Sequence header or payload is null\n"); 950 return rc; 951 } 952 953 hdr = seq->header->dma.virt; 954 955 /* extract the s_id and d_id */ 956 s_id = ntoh24(hdr->fh_s_id); 957 d_id = ntoh24(hdr->fh_d_id); 958 959 spin_lock_irqsave(&efc->lock, flags); 960 961 nport = efc_nport_find(domain, d_id); 962 if (!nport) { 963 if (hdr->fh_type == FC_TYPE_FCP) { 964 /* Drop frame */ 965 efc_log_warn(efc, "FCP frame with invalid d_id x%x\n", 966 d_id); 967 goto out; 968 } 969 970 /* p2p will use this case */ 971 nport = domain->nport; 972 if (!nport || !kref_get_unless_zero(&nport->ref)) { 973 efc_log_err(efc, "Physical nport is NULL\n"); 974 goto out; 975 } 976 } 977 978 /* Lookup the node given the remote s_id */ 979 node = efc_node_find(nport, s_id); 980 981 /* If not found, then create a new node */ 982 if (!node) { 983 /* 984 * If this is solicited data or control based on R_CTL and 985 * there is no node context, then we can drop the frame 986 */ 987 if ((hdr->fh_r_ctl == FC_RCTL_DD_SOL_DATA) || 988 (hdr->fh_r_ctl == FC_RCTL_DD_SOL_CTL)) { 989 efc_log_debug(efc, "sol data/ctrl frame without node\n"); 990 goto out_release; 991 } 992 993 node = efc_node_alloc(nport, s_id, false, false); 994 if (!node) { 995 efc_log_err(efc, "efc_node_alloc() failed\n"); 996 goto out_release; 997 } 998 /* don't send PLOGI on efc_d_init entry */ 999 efc_node_init_device(node, false); 1000 } 1001 1002 if (node->hold_frames || !list_empty(&node->pend_frames)) { 1003 /* add frame to node's pending list */ 1004 spin_lock(&node->pend_frames_lock); 1005 INIT_LIST_HEAD(&seq->list_entry); 1006 list_add_tail(&seq->list_entry, &node->pend_frames); 1007 spin_unlock(&node->pend_frames_lock); 1008 rc = EFC_HW_SEQ_HOLD; 1009 goto out_release; 1010 } 1011 1012 /* now dispatch frame to the node frame handler */ 1013 efc_node_dispatch_frame(node, seq); 1014 1015out_release: 1016 kref_put(&nport->ref, nport->release); 1017out: 1018 spin_unlock_irqrestore(&efc->lock, flags); 1019 return rc; 1020} 1021 1022void 1023efc_node_dispatch_frame(void *arg, struct efc_hw_sequence *seq) 1024{ 1025 struct fc_frame_header *hdr = seq->header->dma.virt; 1026 u32 port_id; 1027 struct efc_node *node = (struct efc_node *)arg; 1028 struct efc *efc = node->efc; 1029 1030 port_id = ntoh24(hdr->fh_s_id); 1031 1032 if (WARN_ON(port_id != node->rnode.fc_id)) 1033 return; 1034 1035 if ((!(ntoh24(hdr->fh_f_ctl) & FC_FC_END_SEQ)) || 1036 !(ntoh24(hdr->fh_f_ctl) & FC_FC_SEQ_INIT)) { 1037 node_printf(node, 1038 "Drop frame hdr = %08x %08x %08x %08x %08x %08x\n", 1039 cpu_to_be32(((u32 *)hdr)[0]), 1040 cpu_to_be32(((u32 *)hdr)[1]), 1041 cpu_to_be32(((u32 *)hdr)[2]), 1042 cpu_to_be32(((u32 *)hdr)[3]), 1043 cpu_to_be32(((u32 *)hdr)[4]), 1044 cpu_to_be32(((u32 *)hdr)[5])); 1045 return; 1046 } 1047 1048 switch (hdr->fh_r_ctl) { 1049 case FC_RCTL_ELS_REQ: 1050 case FC_RCTL_ELS_REP: 1051 efc_node_recv_els_frame(node, seq); 1052 break; 1053 1054 case FC_RCTL_BA_ABTS: 1055 case FC_RCTL_BA_ACC: 1056 case FC_RCTL_BA_RJT: 1057 case FC_RCTL_BA_NOP: 1058 efc_log_err(efc, "Received ABTS:\n"); 1059 break; 1060 1061 case FC_RCTL_DD_UNSOL_CMD: 1062 case FC_RCTL_DD_UNSOL_CTL: 1063 switch (hdr->fh_type) { 1064 case FC_TYPE_FCP: 1065 if ((hdr->fh_r_ctl & 0xf) == FC_RCTL_DD_UNSOL_CMD) { 1066 if (!node->fcp_enabled) { 1067 efc_node_recv_fcp_cmd(node, seq); 1068 break; 1069 } 1070 efc_log_err(efc, "Recvd FCP CMD. Drop IO\n"); 1071 } else if ((hdr->fh_r_ctl & 0xf) == 1072 FC_RCTL_DD_SOL_DATA) { 1073 node_printf(node, 1074 "solicited data recvd. Drop IO\n"); 1075 } 1076 break; 1077 1078 case FC_TYPE_CT: 1079 efc_node_recv_ct_frame(node, seq); 1080 break; 1081 default: 1082 break; 1083 } 1084 break; 1085 default: 1086 efc_log_err(efc, "Unhandled frame rctl: %02x\n", hdr->fh_r_ctl); 1087 } 1088} 1089