drivers/scsi/elx/libefc/efc_domain.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  * domain_sm Domain State Machine: States
   9  */
  10
  11 #include "efc.h"
  12
  13 int
  14 efc_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
 103 static 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
 115 void
 116 efc_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
 132 struct efc_domain *
 133 efc_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
 158 void
 159 efc_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
 170 static 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
 192 static 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
 229 void
 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
 356 void
 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
 458 void
 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
 543 void
 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
 624 void
 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
 694 void
 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
 723 void
 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
 773 void
 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
 823 void
 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
 833 void
 834 efc_domain_attach(struct efc_domain *domain, u32 s_id)
 835 {
 836         __efc_domain_attach_internal(domain, s_id);
 837 }
 838
 839 int
 840 efc_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
 857 static void
 858 efct_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
 904 void
 905 efc_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
 937 int
 938 efc_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
1015 out_release:
1016         kref_put(&nport->ref, nport->release);
1017 out:
1018         spin_unlock_irqrestore(&efc->lock, flags);
1019         return rc;
1020 }
1021
1022 void
1023 efc_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 }