git.oblomov.eu Git - linux-2.6/blob - drivers/scsi/lpfc/lpfc_els.c

   1 /*******************************************************************
   2  * This file is part of the Emulex Linux Device Driver for         *
   3  * Fibre Channel Host Bus Adapters.                                *
   4  * Copyright (C) 2004-2007 Emulex.  All rights reserved.           *
   5  * EMULEX and SLI are trademarks of Emulex.                        *
   6  * www.emulex.com                                                  *
   7  * Portions Copyright (C) 2004-2005 Christoph Hellwig              *
   8  *                                                                 *
   9  * This program is free software; you can redistribute it and/or   *
  10  * modify it under the terms of version 2 of the GNU General       *
  11  * Public License as published by the Free Software Foundation.    *
  12  * This program is distributed in the hope that it will be useful. *
  13  * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND          *
  14  * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,  *
  15  * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE      *
  16  * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
  17  * TO BE LEGALLY INVALID.  See the GNU General Public License for  *
  18  * more details, a copy of which can be found in the file COPYING  *
  19  * included with this package.                                     *
  20  *******************************************************************/
  21
  22 #include <linux/blkdev.h>
  23 #include <linux/pci.h>
  24 #include <linux/interrupt.h>
  25
  26 #include <scsi/scsi.h>
  27 #include <scsi/scsi_device.h>
  28 #include <scsi/scsi_host.h>
  29 #include <scsi/scsi_transport_fc.h>
  30
  31 #include "lpfc_hw.h"
  32 #include "lpfc_sli.h"
  33 #include "lpfc_disc.h"
  34 #include "lpfc_scsi.h"
  35 #include "lpfc.h"
  36 #include "lpfc_logmsg.h"
  37 #include "lpfc_crtn.h"
  38 #include "lpfc_vport.h"
  39 #include "lpfc_debugfs.h"
  40
  41 static int lpfc_els_retry(struct lpfc_hba *, struct lpfc_iocbq *,
  42                           struct lpfc_iocbq *);
  43 static void lpfc_cmpl_fabric_iocb(struct lpfc_hba *, struct lpfc_iocbq *,
  44                         struct lpfc_iocbq *);
  45
  46 static int lpfc_max_els_tries = 3;
  47
  48 int
  49 lpfc_els_chk_latt(struct lpfc_vport *vport)
  50 {
  51         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
  52         struct lpfc_hba  *phba = vport->phba;
  53         uint32_t ha_copy;
  54
  55         if (vport->port_state >= LPFC_VPORT_READY ||
  56             phba->link_state == LPFC_LINK_DOWN)
  57                 return 0;
  58
  59         /* Read the HBA Host Attention Register */
  60         ha_copy = readl(phba->HAregaddr);
  61
  62         if (!(ha_copy & HA_LATT))
  63                 return 0;
  64
  65         /* Pending Link Event during Discovery */
  66         lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
  67                          "0237 Pending Link Event during "
  68                          "Discovery: State x%x\n",
  69                          phba->pport->port_state);
  70
  71         /* CLEAR_LA should re-enable link attention events and
  72          * we should then imediately take a LATT event. The
  73          * LATT processing should call lpfc_linkdown() which
  74          * will cleanup any left over in-progress discovery
  75          * events.
  76          */
  77         spin_lock_irq(shost->host_lock);
  78         vport->fc_flag |= FC_ABORT_DISCOVERY;
  79         spin_unlock_irq(shost->host_lock);
  80
  81         if (phba->link_state != LPFC_CLEAR_LA)
  82                 lpfc_issue_clear_la(phba, vport);
  83
  84         return 1;
  85 }
  86
  87 static struct lpfc_iocbq *
  88 lpfc_prep_els_iocb(struct lpfc_vport *vport, uint8_t expectRsp,
  89                    uint16_t cmdSize, uint8_t retry,
  90                    struct lpfc_nodelist *ndlp, uint32_t did,
  91                    uint32_t elscmd)
  92 {
  93         struct lpfc_hba  *phba = vport->phba;
  94         struct lpfc_iocbq *elsiocb;
  95         struct lpfc_dmabuf *pcmd, *prsp, *pbuflist;
  96         struct ulp_bde64 *bpl;
  97         IOCB_t *icmd;
  98
  99
 100         if (!lpfc_is_link_up(phba))
 101                 return NULL;
 102
 103         /* Allocate buffer for  command iocb */
 104         elsiocb = lpfc_sli_get_iocbq(phba);
 105
 106         if (elsiocb == NULL)
 107                 return NULL;
 108         icmd = &elsiocb->iocb;
 109
 110         /* fill in BDEs for command */
 111         /* Allocate buffer for command payload */
 112         if (((pcmd = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL)) == 0) ||
 113             ((pcmd->virt = lpfc_mbuf_alloc(phba,
 114                                            MEM_PRI, &(pcmd->phys))) == 0)) {
 115                 kfree(pcmd);
 116
 117                 lpfc_sli_release_iocbq(phba, elsiocb);
 118                 return NULL;
 119         }
 120
 121         INIT_LIST_HEAD(&pcmd->list);
 122
 123         /* Allocate buffer for response payload */
 124         if (expectRsp) {
 125                 prsp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
 126                 if (prsp)
 127                         prsp->virt = lpfc_mbuf_alloc(phba, MEM_PRI,
 128                                                      &prsp->phys);
 129                 if (prsp == 0 || prsp->virt == 0) {
 130                         kfree(prsp);
 131                         lpfc_mbuf_free(phba, pcmd->virt, pcmd->phys);
 132                         kfree(pcmd);
 133                         lpfc_sli_release_iocbq(phba, elsiocb);
 134                         return NULL;
 135                 }
 136                 INIT_LIST_HEAD(&prsp->list);
 137         } else {
 138                 prsp = NULL;
 139         }
 140
 141         /* Allocate buffer for Buffer ptr list */
 142         pbuflist = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
 143         if (pbuflist)
 144                 pbuflist->virt = lpfc_mbuf_alloc(phba, MEM_PRI,
 145                                                  &pbuflist->phys);
 146         if (pbuflist == 0 || pbuflist->virt == 0) {
 147                 lpfc_sli_release_iocbq(phba, elsiocb);
 148                 lpfc_mbuf_free(phba, pcmd->virt, pcmd->phys);
 149                 lpfc_mbuf_free(phba, prsp->virt, prsp->phys);
 150                 kfree(pcmd);
 151                 kfree(prsp);
 152                 kfree(pbuflist);
 153                 return NULL;
 154         }
 155
 156         INIT_LIST_HEAD(&pbuflist->list);
 157
 158         icmd->un.elsreq64.bdl.addrHigh = putPaddrHigh(pbuflist->phys);
 159         icmd->un.elsreq64.bdl.addrLow = putPaddrLow(pbuflist->phys);
 160         icmd->un.elsreq64.bdl.bdeFlags = BUFF_TYPE_BDL;
 161         icmd->un.elsreq64.remoteID = did;       /* DID */
 162         if (expectRsp) {
 163                 icmd->un.elsreq64.bdl.bdeSize = (2 * sizeof(struct ulp_bde64));
 164                 icmd->ulpCommand = CMD_ELS_REQUEST64_CR;
 165                 icmd->ulpTimeout = phba->fc_ratov * 2;
 166         } else {
 167                 icmd->un.elsreq64.bdl.bdeSize = sizeof(struct ulp_bde64);
 168                 icmd->ulpCommand = CMD_XMIT_ELS_RSP64_CX;
 169         }
 170         icmd->ulpBdeCount = 1;
 171         icmd->ulpLe = 1;
 172         icmd->ulpClass = CLASS3;
 173
 174         if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) {
 175                 icmd->un.elsreq64.myID = vport->fc_myDID;
 176
 177                 /* For ELS_REQUEST64_CR, use the VPI by default */
 178                 icmd->ulpContext = vport->vpi;
 179                 icmd->ulpCt_h = 0;
 180                 icmd->ulpCt_l = 1;
 181         }
 182
 183         bpl = (struct ulp_bde64 *) pbuflist->virt;
 184         bpl->addrLow = le32_to_cpu(putPaddrLow(pcmd->phys));
 185         bpl->addrHigh = le32_to_cpu(putPaddrHigh(pcmd->phys));
 186         bpl->tus.f.bdeSize = cmdSize;
 187         bpl->tus.f.bdeFlags = 0;
 188         bpl->tus.w = le32_to_cpu(bpl->tus.w);
 189
 190         if (expectRsp) {
 191                 bpl++;
 192                 bpl->addrLow = le32_to_cpu(putPaddrLow(prsp->phys));
 193                 bpl->addrHigh = le32_to_cpu(putPaddrHigh(prsp->phys));
 194                 bpl->tus.f.bdeSize = FCELSSIZE;
 195                 bpl->tus.f.bdeFlags = BUFF_USE_RCV;
 196                 bpl->tus.w = le32_to_cpu(bpl->tus.w);
 197         }
 198
 199         elsiocb->context1 = lpfc_nlp_get(ndlp);
 200         elsiocb->context2 = pcmd;
 201         elsiocb->context3 = pbuflist;
 202         elsiocb->retry = retry;
 203         elsiocb->vport = vport;
 204         elsiocb->drvrTimeout = (phba->fc_ratov << 1) + LPFC_DRVR_TIMEOUT;
 205
 206         if (prsp) {
 207                 list_add(&prsp->list, &pcmd->list);
 208         }
 209         if (expectRsp) {
 210                 /* Xmit ELS command <elsCmd> to remote NPORT <did> */
 211                 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
 212                                  "0116 Xmit ELS command x%x to remote "
 213                                  "NPORT x%x I/O tag: x%x, port state: x%x\n",
 214                                  elscmd, did, elsiocb->iotag,
 215                                  vport->port_state);
 216         } else {
 217                 /* Xmit ELS response <elsCmd> to remote NPORT <did> */
 218                 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
 219                                  "0117 Xmit ELS response x%x to remote "
 220                                  "NPORT x%x I/O tag: x%x, size: x%x\n",
 221                                  elscmd, ndlp->nlp_DID, elsiocb->iotag,
 222                                  cmdSize);
 223         }
 224         return elsiocb;
 225 }
 226
 227
 228 static int
 229 lpfc_issue_fabric_reglogin(struct lpfc_vport *vport)
 230 {
 231         struct lpfc_hba  *phba = vport->phba;
 232         LPFC_MBOXQ_t *mbox;
 233         struct lpfc_dmabuf *mp;
 234         struct lpfc_nodelist *ndlp;
 235         struct serv_parm *sp;
 236         int rc;
 237
 238         sp = &phba->fc_fabparam;
 239         ndlp = lpfc_findnode_did(vport, Fabric_DID);
 240         if (!ndlp)
 241                 goto fail;
 242
 243         mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 244         if (!mbox)
 245                 goto fail;
 246
 247         vport->port_state = LPFC_FABRIC_CFG_LINK;
 248         lpfc_config_link(phba, mbox);
 249         mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
 250         mbox->vport = vport;
 251
 252         rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT | MBX_STOP_IOCB);
 253         if (rc == MBX_NOT_FINISHED)
 254                 goto fail_free_mbox;
 255
 256         mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 257         if (!mbox)
 258                 goto fail;
 259         rc = lpfc_reg_login(phba, vport->vpi, Fabric_DID, (uint8_t *)sp, mbox,
 260                             0);
 261         if (rc)
 262                 goto fail_free_mbox;
 263
 264         mbox->mbox_cmpl = lpfc_mbx_cmpl_fabric_reg_login;
 265         mbox->vport = vport;
 266         mbox->context2 = lpfc_nlp_get(ndlp);
 267
 268         rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT | MBX_STOP_IOCB);
 269         if (rc == MBX_NOT_FINISHED)
 270                 goto fail_issue_reg_login;
 271
 272         return 0;
 273
 274 fail_issue_reg_login:
 275         lpfc_nlp_put(ndlp);
 276         mp = (struct lpfc_dmabuf *) mbox->context1;
 277         lpfc_mbuf_free(phba, mp->virt, mp->phys);
 278         kfree(mp);
 279 fail_free_mbox:
 280         mempool_free(mbox, phba->mbox_mem_pool);
 281
 282 fail:
 283         lpfc_vport_set_state(vport, FC_VPORT_FAILED);
 284         lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
 285                 "0249 Cannot issue Register Fabric login\n");
 286         return -ENXIO;
 287 }
 288
 289 static int
 290 lpfc_cmpl_els_flogi_fabric(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
 291                            struct serv_parm *sp, IOCB_t *irsp)
 292 {
 293         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
 294         struct lpfc_hba  *phba = vport->phba;
 295         struct lpfc_nodelist *np;
 296         struct lpfc_nodelist *next_np;
 297
 298         spin_lock_irq(shost->host_lock);
 299         vport->fc_flag |= FC_FABRIC;
 300         spin_unlock_irq(shost->host_lock);
 301
 302         phba->fc_edtov = be32_to_cpu(sp->cmn.e_d_tov);
 303         if (sp->cmn.edtovResolution)    /* E_D_TOV ticks are in nanoseconds */
 304                 phba->fc_edtov = (phba->fc_edtov + 999999) / 1000000;
 305
 306         phba->fc_ratov = (be32_to_cpu(sp->cmn.w2.r_a_tov) + 999) / 1000;
 307
 308         if (phba->fc_topology == TOPOLOGY_LOOP) {
 309                 spin_lock_irq(shost->host_lock);
 310                 vport->fc_flag |= FC_PUBLIC_LOOP;
 311                 spin_unlock_irq(shost->host_lock);
 312         } else {
 313                 /*
 314                  * If we are a N-port connected to a Fabric, fixup sparam's so
 315                  * logins to devices on remote loops work.
 316                  */
 317                 vport->fc_sparam.cmn.altBbCredit = 1;
 318         }
 319
 320         vport->fc_myDID = irsp->un.ulpWord[4] & Mask_DID;
 321         memcpy(&ndlp->nlp_portname, &sp->portName, sizeof(struct lpfc_name));
 322         memcpy(&ndlp->nlp_nodename, &sp->nodeName, sizeof(struct lpfc_name));
 323         ndlp->nlp_class_sup = 0;
 324         if (sp->cls1.classValid)
 325                 ndlp->nlp_class_sup |= FC_COS_CLASS1;
 326         if (sp->cls2.classValid)
 327                 ndlp->nlp_class_sup |= FC_COS_CLASS2;
 328         if (sp->cls3.classValid)
 329                 ndlp->nlp_class_sup |= FC_COS_CLASS3;
 330         if (sp->cls4.classValid)
 331                 ndlp->nlp_class_sup |= FC_COS_CLASS4;
 332         ndlp->nlp_maxframe = ((sp->cmn.bbRcvSizeMsb & 0x0F) << 8) |
 333                                 sp->cmn.bbRcvSizeLsb;
 334         memcpy(&phba->fc_fabparam, sp, sizeof(struct serv_parm));
 335
 336         if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) {
 337                 if (sp->cmn.response_multiple_NPort) {
 338                         lpfc_printf_vlog(vport, KERN_WARNING,
 339                                          LOG_ELS | LOG_VPORT,
 340                                          "1816 FLOGI NPIV supported, "
 341                                          "response data 0x%x\n",
 342                                          sp->cmn.response_multiple_NPort);
 343                         phba->link_flag |= LS_NPIV_FAB_SUPPORTED;
 344                 } else {
 345                         /* Because we asked f/w for NPIV it still expects us
 346                         to call reg_vnpid atleast for the physcial host */
 347                         lpfc_printf_vlog(vport, KERN_WARNING,
 348                                          LOG_ELS | LOG_VPORT,
 349                                          "1817 Fabric does not support NPIV "
 350                                          "- configuring single port mode.\n");
 351                         phba->link_flag &= ~LS_NPIV_FAB_SUPPORTED;
 352                 }
 353         }
 354
 355         if ((vport->fc_prevDID != vport->fc_myDID) &&
 356                 !(vport->fc_flag & FC_VPORT_NEEDS_REG_VPI)) {
 357
 358                 /* If our NportID changed, we need to ensure all
 359                  * remaining NPORTs get unreg_login'ed.
 360                  */
 361                 list_for_each_entry_safe(np, next_np,
 362                                         &vport->fc_nodes, nlp_listp) {
 363                         if ((np->nlp_state != NLP_STE_NPR_NODE) ||
 364                                    !(np->nlp_flag & NLP_NPR_ADISC))
 365                                 continue;
 366                         spin_lock_irq(shost->host_lock);
 367                         np->nlp_flag &= ~NLP_NPR_ADISC;
 368                         spin_unlock_irq(shost->host_lock);
 369                         lpfc_unreg_rpi(vport, np);
 370                 }
 371                 if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) {
 372                         lpfc_mbx_unreg_vpi(vport);
 373                         vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
 374                 }
 375         }
 376
 377         ndlp->nlp_sid = irsp->un.ulpWord[4] & Mask_DID;
 378         lpfc_nlp_set_state(vport, ndlp, NLP_STE_REG_LOGIN_ISSUE);
 379
 380         if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED &&
 381             vport->fc_flag & FC_VPORT_NEEDS_REG_VPI) {
 382                 lpfc_register_new_vport(phba, vport, ndlp);
 383                 return 0;
 384         }
 385         lpfc_issue_fabric_reglogin(vport);
 386         return 0;
 387 }
 388
 389 /*
 390  * We FLOGIed into an NPort, initiate pt2pt protocol
 391  */
 392 static int
 393 lpfc_cmpl_els_flogi_nport(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
 394                           struct serv_parm *sp)
 395 {
 396         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
 397         struct lpfc_hba  *phba = vport->phba;
 398         LPFC_MBOXQ_t *mbox;
 399         int rc;
 400
 401         spin_lock_irq(shost->host_lock);
 402         vport->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP);
 403         spin_unlock_irq(shost->host_lock);
 404
 405         phba->fc_edtov = FF_DEF_EDTOV;
 406         phba->fc_ratov = FF_DEF_RATOV;
 407         rc = memcmp(&vport->fc_portname, &sp->portName,
 408                     sizeof(vport->fc_portname));
 409         if (rc >= 0) {
 410                 /* This side will initiate the PLOGI */
 411                 spin_lock_irq(shost->host_lock);
 412                 vport->fc_flag |= FC_PT2PT_PLOGI;
 413                 spin_unlock_irq(shost->host_lock);
 414
 415                 /*
 416                  * N_Port ID cannot be 0, set our to LocalID the other
 417                  * side will be RemoteID.
 418                  */
 419
 420                 /* not equal */
 421                 if (rc)
 422                         vport->fc_myDID = PT2PT_LocalID;
 423
 424                 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 425                 if (!mbox)
 426                         goto fail;
 427
 428                 lpfc_config_link(phba, mbox);
 429
 430                 mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
 431                 mbox->vport = vport;
 432                 rc = lpfc_sli_issue_mbox(phba, mbox,
 433                                          MBX_NOWAIT | MBX_STOP_IOCB);
 434                 if (rc == MBX_NOT_FINISHED) {
 435                         mempool_free(mbox, phba->mbox_mem_pool);
 436                         goto fail;
 437                 }
 438                 lpfc_nlp_put(ndlp);
 439
 440                 ndlp = lpfc_findnode_did(vport, PT2PT_RemoteID);
 441                 if (!ndlp) {
 442                         /*
 443                          * Cannot find existing Fabric ndlp, so allocate a
 444                          * new one
 445                          */
 446                         ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
 447                         if (!ndlp)
 448                                 goto fail;
 449
 450                         lpfc_nlp_init(vport, ndlp, PT2PT_RemoteID);
 451                 }
 452
 453                 memcpy(&ndlp->nlp_portname, &sp->portName,
 454                        sizeof(struct lpfc_name));
 455                 memcpy(&ndlp->nlp_nodename, &sp->nodeName,
 456                        sizeof(struct lpfc_name));
 457                 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
 458                 spin_lock_irq(shost->host_lock);
 459                 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
 460                 spin_unlock_irq(shost->host_lock);
 461         } else {
 462                 /* This side will wait for the PLOGI */
 463                 lpfc_nlp_put(ndlp);
 464         }
 465
 466         spin_lock_irq(shost->host_lock);
 467         vport->fc_flag |= FC_PT2PT;
 468         spin_unlock_irq(shost->host_lock);
 469
 470         /* Start discovery - this should just do CLEAR_LA */
 471         lpfc_disc_start(vport);
 472         return 0;
 473 fail:
 474         return -ENXIO;
 475 }
 476
 477 static void
 478 lpfc_cmpl_els_flogi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
 479                     struct lpfc_iocbq *rspiocb)
 480 {
 481         struct lpfc_vport *vport = cmdiocb->vport;
 482         struct Scsi_Host  *shost = lpfc_shost_from_vport(vport);
 483         IOCB_t *irsp = &rspiocb->iocb;
 484         struct lpfc_nodelist *ndlp = cmdiocb->context1;
 485         struct lpfc_dmabuf *pcmd = cmdiocb->context2, *prsp;
 486         struct serv_parm *sp;
 487         int rc;
 488
 489         /* Check to see if link went down during discovery */
 490         if (lpfc_els_chk_latt(vport)) {
 491                 lpfc_nlp_put(ndlp);
 492                 goto out;
 493         }
 494
 495         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
 496                 "FLOGI cmpl:      status:x%x/x%x state:x%x",
 497                 irsp->ulpStatus, irsp->un.ulpWord[4],
 498                 vport->port_state);
 499
 500         if (irsp->ulpStatus) {
 501                 /* Check for retry */
 502                 if (lpfc_els_retry(phba, cmdiocb, rspiocb))
 503                         goto out;
 504
 505                 /* FLOGI failed, so there is no fabric */
 506                 spin_lock_irq(shost->host_lock);
 507                 vport->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP);
 508                 spin_unlock_irq(shost->host_lock);
 509
 510                 /* If private loop, then allow max outstanding els to be
 511                  * LPFC_MAX_DISC_THREADS (32). Scanning in the case of no
 512                  * alpa map would take too long otherwise.
 513                  */
 514                 if (phba->alpa_map[0] == 0) {
 515                         vport->cfg_discovery_threads = LPFC_MAX_DISC_THREADS;
 516                 }
 517
 518                 /* FLOGI failure */
 519                 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
 520                                  "0100 FLOGI failure Data: x%x x%x "
 521                                  "x%x\n",
 522                                  irsp->ulpStatus, irsp->un.ulpWord[4],
 523                                  irsp->ulpTimeout);
 524                 goto flogifail;
 525         }
 526
 527         /*
 528          * The FLogI succeeded.  Sync the data for the CPU before
 529          * accessing it.
 530          */
 531         prsp = list_get_first(&pcmd->list, struct lpfc_dmabuf, list);
 532
 533         sp = prsp->virt + sizeof(uint32_t);
 534
 535         /* FLOGI completes successfully */
 536         lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
 537                          "0101 FLOGI completes sucessfully "
 538                          "Data: x%x x%x x%x x%x\n",
 539                          irsp->un.ulpWord[4], sp->cmn.e_d_tov,
 540                          sp->cmn.w2.r_a_tov, sp->cmn.edtovResolution);
 541
 542         if (vport->port_state == LPFC_FLOGI) {
 543                 /*
 544                  * If Common Service Parameters indicate Nport
 545                  * we are point to point, if Fport we are Fabric.
 546                  */
 547                 if (sp->cmn.fPort)
 548                         rc = lpfc_cmpl_els_flogi_fabric(vport, ndlp, sp, irsp);
 549                 else
 550                         rc = lpfc_cmpl_els_flogi_nport(vport, ndlp, sp);
 551
 552                 if (!rc)
 553                         goto out;
 554         }
 555
 556 flogifail:
 557         lpfc_nlp_put(ndlp);
 558
 559         if (!lpfc_error_lost_link(irsp)) {
 560                 /* FLOGI failed, so just use loop map to make discovery list */
 561                 lpfc_disc_list_loopmap(vport);
 562
 563                 /* Start discovery */
 564                 lpfc_disc_start(vport);
 565         }
 566
 567 out:
 568         lpfc_els_free_iocb(phba, cmdiocb);
 569 }
 570
 571 static int
 572 lpfc_issue_els_flogi(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
 573                      uint8_t retry)
 574 {
 575         struct lpfc_hba  *phba = vport->phba;
 576         struct serv_parm *sp;
 577         IOCB_t *icmd;
 578         struct lpfc_iocbq *elsiocb;
 579         struct lpfc_sli_ring *pring;
 580         uint8_t *pcmd;
 581         uint16_t cmdsize;
 582         uint32_t tmo;
 583         int rc;
 584
 585         pring = &phba->sli.ring[LPFC_ELS_RING];
 586
 587         cmdsize = (sizeof(uint32_t) + sizeof(struct serv_parm));
 588         elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, ndlp,
 589                                      ndlp->nlp_DID, ELS_CMD_FLOGI);
 590
 591         if (!elsiocb)
 592                 return 1;
 593
 594         icmd = &elsiocb->iocb;
 595         pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
 596
 597         /* For FLOGI request, remainder of payload is service parameters */
 598         *((uint32_t *) (pcmd)) = ELS_CMD_FLOGI;
 599         pcmd += sizeof(uint32_t);
 600         memcpy(pcmd, &vport->fc_sparam, sizeof(struct serv_parm));
 601         sp = (struct serv_parm *) pcmd;
 602
 603         /* Setup CSPs accordingly for Fabric */
 604         sp->cmn.e_d_tov = 0;
 605         sp->cmn.w2.r_a_tov = 0;
 606         sp->cls1.classValid = 0;
 607         sp->cls2.seqDelivery = 1;
 608         sp->cls3.seqDelivery = 1;
 609         if (sp->cmn.fcphLow < FC_PH3)
 610                 sp->cmn.fcphLow = FC_PH3;
 611         if (sp->cmn.fcphHigh < FC_PH3)
 612                 sp->cmn.fcphHigh = FC_PH3;
 613
 614         if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) {
 615                 sp->cmn.request_multiple_Nport = 1;
 616
 617                 /* For FLOGI, Let FLOGI rsp set the NPortID for VPI 0 */
 618                 icmd->ulpCt_h = 1;
 619                 icmd->ulpCt_l = 0;
 620         }
 621
 622         if (phba->fc_topology != TOPOLOGY_LOOP) {
 623                 icmd->un.elsreq64.myID = 0;
 624                 icmd->un.elsreq64.fl = 1;
 625         }
 626
 627         tmo = phba->fc_ratov;
 628         phba->fc_ratov = LPFC_DISC_FLOGI_TMO;
 629         lpfc_set_disctmo(vport);
 630         phba->fc_ratov = tmo;
 631
 632         phba->fc_stat.elsXmitFLOGI++;
 633         elsiocb->iocb_cmpl = lpfc_cmpl_els_flogi;
 634
 635         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
 636                 "Issue FLOGI:     opt:x%x",
 637                 phba->sli3_options, 0, 0);
 638
 639         rc = lpfc_issue_fabric_iocb(phba, elsiocb);
 640         if (rc == IOCB_ERROR) {
 641                 lpfc_els_free_iocb(phba, elsiocb);
 642                 return 1;
 643         }
 644         return 0;
 645 }
 646
 647 int
 648 lpfc_els_abort_flogi(struct lpfc_hba *phba)
 649 {
 650         struct lpfc_sli_ring *pring;
 651         struct lpfc_iocbq *iocb, *next_iocb;
 652         struct lpfc_nodelist *ndlp;
 653         IOCB_t *icmd;
 654
 655         /* Abort outstanding I/O on NPort <nlp_DID> */
 656         lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
 657                         "0201 Abort outstanding I/O on NPort x%x\n",
 658                         Fabric_DID);
 659
 660         pring = &phba->sli.ring[LPFC_ELS_RING];
 661
 662         /*
 663          * Check the txcmplq for an iocb that matches the nport the driver is
 664          * searching for.
 665          */
 666         spin_lock_irq(&phba->hbalock);
 667         list_for_each_entry_safe(iocb, next_iocb, &pring->txcmplq, list) {
 668                 icmd = &iocb->iocb;
 669                 if (icmd->ulpCommand == CMD_ELS_REQUEST64_CR &&
 670                     icmd->un.elsreq64.bdl.ulpIoTag32) {
 671                         ndlp = (struct lpfc_nodelist *)(iocb->context1);
 672                         if (ndlp && (ndlp->nlp_DID == Fabric_DID)) {
 673                                 lpfc_sli_issue_abort_iotag(phba, pring, iocb);
 674                         }
 675                 }
 676         }
 677         spin_unlock_irq(&phba->hbalock);
 678
 679         return 0;
 680 }
 681
 682 int
 683 lpfc_initial_flogi(struct lpfc_vport *vport)
 684 {
 685         struct lpfc_hba *phba = vport->phba;
 686         struct lpfc_nodelist *ndlp;
 687
 688         /* First look for the Fabric ndlp */
 689         ndlp = lpfc_findnode_did(vport, Fabric_DID);
 690         if (!ndlp) {
 691                 /* Cannot find existing Fabric ndlp, so allocate a new one */
 692                 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
 693                 if (!ndlp)
 694                         return 0;
 695                 lpfc_nlp_init(vport, ndlp, Fabric_DID);
 696         } else {
 697                 lpfc_dequeue_node(vport, ndlp);
 698         }
 699         if (lpfc_issue_els_flogi(vport, ndlp, 0)) {
 700                 lpfc_nlp_put(ndlp);
 701         }
 702         return 1;
 703 }
 704
 705 int
 706 lpfc_initial_fdisc(struct lpfc_vport *vport)
 707 {
 708         struct lpfc_hba *phba = vport->phba;
 709         struct lpfc_nodelist *ndlp;
 710
 711         /* First look for the Fabric ndlp */
 712         ndlp = lpfc_findnode_did(vport, Fabric_DID);
 713         if (!ndlp) {
 714                 /* Cannot find existing Fabric ndlp, so allocate a new one */
 715                 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
 716                 if (!ndlp)
 717                         return 0;
 718                 lpfc_nlp_init(vport, ndlp, Fabric_DID);
 719         } else {
 720                 lpfc_dequeue_node(vport, ndlp);
 721         }
 722         if (lpfc_issue_els_fdisc(vport, ndlp, 0)) {
 723                 lpfc_nlp_put(ndlp);
 724         }
 725         return 1;
 726 }
 727 static void
 728 lpfc_more_plogi(struct lpfc_vport *vport)
 729 {
 730         int sentplogi;
 731
 732         if (vport->num_disc_nodes)
 733                 vport->num_disc_nodes--;
 734
 735         /* Continue discovery with <num_disc_nodes> PLOGIs to go */
 736         lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
 737                          "0232 Continue discovery with %d PLOGIs to go "
 738                          "Data: x%x x%x x%x\n",
 739                          vport->num_disc_nodes, vport->fc_plogi_cnt,
 740                          vport->fc_flag, vport->port_state);
 741         /* Check to see if there are more PLOGIs to be sent */
 742         if (vport->fc_flag & FC_NLP_MORE)
 743                 /* go thru NPR nodes and issue any remaining ELS PLOGIs */
 744                 sentplogi = lpfc_els_disc_plogi(vport);
 745
 746         return;
 747 }
 748
 749 static struct lpfc_nodelist *
 750 lpfc_plogi_confirm_nport(struct lpfc_hba *phba, uint32_t *prsp,
 751                          struct lpfc_nodelist *ndlp)
 752 {
 753         struct lpfc_vport    *vport = ndlp->vport;
 754         struct lpfc_nodelist *new_ndlp;
 755         struct serv_parm *sp;
 756         uint8_t  name[sizeof(struct lpfc_name)];
 757         uint32_t rc;
 758
 759         /* Fabric nodes can have the same WWPN so we don't bother searching
 760          * by WWPN.  Just return the ndlp that was given to us.
 761          */
 762         if (ndlp->nlp_type & NLP_FABRIC)
 763                 return ndlp;
 764
 765         sp = (struct serv_parm *) ((uint8_t *) prsp + sizeof(uint32_t));
 766         memset(name, 0, sizeof(struct lpfc_name));
 767
 768         /* Now we find out if the NPort we are logging into, matches the WWPN
 769          * we have for that ndlp. If not, we have some work to do.
 770          */
 771         new_ndlp = lpfc_findnode_wwpn(vport, &sp->portName);
 772
 773         if (new_ndlp == ndlp)
 774                 return ndlp;
 775
 776         if (!new_ndlp) {
 777                 rc = memcmp(&ndlp->nlp_portname, name,
 778                             sizeof(struct lpfc_name));
 779                 if (!rc)
 780                         return ndlp;
 781                 new_ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_ATOMIC);
 782                 if (!new_ndlp)
 783                         return ndlp;
 784
 785                 lpfc_nlp_init(vport, new_ndlp, ndlp->nlp_DID);
 786         }
 787
 788         lpfc_unreg_rpi(vport, new_ndlp);
 789         new_ndlp->nlp_DID = ndlp->nlp_DID;
 790         new_ndlp->nlp_prev_state = ndlp->nlp_prev_state;
 791         lpfc_nlp_set_state(vport, new_ndlp, ndlp->nlp_state);
 792
 793         /* Move this back to NPR state */
 794         if (memcmp(&ndlp->nlp_portname, name, sizeof(struct lpfc_name)) == 0)
 795                 lpfc_drop_node(vport, ndlp);
 796         else {
 797                 lpfc_unreg_rpi(vport, ndlp);
 798                 ndlp->nlp_DID = 0; /* Two ndlps cannot have the same did */
 799                 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
 800         }
 801         return new_ndlp;
 802 }
 803
 804 static void
 805 lpfc_cmpl_els_plogi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
 806                     struct lpfc_iocbq *rspiocb)
 807 {
 808         struct lpfc_vport *vport = cmdiocb->vport;
 809         struct Scsi_Host  *shost = lpfc_shost_from_vport(vport);
 810         IOCB_t *irsp;
 811         struct lpfc_nodelist *ndlp;
 812         struct lpfc_dmabuf *prsp;
 813         int disc, rc, did, type;
 814
 815         /* we pass cmdiocb to state machine which needs rspiocb as well */
 816         cmdiocb->context_un.rsp_iocb = rspiocb;
 817
 818         irsp = &rspiocb->iocb;
 819         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
 820                 "PLOGI cmpl:      status:x%x/x%x did:x%x",
 821                 irsp->ulpStatus, irsp->un.ulpWord[4],
 822                 irsp->un.elsreq64.remoteID);
 823
 824         ndlp = lpfc_findnode_did(vport, irsp->un.elsreq64.remoteID);
 825         if (!ndlp) {
 826                 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
 827                                  "0136 PLOGI completes to NPort x%x "
 828                                  "with no ndlp. Data: x%x x%x x%x\n",
 829                                  irsp->un.elsreq64.remoteID,
 830                                  irsp->ulpStatus, irsp->un.ulpWord[4],
 831                                  irsp->ulpIoTag);
 832                 goto out;
 833         }
 834
 835         /* Since ndlp can be freed in the disc state machine, note if this node
 836          * is being used during discovery.
 837          */
 838         spin_lock_irq(shost->host_lock);
 839         disc = (ndlp->nlp_flag & NLP_NPR_2B_DISC);
 840         ndlp->nlp_flag &= ~NLP_NPR_2B_DISC;
 841         spin_unlock_irq(shost->host_lock);
 842         rc   = 0;
 843
 844         /* PLOGI completes to NPort <nlp_DID> */
 845         lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
 846                          "0102 PLOGI completes to NPort x%x "
 847                          "Data: x%x x%x x%x x%x x%x\n",
 848                          ndlp->nlp_DID, irsp->ulpStatus, irsp->un.ulpWord[4],
 849                          irsp->ulpTimeout, disc, vport->num_disc_nodes);
 850         /* Check to see if link went down during discovery */
 851         if (lpfc_els_chk_latt(vport)) {
 852                 spin_lock_irq(shost->host_lock);
 853                 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
 854                 spin_unlock_irq(shost->host_lock);
 855                 goto out;
 856         }
 857
 858         /* ndlp could be freed in DSM, save these values now */
 859         type = ndlp->nlp_type;
 860         did = ndlp->nlp_DID;
 861
 862         if (irsp->ulpStatus) {
 863                 /* Check for retry */
 864                 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
 865                         /* ELS command is being retried */
 866                         if (disc) {
 867                                 spin_lock_irq(shost->host_lock);
 868                                 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
 869                                 spin_unlock_irq(shost->host_lock);
 870                         }
 871                         goto out;
 872                 }
 873                 /* PLOGI failed */
 874                 if (ndlp->nlp_DID == NameServer_DID) {
 875                         lpfc_vport_set_state(vport, FC_VPORT_FAILED);
 876                         lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
 877                                          "0250 Nameserver login error: "
 878                                          "0x%x / 0x%x\n",
 879                                          irsp->ulpStatus, irsp->un.ulpWord[4]);
 880                 }
 881                 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
 882                 if (lpfc_error_lost_link(irsp)) {
 883                         rc = NLP_STE_FREED_NODE;
 884                 } else {
 885                         rc = lpfc_disc_state_machine(vport, ndlp, cmdiocb,
 886                                                      NLP_EVT_CMPL_PLOGI);
 887                 }
 888         } else {
 889                 /* Good status, call state machine */
 890                 prsp = list_entry(((struct lpfc_dmabuf *)
 891                                    cmdiocb->context2)->list.next,
 892                                   struct lpfc_dmabuf, list);
 893                 ndlp = lpfc_plogi_confirm_nport(phba, prsp->virt, ndlp);
 894                 rc = lpfc_disc_state_machine(vport, ndlp, cmdiocb,
 895                                              NLP_EVT_CMPL_PLOGI);
 896         }
 897
 898         if (disc && vport->num_disc_nodes) {
 899                 /* Check to see if there are more PLOGIs to be sent */
 900                 lpfc_more_plogi(vport);
 901
 902                 if (vport->num_disc_nodes == 0) {
 903                         spin_lock_irq(shost->host_lock);
 904                         vport->fc_flag &= ~FC_NDISC_ACTIVE;
 905                         spin_unlock_irq(shost->host_lock);
 906
 907                         lpfc_can_disctmo(vport);
 908                         if (vport->fc_flag & FC_RSCN_MODE) {
 909                                 /*
 910                                  * Check to see if more RSCNs came in while
 911                                  * we were processing this one.
 912                                  */
 913                                 if ((vport->fc_rscn_id_cnt == 0) &&
 914                                     (!(vport->fc_flag & FC_RSCN_DISCOVERY))) {
 915                                         spin_lock_irq(shost->host_lock);
 916                                         vport->fc_flag &= ~FC_RSCN_MODE;
 917                                         spin_unlock_irq(shost->host_lock);
 918                                 } else {
 919                                         lpfc_els_handle_rscn(vport);
 920                                 }
 921                         }
 922                 }
 923         }
 924
 925 out:
 926         lpfc_els_free_iocb(phba, cmdiocb);
 927         return;
 928 }
 929
 930 int
 931 lpfc_issue_els_plogi(struct lpfc_vport *vport, uint32_t did, uint8_t retry)
 932 {
 933         struct lpfc_hba  *phba = vport->phba;
 934         struct serv_parm *sp;
 935         IOCB_t *icmd;
 936         struct lpfc_iocbq *elsiocb;
 937         struct lpfc_sli_ring *pring;
 938         struct lpfc_sli *psli;
 939         uint8_t *pcmd;
 940         uint16_t cmdsize;
 941         int ret;
 942
 943         psli = &phba->sli;
 944         pring = &psli->ring[LPFC_ELS_RING];     /* ELS ring */
 945
 946         cmdsize = (sizeof(uint32_t) + sizeof(struct serv_parm));
 947         elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, NULL, did,
 948                                      ELS_CMD_PLOGI);
 949         if (!elsiocb)
 950                 return 1;
 951
 952         icmd = &elsiocb->iocb;
 953         pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
 954
 955         /* For PLOGI request, remainder of payload is service parameters */
 956         *((uint32_t *) (pcmd)) = ELS_CMD_PLOGI;
 957         pcmd += sizeof(uint32_t);
 958         memcpy(pcmd, &vport->fc_sparam, sizeof(struct serv_parm));
 959         sp = (struct serv_parm *) pcmd;
 960
 961         if (sp->cmn.fcphLow < FC_PH_4_3)
 962                 sp->cmn.fcphLow = FC_PH_4_3;
 963
 964         if (sp->cmn.fcphHigh < FC_PH3)
 965                 sp->cmn.fcphHigh = FC_PH3;
 966
 967         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
 968                 "Issue PLOGI:     did:x%x",
 969                 did, 0, 0);
 970
 971         phba->fc_stat.elsXmitPLOGI++;
 972         elsiocb->iocb_cmpl = lpfc_cmpl_els_plogi;
 973         ret = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
 974
 975         if (ret == IOCB_ERROR) {
 976                 lpfc_els_free_iocb(phba, elsiocb);
 977                 return 1;
 978         }
 979         return 0;
 980 }
 981
 982 static void
 983 lpfc_cmpl_els_prli(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
 984                    struct lpfc_iocbq *rspiocb)
 985 {
 986         struct lpfc_vport *vport = cmdiocb->vport;
 987         struct Scsi_Host  *shost = lpfc_shost_from_vport(vport);
 988         IOCB_t *irsp;
 989         struct lpfc_sli *psli;
 990         struct lpfc_nodelist *ndlp;
 991
 992         psli = &phba->sli;
 993         /* we pass cmdiocb to state machine which needs rspiocb as well */
 994         cmdiocb->context_un.rsp_iocb = rspiocb;
 995
 996         irsp = &(rspiocb->iocb);
 997         ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
 998         spin_lock_irq(shost->host_lock);
 999         ndlp->nlp_flag &= ~NLP_PRLI_SND;
1000         spin_unlock_irq(shost->host_lock);
1001
1002         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
1003                 "PRLI cmpl:       status:x%x/x%x did:x%x",
1004                 irsp->ulpStatus, irsp->un.ulpWord[4],
1005                 ndlp->nlp_DID);
1006         /* PRLI completes to NPort <nlp_DID> */
1007         lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
1008                          "0103 PRLI completes to NPort x%x "
1009                          "Data: x%x x%x x%x x%x\n",
1010                          ndlp->nlp_DID, irsp->ulpStatus, irsp->un.ulpWord[4],
1011                          irsp->ulpTimeout, vport->num_disc_nodes);
1012
1013         vport->fc_prli_sent--;
1014         /* Check to see if link went down during discovery */
1015         if (lpfc_els_chk_latt(vport))
1016                 goto out;
1017
1018         if (irsp->ulpStatus) {
1019                 /* Check for retry */
1020                 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
1021                         /* ELS command is being retried */
1022                         goto out;
1023                 }
1024                 /* PRLI failed */
1025                 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
1026                 if (lpfc_error_lost_link(irsp)) {
1027                         goto out;
1028                 } else {
1029                         lpfc_disc_state_machine(vport, ndlp, cmdiocb,
1030                                                 NLP_EVT_CMPL_PRLI);
1031                 }
1032         } else {
1033                 /* Good status, call state machine */
1034                 lpfc_disc_state_machine(vport, ndlp, cmdiocb,
1035                                         NLP_EVT_CMPL_PRLI);
1036         }
1037
1038 out:
1039         lpfc_els_free_iocb(phba, cmdiocb);
1040         return;
1041 }
1042
1043 int
1044 lpfc_issue_els_prli(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1045                     uint8_t retry)
1046 {
1047         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1048         struct lpfc_hba *phba = vport->phba;
1049         PRLI *npr;
1050         IOCB_t *icmd;
1051         struct lpfc_iocbq *elsiocb;
1052         struct lpfc_sli_ring *pring;
1053         struct lpfc_sli *psli;
1054         uint8_t *pcmd;
1055         uint16_t cmdsize;
1056
1057         psli = &phba->sli;
1058         pring = &psli->ring[LPFC_ELS_RING];     /* ELS ring */
1059
1060         cmdsize = (sizeof(uint32_t) + sizeof(PRLI));
1061         elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, ndlp,
1062                                      ndlp->nlp_DID, ELS_CMD_PRLI);
1063         if (!elsiocb)
1064                 return 1;
1065
1066         icmd = &elsiocb->iocb;
1067         pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1068
1069         /* For PRLI request, remainder of payload is service parameters */
1070         memset(pcmd, 0, (sizeof(PRLI) + sizeof(uint32_t)));
1071         *((uint32_t *) (pcmd)) = ELS_CMD_PRLI;
1072         pcmd += sizeof(uint32_t);
1073
1074         /* For PRLI, remainder of payload is PRLI parameter page */
1075         npr = (PRLI *) pcmd;
1076         /*
1077          * If our firmware version is 3.20 or later,
1078          * set the following bits for FC-TAPE support.
1079          */
1080         if (phba->vpd.rev.feaLevelHigh >= 0x02) {
1081                 npr->ConfmComplAllowed = 1;
1082                 npr->Retry = 1;
1083                 npr->TaskRetryIdReq = 1;
1084         }
1085         npr->estabImagePair = 1;
1086         npr->readXferRdyDis = 1;
1087
1088         /* For FCP support */
1089         npr->prliType = PRLI_FCP_TYPE;
1090         npr->initiatorFunc = 1;
1091
1092         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
1093                 "Issue PRLI:      did:x%x",
1094                 ndlp->nlp_DID, 0, 0);
1095
1096         phba->fc_stat.elsXmitPRLI++;
1097         elsiocb->iocb_cmpl = lpfc_cmpl_els_prli;
1098         spin_lock_irq(shost->host_lock);
1099         ndlp->nlp_flag |= NLP_PRLI_SND;
1100         spin_unlock_irq(shost->host_lock);
1101         if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
1102                 spin_lock_irq(shost->host_lock);
1103                 ndlp->nlp_flag &= ~NLP_PRLI_SND;
1104                 spin_unlock_irq(shost->host_lock);
1105                 lpfc_els_free_iocb(phba, elsiocb);
1106                 return 1;
1107         }
1108         vport->fc_prli_sent++;
1109         return 0;
1110 }
1111
1112 static void
1113 lpfc_more_adisc(struct lpfc_vport *vport)
1114 {
1115         int sentadisc;
1116
1117         if (vport->num_disc_nodes)
1118                 vport->num_disc_nodes--;
1119         /* Continue discovery with <num_disc_nodes> ADISCs to go */
1120         lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1121                          "0210 Continue discovery with %d ADISCs to go "
1122                          "Data: x%x x%x x%x\n",
1123                          vport->num_disc_nodes, vport->fc_adisc_cnt,
1124                          vport->fc_flag, vport->port_state);
1125         /* Check to see if there are more ADISCs to be sent */
1126         if (vport->fc_flag & FC_NLP_MORE) {
1127                 lpfc_set_disctmo(vport);
1128                 /* go thru NPR nodes and issue any remaining ELS ADISCs */
1129                 sentadisc = lpfc_els_disc_adisc(vport);
1130         }
1131         return;
1132 }
1133
1134 static void
1135 lpfc_rscn_disc(struct lpfc_vport *vport)
1136 {
1137         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1138
1139         lpfc_can_disctmo(vport);
1140
1141         /* RSCN discovery */
1142         /* go thru NPR nodes and issue ELS PLOGIs */
1143         if (vport->fc_npr_cnt)
1144                 if (lpfc_els_disc_plogi(vport))
1145                         return;
1146
1147         if (vport->fc_flag & FC_RSCN_MODE) {
1148                 /* Check to see if more RSCNs came in while we were
1149                  * processing this one.
1150                  */
1151                 if ((vport->fc_rscn_id_cnt == 0) &&
1152                     (!(vport->fc_flag & FC_RSCN_DISCOVERY))) {
1153                         spin_lock_irq(shost->host_lock);
1154                         vport->fc_flag &= ~FC_RSCN_MODE;
1155                         spin_unlock_irq(shost->host_lock);
1156                 } else {
1157                         lpfc_els_handle_rscn(vport);
1158                 }
1159         }
1160 }
1161
1162 static void
1163 lpfc_cmpl_els_adisc(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1164                     struct lpfc_iocbq *rspiocb)
1165 {
1166         struct lpfc_vport *vport = cmdiocb->vport;
1167         struct Scsi_Host  *shost = lpfc_shost_from_vport(vport);
1168         IOCB_t *irsp;
1169         struct lpfc_nodelist *ndlp;
1170         int  disc;
1171
1172         /* we pass cmdiocb to state machine which needs rspiocb as well */
1173         cmdiocb->context_un.rsp_iocb = rspiocb;
1174
1175         irsp = &(rspiocb->iocb);
1176         ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
1177
1178         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
1179                 "ADISC cmpl:      status:x%x/x%x did:x%x",
1180                 irsp->ulpStatus, irsp->un.ulpWord[4],
1181                 ndlp->nlp_DID);
1182
1183         /* Since ndlp can be freed in the disc state machine, note if this node
1184          * is being used during discovery.
1185          */
1186         spin_lock_irq(shost->host_lock);
1187         disc = (ndlp->nlp_flag & NLP_NPR_2B_DISC);
1188         ndlp->nlp_flag &= ~(NLP_ADISC_SND | NLP_NPR_2B_DISC);
1189         spin_unlock_irq(shost->host_lock);
1190         /* ADISC completes to NPort <nlp_DID> */
1191         lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
1192                          "0104 ADISC completes to NPort x%x "
1193                          "Data: x%x x%x x%x x%x x%x\n",
1194                          ndlp->nlp_DID, irsp->ulpStatus, irsp->un.ulpWord[4],
1195                          irsp->ulpTimeout, disc, vport->num_disc_nodes);
1196         /* Check to see if link went down during discovery */
1197         if (lpfc_els_chk_latt(vport)) {
1198                 spin_lock_irq(shost->host_lock);
1199                 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
1200                 spin_unlock_irq(shost->host_lock);
1201                 goto out;
1202         }
1203
1204         if (irsp->ulpStatus) {
1205                 /* Check for retry */
1206                 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
1207                         /* ELS command is being retried */
1208                         if (disc) {
1209                                 spin_lock_irq(shost->host_lock);
1210                                 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
1211                                 spin_unlock_irq(shost->host_lock);
1212                                 lpfc_set_disctmo(vport);
1213                         }
1214                         goto out;
1215                 }
1216                 /* ADISC failed */
1217                 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
1218                 if (!lpfc_error_lost_link(irsp)) {
1219                         lpfc_disc_state_machine(vport, ndlp, cmdiocb,
1220                                                 NLP_EVT_CMPL_ADISC);
1221                 }
1222         } else {
1223                 /* Good status, call state machine */
1224                 lpfc_disc_state_machine(vport, ndlp, cmdiocb,
1225                                         NLP_EVT_CMPL_ADISC);
1226         }
1227
1228         if (disc && vport->num_disc_nodes) {
1229                 /* Check to see if there are more ADISCs to be sent */
1230                 lpfc_more_adisc(vport);
1231
1232                 /* Check to see if we are done with ADISC authentication */
1233                 if (vport->num_disc_nodes == 0) {
1234                         /* If we get here, there is nothing left to ADISC */
1235                         /*
1236                          * For NPIV, cmpl_reg_vpi will set port_state to READY,
1237                          * and continue discovery.
1238                          */
1239                         if ((phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) &&
1240                            !(vport->fc_flag & FC_RSCN_MODE)) {
1241                                 lpfc_issue_reg_vpi(phba, vport);
1242                                 goto out;
1243                         }
1244                         /*
1245                          * For SLI2, we need to set port_state to READY
1246                          * and continue discovery.
1247                          */
1248                         if (vport->port_state < LPFC_VPORT_READY) {
1249                                 /* If we get here, there is nothing to ADISC */
1250                                 if (vport->port_type == LPFC_PHYSICAL_PORT)
1251                                         lpfc_issue_clear_la(phba, vport);
1252
1253                                 if (!(vport->fc_flag & FC_ABORT_DISCOVERY)) {
1254                                         vport->num_disc_nodes = 0;
1255                                         /* go thru NPR list, issue ELS PLOGIs */
1256                                         if (vport->fc_npr_cnt)
1257                                                 lpfc_els_disc_plogi(vport);
1258
1259                                         if (!vport->num_disc_nodes) {
1260                                                 spin_lock_irq(shost->host_lock);
1261                                                 vport->fc_flag &=
1262                                                         ~FC_NDISC_ACTIVE;
1263                                                 spin_unlock_irq(
1264                                                         shost->host_lock);
1265                                                 lpfc_can_disctmo(vport);
1266                                         }
1267                                 }
1268                                 vport->port_state = LPFC_VPORT_READY;
1269                         } else {
1270                                 lpfc_rscn_disc(vport);
1271                         }
1272                 }
1273         }
1274 out:
1275         lpfc_els_free_iocb(phba, cmdiocb);
1276         return;
1277 }
1278
1279 int
1280 lpfc_issue_els_adisc(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1281                      uint8_t retry)
1282 {
1283         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1284         struct lpfc_hba  *phba = vport->phba;
1285         ADISC *ap;
1286         IOCB_t *icmd;
1287         struct lpfc_iocbq *elsiocb;
1288         struct lpfc_sli *psli = &phba->sli;
1289         struct lpfc_sli_ring *pring = &psli->ring[LPFC_ELS_RING];
1290         uint8_t *pcmd;
1291         uint16_t cmdsize;
1292
1293         cmdsize = (sizeof(uint32_t) + sizeof(ADISC));
1294         elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, ndlp,
1295                                      ndlp->nlp_DID, ELS_CMD_ADISC);
1296         if (!elsiocb)
1297                 return 1;
1298
1299         icmd = &elsiocb->iocb;
1300         pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1301
1302         /* For ADISC request, remainder of payload is service parameters */
1303         *((uint32_t *) (pcmd)) = ELS_CMD_ADISC;
1304         pcmd += sizeof(uint32_t);
1305
1306         /* Fill in ADISC payload */
1307         ap = (ADISC *) pcmd;
1308         ap->hardAL_PA = phba->fc_pref_ALPA;
1309         memcpy(&ap->portName, &vport->fc_portname, sizeof(struct lpfc_name));
1310         memcpy(&ap->nodeName, &vport->fc_nodename, sizeof(struct lpfc_name));
1311         ap->DID = be32_to_cpu(vport->fc_myDID);
1312
1313         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
1314                 "Issue ADISC:     did:x%x",
1315                 ndlp->nlp_DID, 0, 0);
1316
1317         phba->fc_stat.elsXmitADISC++;
1318         elsiocb->iocb_cmpl = lpfc_cmpl_els_adisc;
1319         spin_lock_irq(shost->host_lock);
1320         ndlp->nlp_flag |= NLP_ADISC_SND;
1321         spin_unlock_irq(shost->host_lock);
1322         if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
1323                 spin_lock_irq(shost->host_lock);
1324                 ndlp->nlp_flag &= ~NLP_ADISC_SND;
1325                 spin_unlock_irq(shost->host_lock);
1326                 lpfc_els_free_iocb(phba, elsiocb);
1327                 return 1;
1328         }
1329         return 0;
1330 }
1331
1332 static void
1333 lpfc_cmpl_els_logo(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1334                    struct lpfc_iocbq *rspiocb)
1335 {
1336         struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
1337         struct lpfc_vport *vport = ndlp->vport;
1338         struct Scsi_Host  *shost = lpfc_shost_from_vport(vport);
1339         IOCB_t *irsp;
1340         struct lpfc_sli *psli;
1341
1342         psli = &phba->sli;
1343         /* we pass cmdiocb to state machine which needs rspiocb as well */
1344         cmdiocb->context_un.rsp_iocb = rspiocb;
1345
1346         irsp = &(rspiocb->iocb);
1347         spin_lock_irq(shost->host_lock);
1348         ndlp->nlp_flag &= ~NLP_LOGO_SND;
1349         spin_unlock_irq(shost->host_lock);
1350
1351         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
1352                 "LOGO cmpl:       status:x%x/x%x did:x%x",
1353                 irsp->ulpStatus, irsp->un.ulpWord[4],
1354                 ndlp->nlp_DID);
1355         /* LOGO completes to NPort <nlp_DID> */
1356         lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
1357                          "0105 LOGO completes to NPort x%x "
1358                          "Data: x%x x%x x%x x%x\n",
1359                          ndlp->nlp_DID, irsp->ulpStatus, irsp->un.ulpWord[4],
1360                          irsp->ulpTimeout, vport->num_disc_nodes);
1361         /* Check to see if link went down during discovery */
1362         if (lpfc_els_chk_latt(vport))
1363                 goto out;
1364
1365         if (ndlp->nlp_flag & NLP_TARGET_REMOVE) {
1366                 /* NLP_EVT_DEVICE_RM should unregister the RPI
1367                  * which should abort all outstanding IOs.
1368                  */
1369                 lpfc_disc_state_machine(vport, ndlp, cmdiocb,
1370                                         NLP_EVT_DEVICE_RM);
1371                 goto out;
1372         }
1373
1374         if (irsp->ulpStatus) {
1375                 /* Check for retry */
1376                 if (lpfc_els_retry(phba, cmdiocb, rspiocb))
1377                         /* ELS command is being retried */
1378                         goto out;
1379                 /* LOGO failed */
1380                 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
1381                 if (lpfc_error_lost_link(irsp))
1382                         goto out;
1383                 else
1384                         lpfc_disc_state_machine(vport, ndlp, cmdiocb,
1385                                                 NLP_EVT_CMPL_LOGO);
1386         } else {
1387                 /* Good status, call state machine.
1388                  * This will unregister the rpi if needed.
1389                  */
1390                 lpfc_disc_state_machine(vport, ndlp, cmdiocb,
1391                                         NLP_EVT_CMPL_LOGO);
1392         }
1393
1394 out:
1395         lpfc_els_free_iocb(phba, cmdiocb);
1396         return;
1397 }
1398
1399 int
1400 lpfc_issue_els_logo(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1401                     uint8_t retry)
1402 {
1403         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1404         struct lpfc_hba  *phba = vport->phba;
1405         IOCB_t *icmd;
1406         struct lpfc_iocbq *elsiocb;
1407         struct lpfc_sli_ring *pring;
1408         struct lpfc_sli *psli;
1409         uint8_t *pcmd;
1410         uint16_t cmdsize;
1411         int rc;
1412
1413         psli = &phba->sli;
1414         pring = &psli->ring[LPFC_ELS_RING];
1415
1416         cmdsize = (2 * sizeof(uint32_t)) + sizeof(struct lpfc_name);
1417         elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, ndlp,
1418                                      ndlp->nlp_DID, ELS_CMD_LOGO);
1419         if (!elsiocb)
1420                 return 1;
1421
1422         icmd = &elsiocb->iocb;
1423         pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1424         *((uint32_t *) (pcmd)) = ELS_CMD_LOGO;
1425         pcmd += sizeof(uint32_t);
1426
1427         /* Fill in LOGO payload */
1428         *((uint32_t *) (pcmd)) = be32_to_cpu(vport->fc_myDID);
1429         pcmd += sizeof(uint32_t);
1430         memcpy(pcmd, &vport->fc_portname, sizeof(struct lpfc_name));
1431
1432         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
1433                 "Issue LOGO:      did:x%x",
1434                 ndlp->nlp_DID, 0, 0);
1435
1436         phba->fc_stat.elsXmitLOGO++;
1437         elsiocb->iocb_cmpl = lpfc_cmpl_els_logo;
1438         spin_lock_irq(shost->host_lock);
1439         ndlp->nlp_flag |= NLP_LOGO_SND;
1440         spin_unlock_irq(shost->host_lock);
1441         rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
1442
1443         if (rc == IOCB_ERROR) {
1444                 spin_lock_irq(shost->host_lock);
1445                 ndlp->nlp_flag &= ~NLP_LOGO_SND;
1446                 spin_unlock_irq(shost->host_lock);
1447                 lpfc_els_free_iocb(phba, elsiocb);
1448                 return 1;
1449         }
1450         return 0;
1451 }
1452
1453 static void
1454 lpfc_cmpl_els_cmd(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1455                   struct lpfc_iocbq *rspiocb)
1456 {
1457         struct lpfc_vport *vport = cmdiocb->vport;
1458         IOCB_t *irsp;
1459
1460         irsp = &rspiocb->iocb;
1461
1462         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
1463                 "ELS cmd cmpl:    status:x%x/x%x did:x%x",
1464                 irsp->ulpStatus, irsp->un.ulpWord[4],
1465                 irsp->un.elsreq64.remoteID);
1466         /* ELS cmd tag <ulpIoTag> completes */
1467         lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
1468                          "0106 ELS cmd tag x%x completes Data: x%x x%x x%x\n",
1469                          irsp->ulpIoTag, irsp->ulpStatus,
1470                          irsp->un.ulpWord[4], irsp->ulpTimeout);
1471         /* Check to see if link went down during discovery */
1472         lpfc_els_chk_latt(vport);
1473         lpfc_els_free_iocb(phba, cmdiocb);
1474         return;
1475 }
1476
1477 int
1478 lpfc_issue_els_scr(struct lpfc_vport *vport, uint32_t nportid, uint8_t retry)
1479 {
1480         struct lpfc_hba  *phba = vport->phba;
1481         IOCB_t *icmd;
1482         struct lpfc_iocbq *elsiocb;
1483         struct lpfc_sli_ring *pring;
1484         struct lpfc_sli *psli;
1485         uint8_t *pcmd;
1486         uint16_t cmdsize;
1487         struct lpfc_nodelist *ndlp;
1488
1489         psli = &phba->sli;
1490         pring = &psli->ring[LPFC_ELS_RING];     /* ELS ring */
1491         cmdsize = (sizeof(uint32_t) + sizeof(SCR));
1492         ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
1493         if (!ndlp)
1494                 return 1;
1495
1496         lpfc_nlp_init(vport, ndlp, nportid);
1497
1498         elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, ndlp,
1499                                      ndlp->nlp_DID, ELS_CMD_SCR);
1500
1501         if (!elsiocb) {
1502                 lpfc_nlp_put(ndlp);
1503                 return 1;
1504         }
1505
1506         icmd = &elsiocb->iocb;
1507         pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1508
1509         *((uint32_t *) (pcmd)) = ELS_CMD_SCR;
1510         pcmd += sizeof(uint32_t);
1511
1512         /* For SCR, remainder of payload is SCR parameter page */
1513         memset(pcmd, 0, sizeof(SCR));
1514         ((SCR *) pcmd)->Function = SCR_FUNC_FULL;
1515
1516         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
1517                 "Issue SCR:       did:x%x",
1518                 ndlp->nlp_DID, 0, 0);
1519
1520         phba->fc_stat.elsXmitSCR++;
1521         elsiocb->iocb_cmpl = lpfc_cmpl_els_cmd;
1522         if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
1523                 lpfc_nlp_put(ndlp);
1524                 lpfc_els_free_iocb(phba, elsiocb);
1525                 return 1;
1526         }
1527         lpfc_nlp_put(ndlp);
1528         return 0;
1529 }
1530
1531 static int
1532 lpfc_issue_els_farpr(struct lpfc_vport *vport, uint32_t nportid, uint8_t retry)
1533 {
1534         struct lpfc_hba  *phba = vport->phba;
1535         IOCB_t *icmd;
1536         struct lpfc_iocbq *elsiocb;
1537         struct lpfc_sli_ring *pring;
1538         struct lpfc_sli *psli;
1539         FARP *fp;
1540         uint8_t *pcmd;
1541         uint32_t *lp;
1542         uint16_t cmdsize;
1543         struct lpfc_nodelist *ondlp;
1544         struct lpfc_nodelist *ndlp;
1545
1546         psli = &phba->sli;
1547         pring = &psli->ring[LPFC_ELS_RING];     /* ELS ring */
1548         cmdsize = (sizeof(uint32_t) + sizeof(FARP));
1549         ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
1550         if (!ndlp)
1551                 return 1;
1552
1553         lpfc_nlp_init(vport, ndlp, nportid);
1554
1555         elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, ndlp,
1556                                      ndlp->nlp_DID, ELS_CMD_RNID);
1557         if (!elsiocb) {
1558                 lpfc_nlp_put(ndlp);
1559                 return 1;
1560         }
1561
1562         icmd = &elsiocb->iocb;
1563         pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1564
1565         *((uint32_t *) (pcmd)) = ELS_CMD_FARPR;
1566         pcmd += sizeof(uint32_t);
1567
1568         /* Fill in FARPR payload */
1569         fp = (FARP *) (pcmd);
1570         memset(fp, 0, sizeof(FARP));
1571         lp = (uint32_t *) pcmd;
1572         *lp++ = be32_to_cpu(nportid);
1573         *lp++ = be32_to_cpu(vport->fc_myDID);
1574         fp->Rflags = 0;
1575         fp->Mflags = (FARP_MATCH_PORT | FARP_MATCH_NODE);
1576
1577         memcpy(&fp->RportName, &vport->fc_portname, sizeof(struct lpfc_name));
1578         memcpy(&fp->RnodeName, &vport->fc_nodename, sizeof(struct lpfc_name));
1579         ondlp = lpfc_findnode_did(vport, nportid);
1580         if (ondlp) {
1581                 memcpy(&fp->OportName, &ondlp->nlp_portname,
1582                        sizeof(struct lpfc_name));
1583                 memcpy(&fp->OnodeName, &ondlp->nlp_nodename,
1584                        sizeof(struct lpfc_name));
1585         }
1586
1587         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
1588                 "Issue FARPR:     did:x%x",
1589                 ndlp->nlp_DID, 0, 0);
1590
1591         phba->fc_stat.elsXmitFARPR++;
1592         elsiocb->iocb_cmpl = lpfc_cmpl_els_cmd;
1593         if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
1594                 lpfc_nlp_put(ndlp);
1595                 lpfc_els_free_iocb(phba, elsiocb);
1596                 return 1;
1597         }
1598         lpfc_nlp_put(ndlp);
1599         return 0;
1600 }
1601
1602 static void
1603 lpfc_end_rscn(struct lpfc_vport *vport)
1604 {
1605         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1606
1607         if (vport->fc_flag & FC_RSCN_MODE) {
1608                 /*
1609                  * Check to see if more RSCNs came in while we were
1610                  * processing this one.
1611                  */
1612                 if (vport->fc_rscn_id_cnt ||
1613                     (vport->fc_flag & FC_RSCN_DISCOVERY) != 0)
1614                         lpfc_els_handle_rscn(vport);
1615                 else {
1616                         spin_lock_irq(shost->host_lock);
1617                         vport->fc_flag &= ~FC_RSCN_MODE;
1618                         spin_unlock_irq(shost->host_lock);
1619                 }
1620         }
1621 }
1622
1623 void
1624 lpfc_cancel_retry_delay_tmo(struct lpfc_vport *vport, struct lpfc_nodelist *nlp)
1625 {
1626         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1627
1628         spin_lock_irq(shost->host_lock);
1629         nlp->nlp_flag &= ~NLP_DELAY_TMO;
1630         spin_unlock_irq(shost->host_lock);
1631         del_timer_sync(&nlp->nlp_delayfunc);
1632         nlp->nlp_last_elscmd = 0;
1633
1634         if (!list_empty(&nlp->els_retry_evt.evt_listp))
1635                 list_del_init(&nlp->els_retry_evt.evt_listp);
1636
1637         if (nlp->nlp_flag & NLP_NPR_2B_DISC) {
1638                 spin_lock_irq(shost->host_lock);
1639                 nlp->nlp_flag &= ~NLP_NPR_2B_DISC;
1640                 spin_unlock_irq(shost->host_lock);
1641                 if (vport->num_disc_nodes) {
1642                         /* Check to see if there are more
1643                          * PLOGIs to be sent
1644                          */
1645                         lpfc_more_plogi(vport);
1646
1647                         if (vport->num_disc_nodes == 0) {
1648                                 spin_lock_irq(shost->host_lock);
1649                                 vport->fc_flag &= ~FC_NDISC_ACTIVE;
1650                                 spin_unlock_irq(shost->host_lock);
1651                                 lpfc_can_disctmo(vport);
1652                                 lpfc_end_rscn(vport);
1653                         }
1654                 }
1655         }
1656         return;
1657 }
1658
1659 void
1660 lpfc_els_retry_delay(unsigned long ptr)
1661 {
1662         struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) ptr;
1663         struct lpfc_vport *vport = ndlp->vport;
1664         struct lpfc_hba   *phba = vport->phba;
1665         unsigned long flags;
1666         struct lpfc_work_evt  *evtp = &ndlp->els_retry_evt;
1667
1668         ndlp = (struct lpfc_nodelist *) ptr;
1669         phba = ndlp->vport->phba;
1670         evtp = &ndlp->els_retry_evt;
1671
1672         spin_lock_irqsave(&phba->hbalock, flags);
1673         if (!list_empty(&evtp->evt_listp)) {
1674                 spin_unlock_irqrestore(&phba->hbalock, flags);
1675                 return;
1676         }
1677
1678         evtp->evt_arg1  = ndlp;
1679         evtp->evt       = LPFC_EVT_ELS_RETRY;
1680         list_add_tail(&evtp->evt_listp, &phba->work_list);
1681         if (phba->work_wait)
1682                 lpfc_worker_wake_up(phba);
1683
1684         spin_unlock_irqrestore(&phba->hbalock, flags);
1685         return;
1686 }
1687
1688 void
1689 lpfc_els_retry_delay_handler(struct lpfc_nodelist *ndlp)
1690 {
1691         struct lpfc_vport *vport = ndlp->vport;
1692         struct Scsi_Host  *shost = lpfc_shost_from_vport(vport);
1693         uint32_t cmd, did, retry;
1694
1695         spin_lock_irq(shost->host_lock);
1696         did = ndlp->nlp_DID;
1697         cmd = ndlp->nlp_last_elscmd;
1698         ndlp->nlp_last_elscmd = 0;
1699
1700         if (!(ndlp->nlp_flag & NLP_DELAY_TMO)) {
1701                 spin_unlock_irq(shost->host_lock);
1702                 return;
1703         }
1704
1705         ndlp->nlp_flag &= ~NLP_DELAY_TMO;
1706         spin_unlock_irq(shost->host_lock);
1707         /*
1708          * If a discovery event readded nlp_delayfunc after timer
1709          * firing and before processing the timer, cancel the
1710          * nlp_delayfunc.
1711          */
1712         del_timer_sync(&ndlp->nlp_delayfunc);
1713         retry = ndlp->nlp_retry;
1714
1715         switch (cmd) {
1716         case ELS_CMD_FLOGI:
1717                 lpfc_issue_els_flogi(vport, ndlp, retry);
1718                 break;
1719         case ELS_CMD_PLOGI:
1720                 if (!lpfc_issue_els_plogi(vport, ndlp->nlp_DID, retry)) {
1721                         ndlp->nlp_prev_state = ndlp->nlp_state;
1722                         lpfc_nlp_set_state(vport, ndlp, NLP_STE_PLOGI_ISSUE);
1723                 }
1724                 break;
1725         case ELS_CMD_ADISC:
1726                 if (!lpfc_issue_els_adisc(vport, ndlp, retry)) {
1727                         ndlp->nlp_prev_state = ndlp->nlp_state;
1728                         lpfc_nlp_set_state(vport, ndlp, NLP_STE_ADISC_ISSUE);
1729                 }
1730                 break;
1731         case ELS_CMD_PRLI:
1732                 if (!lpfc_issue_els_prli(vport, ndlp, retry)) {
1733                         ndlp->nlp_prev_state = ndlp->nlp_state;
1734                         lpfc_nlp_set_state(vport, ndlp, NLP_STE_PRLI_ISSUE);
1735                 }
1736                 break;
1737         case ELS_CMD_LOGO:
1738                 if (!lpfc_issue_els_logo(vport, ndlp, retry)) {
1739                         ndlp->nlp_prev_state = ndlp->nlp_state;
1740                         lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
1741                 }
1742                 break;
1743         case ELS_CMD_FDISC:
1744                 lpfc_issue_els_fdisc(vport, ndlp, retry);
1745                 break;
1746         }
1747         return;
1748 }
1749
1750 static int
1751 lpfc_els_retry(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1752                struct lpfc_iocbq *rspiocb)
1753 {
1754         struct lpfc_vport *vport = cmdiocb->vport;
1755         struct Scsi_Host  *shost = lpfc_shost_from_vport(vport);
1756         IOCB_t *irsp = &rspiocb->iocb;
1757         struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
1758         struct lpfc_dmabuf *pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
1759         uint32_t *elscmd;
1760         struct ls_rjt stat;
1761         int retry = 0, maxretry = lpfc_max_els_tries, delay = 0;
1762         uint32_t cmd = 0;
1763         uint32_t did;
1764
1765
1766         /* Note: context2 may be 0 for internal driver abort
1767          * of delays ELS command.
1768          */
1769
1770         if (pcmd && pcmd->virt) {
1771                 elscmd = (uint32_t *) (pcmd->virt);
1772                 cmd = *elscmd++;
1773         }
1774
1775         if (ndlp)
1776                 did = ndlp->nlp_DID;
1777         else {
1778                 /* We should only hit this case for retrying PLOGI */
1779                 did = irsp->un.elsreq64.remoteID;
1780                 ndlp = lpfc_findnode_did(vport, did);
1781                 if (!ndlp && (cmd != ELS_CMD_PLOGI))
1782                         return 1;
1783         }
1784
1785         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
1786                 "Retry ELS:       wd7:x%x wd4:x%x did:x%x",
1787                 *(((uint32_t *) irsp) + 7), irsp->un.ulpWord[4], ndlp->nlp_DID);
1788
1789         switch (irsp->ulpStatus) {
1790         case IOSTAT_FCP_RSP_ERROR:
1791         case IOSTAT_REMOTE_STOP:
1792                 break;
1793
1794         case IOSTAT_LOCAL_REJECT:
1795                 switch ((irsp->un.ulpWord[4] & 0xff)) {
1796                 case IOERR_LOOP_OPEN_FAILURE:
1797                         if (cmd == ELS_CMD_PLOGI && cmdiocb->retry == 0)
1798                                 delay = 1000;
1799                         retry = 1;
1800                         break;
1801
1802                 case IOERR_ILLEGAL_COMMAND:
1803                         if ((phba->sli3_options & LPFC_SLI3_VPORT_TEARDOWN) &&
1804                             (cmd == ELS_CMD_FDISC)) {
1805                                 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
1806                                                  "0124 FDISC failed (3/6) "
1807                                                  "retrying...\n");
1808                                 lpfc_mbx_unreg_vpi(vport);
1809                                 retry = 1;
1810                                 /* FDISC retry policy */
1811                                 maxretry = 48;
1812                                 if (cmdiocb->retry >= 32)
1813                                         delay = 1000;
1814                         }
1815                         break;
1816
1817                 case IOERR_NO_RESOURCES:
1818                         retry = 1;
1819                         if (cmdiocb->retry > 100)
1820                                 delay = 100;
1821                         maxretry = 250;
1822                         break;
1823
1824                 case IOERR_ILLEGAL_FRAME:
1825                         delay = 100;
1826                         retry = 1;
1827                         break;
1828
1829                 case IOERR_SEQUENCE_TIMEOUT:
1830                 case IOERR_INVALID_RPI:
1831                         retry = 1;
1832                         break;
1833                 }
1834                 break;
1835
1836         case IOSTAT_NPORT_RJT:
1837         case IOSTAT_FABRIC_RJT:
1838                 if (irsp->un.ulpWord[4] & RJT_UNAVAIL_TEMP) {
1839                         retry = 1;
1840                         break;
1841                 }
1842                 break;
1843
1844         case IOSTAT_NPORT_BSY:
1845         case IOSTAT_FABRIC_BSY:
1846                 retry = 1;
1847                 break;
1848
1849         case IOSTAT_LS_RJT:
1850                 stat.un.lsRjtError = be32_to_cpu(irsp->un.ulpWord[4]);
1851                 /* Added for Vendor specifc support
1852                  * Just keep retrying for these Rsn / Exp codes
1853                  */
1854                 switch (stat.un.b.lsRjtRsnCode) {
1855                 case LSRJT_UNABLE_TPC:
1856                         if (stat.un.b.lsRjtRsnCodeExp ==
1857                             LSEXP_CMD_IN_PROGRESS) {
1858                                 if (cmd == ELS_CMD_PLOGI) {
1859                                         delay = 1000;
1860                                         maxretry = 48;
1861                                 }
1862                                 retry = 1;
1863                                 break;
1864                         }
1865                         if (cmd == ELS_CMD_PLOGI) {
1866                                 delay = 1000;
1867                                 maxretry = lpfc_max_els_tries + 1;
1868                                 retry = 1;
1869                                 break;
1870                         }
1871                         if ((phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) &&
1872                           (cmd == ELS_CMD_FDISC) &&
1873                           (stat.un.b.lsRjtRsnCodeExp == LSEXP_OUT_OF_RESOURCE)){
1874                                 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
1875                                                  "0125 FDISC Failed (x%x). "
1876                                                  "Fabric out of resources\n",
1877                                                  stat.un.lsRjtError);
1878                                 lpfc_vport_set_state(vport,
1879                                                      FC_VPORT_NO_FABRIC_RSCS);
1880                         }
1881                         break;
1882
1883                 case LSRJT_LOGICAL_BSY:
1884                         if ((cmd == ELS_CMD_PLOGI) ||
1885                             (cmd == ELS_CMD_PRLI)) {
1886                                 delay = 1000;
1887                                 maxretry = 48;
1888                         } else if (cmd == ELS_CMD_FDISC) {
1889                                 /* FDISC retry policy */
1890                                 maxretry = 48;
1891                                 if (cmdiocb->retry >= 32)
1892                                         delay = 1000;
1893                         }
1894                         retry = 1;
1895                         break;
1896
1897                 case LSRJT_LOGICAL_ERR:
1898                 case LSRJT_PROTOCOL_ERR:
1899                         if ((phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) &&
1900                           (cmd == ELS_CMD_FDISC) &&
1901                           ((stat.un.b.lsRjtRsnCodeExp == LSEXP_INVALID_PNAME) ||
1902                           (stat.un.b.lsRjtRsnCodeExp == LSEXP_INVALID_NPORT_ID))
1903                           ) {
1904                                 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
1905                                                  "0123 FDISC Failed (x%x). "
1906                                                  "Fabric Detected Bad WWN\n",
1907                                                  stat.un.lsRjtError);
1908                                 lpfc_vport_set_state(vport,
1909                                                      FC_VPORT_FABRIC_REJ_WWN);
1910                         }
1911                         break;
1912                 }
1913                 break;
1914
1915         case IOSTAT_INTERMED_RSP:
1916         case IOSTAT_BA_RJT:
1917                 break;
1918
1919         default:
1920                 break;
1921         }
1922
1923         if (did == FDMI_DID)
1924                 retry = 1;
1925
1926         if ((++cmdiocb->retry) >= maxretry) {
1927                 phba->fc_stat.elsRetryExceeded++;
1928                 retry = 0;
1929         }
1930
1931         if ((vport->load_flag & FC_UNLOADING) != 0)
1932                 retry = 0;
1933
1934         if (retry) {
1935
1936                 /* Retry ELS command <elsCmd> to remote NPORT <did> */
1937                 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
1938                                  "0107 Retry ELS command x%x to remote "
1939                                  "NPORT x%x Data: x%x x%x\n",
1940                                  cmd, did, cmdiocb->retry, delay);
1941
1942                 if (((cmd == ELS_CMD_PLOGI) || (cmd == ELS_CMD_ADISC)) &&
1943                         ((irsp->ulpStatus != IOSTAT_LOCAL_REJECT) ||
1944                         ((irsp->un.ulpWord[4] & 0xff) != IOERR_NO_RESOURCES))) {
1945                         /* Don't reset timer for no resources */
1946
1947                         /* If discovery / RSCN timer is running, reset it */
1948                         if (timer_pending(&vport->fc_disctmo) ||
1949                             (vport->fc_flag & FC_RSCN_MODE))
1950                                 lpfc_set_disctmo(vport);
1951                 }
1952
1953                 phba->fc_stat.elsXmitRetry++;
1954                 if (ndlp && delay) {
1955                         phba->fc_stat.elsDelayRetry++;
1956                         ndlp->nlp_retry = cmdiocb->retry;
1957
1958                         /* delay is specified in milliseconds */
1959                         mod_timer(&ndlp->nlp_delayfunc,
1960                                 jiffies + msecs_to_jiffies(delay));
1961                         spin_lock_irq(shost->host_lock);
1962                         ndlp->nlp_flag |= NLP_DELAY_TMO;
1963                         spin_unlock_irq(shost->host_lock);
1964
1965                         ndlp->nlp_prev_state = ndlp->nlp_state;
1966                         if (cmd == ELS_CMD_PRLI)
1967                                 lpfc_nlp_set_state(vport, ndlp,
1968                                         NLP_STE_REG_LOGIN_ISSUE);
1969                         else
1970                                 lpfc_nlp_set_state(vport, ndlp,
1971                                         NLP_STE_NPR_NODE);
1972                         ndlp->nlp_last_elscmd = cmd;
1973
1974                         return 1;
1975                 }
1976                 switch (cmd) {
1977                 case ELS_CMD_FLOGI:
1978                         lpfc_issue_els_flogi(vport, ndlp, cmdiocb->retry);
1979                         return 1;
1980                 case ELS_CMD_FDISC:
1981                         lpfc_issue_els_fdisc(vport, ndlp, cmdiocb->retry);
1982                         return 1;
1983                 case ELS_CMD_PLOGI:
1984                         if (ndlp) {
1985                                 ndlp->nlp_prev_state = ndlp->nlp_state;
1986                                 lpfc_nlp_set_state(vport, ndlp,
1987                                                    NLP_STE_PLOGI_ISSUE);
1988                         }
1989                         lpfc_issue_els_plogi(vport, did, cmdiocb->retry);
1990                         return 1;
1991                 case ELS_CMD_ADISC:
1992                         ndlp->nlp_prev_state = ndlp->nlp_state;
1993                         lpfc_nlp_set_state(vport, ndlp, NLP_STE_ADISC_ISSUE);
1994                         lpfc_issue_els_adisc(vport, ndlp, cmdiocb->retry);
1995                         return 1;
1996                 case ELS_CMD_PRLI:
1997                         ndlp->nlp_prev_state = ndlp->nlp_state;
1998                         lpfc_nlp_set_state(vport, ndlp, NLP_STE_PRLI_ISSUE);
1999                         lpfc_issue_els_prli(vport, ndlp, cmdiocb->retry);
2000                         return 1;
2001                 case ELS_CMD_LOGO:
2002                         ndlp->nlp_prev_state = ndlp->nlp_state;
2003                         lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
2004                         lpfc_issue_els_logo(vport, ndlp, cmdiocb->retry);
2005                         return 1;
2006                 }
2007         }
2008         /* No retry ELS command <elsCmd> to remote NPORT <did> */
2009         lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
2010                          "0108 No retry ELS command x%x to remote "
2011                          "NPORT x%x Retried:%d Error:x%x/%x\n",
2012                          cmd, did, cmdiocb->retry, irsp->ulpStatus,
2013                          irsp->un.ulpWord[4]);
2014         return 0;
2015 }
2016
2017 int
2018 lpfc_els_free_iocb(struct lpfc_hba *phba, struct lpfc_iocbq *elsiocb)
2019 {
2020         struct lpfc_dmabuf *buf_ptr, *buf_ptr1;
2021
2022         if (elsiocb->context1) {
2023                 lpfc_nlp_put(elsiocb->context1);
2024                 elsiocb->context1 = NULL;
2025         }
2026         /* context2  = cmd,  context2->next = rsp, context3 = bpl */
2027         if (elsiocb->context2) {
2028                 buf_ptr1 = (struct lpfc_dmabuf *) elsiocb->context2;
2029                 /* Free the response before processing the command.  */
2030                 if (!list_empty(&buf_ptr1->list)) {
2031                         list_remove_head(&buf_ptr1->list, buf_ptr,
2032                                          struct lpfc_dmabuf,
2033                                          list);
2034                         lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
2035                         kfree(buf_ptr);
2036                 }
2037                 lpfc_mbuf_free(phba, buf_ptr1->virt, buf_ptr1->phys);
2038                 kfree(buf_ptr1);
2039         }
2040
2041         if (elsiocb->context3) {
2042                 buf_ptr = (struct lpfc_dmabuf *) elsiocb->context3;
2043                 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
2044                 kfree(buf_ptr);
2045         }
2046         lpfc_sli_release_iocbq(phba, elsiocb);
2047         return 0;
2048 }
2049
2050 static void
2051 lpfc_cmpl_els_logo_acc(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
2052                        struct lpfc_iocbq *rspiocb)
2053 {
2054         struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
2055         struct lpfc_vport *vport = cmdiocb->vport;
2056         IOCB_t *irsp;
2057
2058         irsp = &rspiocb->iocb;
2059         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_RSP,
2060                 "ACC LOGO cmpl:   status:x%x/x%x did:x%x",
2061                 irsp->ulpStatus, irsp->un.ulpWord[4], ndlp->nlp_DID);
2062         /* ACC to LOGO completes to NPort <nlp_DID> */
2063         lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
2064                          "0109 ACC to LOGO completes to NPort x%x "
2065                          "Data: x%x x%x x%x\n",
2066                          ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_state,
2067                          ndlp->nlp_rpi);
2068         switch (ndlp->nlp_state) {
2069         case NLP_STE_UNUSED_NODE:       /* node is just allocated */
2070                 lpfc_drop_node(vport, ndlp);
2071                 break;
2072         case NLP_STE_NPR_NODE:          /* NPort Recovery mode */
2073                 lpfc_unreg_rpi(vport, ndlp);
2074                 break;
2075         default:
2076                 break;
2077         }
2078         lpfc_els_free_iocb(phba, cmdiocb);
2079         return;
2080 }
2081
2082 void
2083 lpfc_mbx_cmpl_dflt_rpi(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
2084 {
2085         struct lpfc_dmabuf *mp = (struct lpfc_dmabuf *) (pmb->context1);
2086         struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) pmb->context2;
2087
2088         pmb->context1 = NULL;
2089         lpfc_mbuf_free(phba, mp->virt, mp->phys);
2090         kfree(mp);
2091         mempool_free(pmb, phba->mbox_mem_pool);
2092         lpfc_nlp_put(ndlp);
2093         return;
2094 }
2095
2096 static void
2097 lpfc_cmpl_els_rsp(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
2098                   struct lpfc_iocbq *rspiocb)
2099 {
2100         struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
2101         struct lpfc_vport *vport = ndlp ? ndlp->vport : NULL;
2102         struct Scsi_Host  *shost = vport ? lpfc_shost_from_vport(vport) : NULL;
2103         IOCB_t *irsp;
2104         LPFC_MBOXQ_t *mbox = NULL;
2105         struct lpfc_dmabuf *mp = NULL;
2106
2107         irsp = &rspiocb->iocb;
2108
2109         if (cmdiocb->context_un.mbox)
2110                 mbox = cmdiocb->context_un.mbox;
2111
2112         /* Check to see if link went down during discovery */
2113         if (!ndlp || lpfc_els_chk_latt(vport)) {
2114                 if (mbox) {
2115                         mp = (struct lpfc_dmabuf *) mbox->context1;
2116                         if (mp) {
2117                                 lpfc_mbuf_free(phba, mp->virt, mp->phys);
2118                                 kfree(mp);
2119                         }
2120                         mempool_free(mbox, phba->mbox_mem_pool);
2121                 }
2122                 goto out;
2123         }
2124
2125         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_RSP,
2126                 "ELS rsp cmpl:    status:x%x/x%x did:x%x",
2127                 irsp->ulpStatus, irsp->un.ulpWord[4],
2128                 cmdiocb->iocb.un.elsreq64.remoteID);
2129         /* ELS response tag <ulpIoTag> completes */
2130         lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
2131                          "0110 ELS response tag x%x completes "
2132                          "Data: x%x x%x x%x x%x x%x x%x x%x\n",
2133                          cmdiocb->iocb.ulpIoTag, rspiocb->iocb.ulpStatus,
2134                          rspiocb->iocb.un.ulpWord[4], rspiocb->iocb.ulpTimeout,
2135                          ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_state,
2136                          ndlp->nlp_rpi);
2137         if (mbox) {
2138                 if ((rspiocb->iocb.ulpStatus == 0)
2139                     && (ndlp->nlp_flag & NLP_ACC_REGLOGIN)) {
2140                         lpfc_unreg_rpi(vport, ndlp);
2141                         mbox->context2 = lpfc_nlp_get(ndlp);
2142                         mbox->vport = vport;
2143                         if (ndlp->nlp_flag & NLP_RM_DFLT_RPI) {
2144                                 mbox->mbox_flag |= LPFC_MBX_IMED_UNREG;
2145                                 mbox->mbox_cmpl = lpfc_mbx_cmpl_dflt_rpi;
2146                         }
2147                         else {
2148                                 mbox->mbox_cmpl = lpfc_mbx_cmpl_reg_login;
2149                                 ndlp->nlp_prev_state = ndlp->nlp_state;
2150                                 lpfc_nlp_set_state(vport, ndlp,
2151                                            NLP_STE_REG_LOGIN_ISSUE);
2152                         }
2153                         if (lpfc_sli_issue_mbox(phba, mbox,
2154                                                 (MBX_NOWAIT | MBX_STOP_IOCB))
2155                             != MBX_NOT_FINISHED) {
2156                                 goto out;
2157                         }
2158                         lpfc_nlp_put(ndlp);
2159                         /* NOTE: we should have messages for unsuccessful
2160                            reglogin */
2161                 } else {
2162                         /* Do not drop node for lpfc_els_abort'ed ELS cmds */
2163                         if (!lpfc_error_lost_link(irsp) &&
2164                             ndlp->nlp_flag & NLP_ACC_REGLOGIN) {
2165                                 lpfc_drop_node(vport, ndlp);
2166                                 ndlp = NULL;
2167                         }
2168                 }
2169                 mp = (struct lpfc_dmabuf *) mbox->context1;
2170                 if (mp) {
2171                         lpfc_mbuf_free(phba, mp->virt, mp->phys);
2172                         kfree(mp);
2173                 }
2174                 mempool_free(mbox, phba->mbox_mem_pool);
2175         }
2176 out:
2177         if (ndlp) {
2178                 spin_lock_irq(shost->host_lock);
2179                 ndlp->nlp_flag &= ~(NLP_ACC_REGLOGIN | NLP_RM_DFLT_RPI);
2180                 spin_unlock_irq(shost->host_lock);
2181         }
2182         lpfc_els_free_iocb(phba, cmdiocb);
2183         return;
2184 }
2185
2186 int
2187 lpfc_els_rsp_acc(struct lpfc_vport *vport, uint32_t flag,
2188                  struct lpfc_iocbq *oldiocb, struct lpfc_nodelist *ndlp,
2189                  LPFC_MBOXQ_t *mbox)
2190 {
2191         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2192         struct lpfc_hba  *phba = vport->phba;
2193         IOCB_t *icmd;
2194         IOCB_t *oldcmd;
2195         struct lpfc_iocbq *elsiocb;
2196         struct lpfc_sli_ring *pring;
2197         struct lpfc_sli *psli;
2198         uint8_t *pcmd;
2199         uint16_t cmdsize;
2200         int rc;
2201         ELS_PKT *els_pkt_ptr;
2202
2203         psli = &phba->sli;
2204         pring = &psli->ring[LPFC_ELS_RING];     /* ELS ring */
2205         oldcmd = &oldiocb->iocb;
2206
2207         switch (flag) {
2208         case ELS_CMD_ACC:
2209                 cmdsize = sizeof(uint32_t);
2210                 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry,
2211                                              ndlp, ndlp->nlp_DID, ELS_CMD_ACC);
2212                 if (!elsiocb) {
2213                         spin_lock_irq(shost->host_lock);
2214                         ndlp->nlp_flag &= ~NLP_LOGO_ACC;
2215                         spin_unlock_irq(shost->host_lock);
2216                         return 1;
2217                 }
2218
2219                 icmd = &elsiocb->iocb;
2220                 icmd->ulpContext = oldcmd->ulpContext;  /* Xri */
2221                 pcmd = (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2222                 *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
2223                 pcmd += sizeof(uint32_t);
2224
2225                 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_RSP,
2226                         "Issue ACC:       did:x%x flg:x%x",
2227                         ndlp->nlp_DID, ndlp->nlp_flag, 0);
2228                 break;
2229         case ELS_CMD_PLOGI:
2230                 cmdsize = (sizeof(struct serv_parm) + sizeof(uint32_t));
2231                 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry,
2232                                              ndlp, ndlp->nlp_DID, ELS_CMD_ACC);
2233                 if (!elsiocb)
2234                         return 1;
2235
2236                 icmd = &elsiocb->iocb;
2237                 icmd->ulpContext = oldcmd->ulpContext;  /* Xri */
2238                 pcmd = (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2239
2240                 if (mbox)
2241                         elsiocb->context_un.mbox = mbox;
2242
2243                 *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
2244                 pcmd += sizeof(uint32_t);
2245                 memcpy(pcmd, &vport->fc_sparam, sizeof(struct serv_parm));
2246
2247                 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_RSP,
2248                         "Issue ACC PLOGI: did:x%x flg:x%x",
2249                         ndlp->nlp_DID, ndlp->nlp_flag, 0);
2250                 break;
2251         case ELS_CMD_PRLO:
2252                 cmdsize = sizeof(uint32_t) + sizeof(PRLO);
2253                 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry,
2254                                              ndlp, ndlp->nlp_DID, ELS_CMD_PRLO);
2255                 if (!elsiocb)
2256                         return 1;
2257
2258                 icmd = &elsiocb->iocb;
2259                 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
2260                 pcmd = (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2261
2262                 memcpy(pcmd, ((struct lpfc_dmabuf *) oldiocb->context2)->virt,
2263                        sizeof(uint32_t) + sizeof(PRLO));
2264                 *((uint32_t *) (pcmd)) = ELS_CMD_PRLO_ACC;
2265                 els_pkt_ptr = (ELS_PKT *) pcmd;
2266                 els_pkt_ptr->un.prlo.acceptRspCode = PRLO_REQ_EXECUTED;
2267
2268                 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_RSP,
2269                         "Issue ACC PRLO:  did:x%x flg:x%x",
2270                         ndlp->nlp_DID, ndlp->nlp_flag, 0);
2271                 break;
2272         default:
2273                 return 1;
2274         }
2275         /* Xmit ELS ACC response tag <ulpIoTag> */
2276         lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
2277                          "0128 Xmit ELS ACC response tag x%x, XRI: x%x, "
2278                          "DID: x%x, nlp_flag: x%x nlp_state: x%x RPI: x%x\n",
2279                          elsiocb->iotag, elsiocb->iocb.ulpContext,
2280                          ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_state,
2281                          ndlp->nlp_rpi);
2282         if (ndlp->nlp_flag & NLP_LOGO_ACC) {
2283                 spin_lock_irq(shost->host_lock);
2284                 ndlp->nlp_flag &= ~NLP_LOGO_ACC;
2285                 spin_unlock_irq(shost->host_lock);
2286                 elsiocb->iocb_cmpl = lpfc_cmpl_els_logo_acc;
2287         } else {
2288                 elsiocb->iocb_cmpl = lpfc_cmpl_els_rsp;
2289         }
2290
2291         phba->fc_stat.elsXmitACC++;
2292         rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
2293         if (rc == IOCB_ERROR) {
2294                 lpfc_els_free_iocb(phba, elsiocb);
2295                 return 1;
2296         }
2297         return 0;
2298 }
2299
2300 int
2301 lpfc_els_rsp_reject(struct lpfc_vport *vport, uint32_t rejectError,
2302                     struct lpfc_iocbq *oldiocb, struct lpfc_nodelist *ndlp,
2303                     LPFC_MBOXQ_t *mbox)
2304 {
2305         struct lpfc_hba  *phba = vport->phba;
2306         IOCB_t *icmd;
2307         IOCB_t *oldcmd;
2308         struct lpfc_iocbq *elsiocb;
2309         struct lpfc_sli_ring *pring;
2310         struct lpfc_sli *psli;
2311         uint8_t *pcmd;
2312         uint16_t cmdsize;
2313         int rc;
2314
2315         psli = &phba->sli;
2316         pring = &psli->ring[LPFC_ELS_RING];     /* ELS ring */
2317
2318         cmdsize = 2 * sizeof(uint32_t);
2319         elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry, ndlp,
2320                                      ndlp->nlp_DID, ELS_CMD_LS_RJT);
2321         if (!elsiocb)
2322                 return 1;
2323
2324         icmd = &elsiocb->iocb;
2325         oldcmd = &oldiocb->iocb;
2326         icmd->ulpContext = oldcmd->ulpContext;  /* Xri */
2327         pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2328
2329         *((uint32_t *) (pcmd)) = ELS_CMD_LS_RJT;
2330         pcmd += sizeof(uint32_t);
2331         *((uint32_t *) (pcmd)) = rejectError;
2332
2333         if (mbox)
2334                 elsiocb->context_un.mbox = mbox;
2335
2336         /* Xmit ELS RJT <err> response tag <ulpIoTag> */
2337         lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
2338                          "0129 Xmit ELS RJT x%x response tag x%x "
2339                          "xri x%x, did x%x, nlp_flag x%x, nlp_state x%x, "
2340                          "rpi x%x\n",
2341                          rejectError, elsiocb->iotag,
2342                          elsiocb->iocb.ulpContext, ndlp->nlp_DID,
2343                          ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi);
2344         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_RSP,
2345                 "Issue LS_RJT:    did:x%x flg:x%x err:x%x",
2346                 ndlp->nlp_DID, ndlp->nlp_flag, rejectError);
2347
2348         phba->fc_stat.elsXmitLSRJT++;
2349         elsiocb->iocb_cmpl = lpfc_cmpl_els_rsp;
2350         rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
2351
2352         /* If the node is in the UNUSED state, and we are sending
2353          * a reject, we are done with it.  Release driver reference
2354          * count here.  The outstanding els will release its reference on
2355          * completion and the node can be freed then.
2356          */
2357         if (ndlp->nlp_state == NLP_STE_UNUSED_NODE)
2358                 lpfc_nlp_put(ndlp);
2359
2360         if (rc == IOCB_ERROR) {
2361                 lpfc_els_free_iocb(phba, elsiocb);
2362                 return 1;
2363         }
2364         return 0;
2365 }
2366
2367 int
2368 lpfc_els_rsp_adisc_acc(struct lpfc_vport *vport, struct lpfc_iocbq *oldiocb,
2369                        struct lpfc_nodelist *ndlp)
2370 {
2371         struct lpfc_hba  *phba = vport->phba;
2372         struct lpfc_sli  *psli = &phba->sli;
2373         struct lpfc_sli_ring *pring = &psli->ring[LPFC_ELS_RING];
2374         ADISC *ap;
2375         IOCB_t *icmd, *oldcmd;
2376         struct lpfc_iocbq *elsiocb;
2377         uint8_t *pcmd;
2378         uint16_t cmdsize;
2379         int rc;
2380
2381         cmdsize = sizeof(uint32_t) + sizeof(ADISC);
2382         elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry, ndlp,
2383                                      ndlp->nlp_DID, ELS_CMD_ACC);
2384         if (!elsiocb)
2385                 return 1;
2386
2387         icmd = &elsiocb->iocb;
2388         oldcmd = &oldiocb->iocb;
2389         icmd->ulpContext = oldcmd->ulpContext;  /* Xri */
2390
2391         /* Xmit ADISC ACC response tag <ulpIoTag> */
2392         lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
2393                          "0130 Xmit ADISC ACC response iotag x%x xri: "
2394                          "x%x, did x%x, nlp_flag x%x, nlp_state x%x rpi x%x\n",
2395                          elsiocb->iotag, elsiocb->iocb.ulpContext,
2396                          ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_state,
2397                          ndlp->nlp_rpi);
2398         pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2399
2400         *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
2401         pcmd += sizeof(uint32_t);
2402
2403         ap = (ADISC *) (pcmd);
2404         ap->hardAL_PA = phba->fc_pref_ALPA;
2405         memcpy(&ap->portName, &vport->fc_portname, sizeof(struct lpfc_name));
2406         memcpy(&ap->nodeName, &vport->fc_nodename, sizeof(struct lpfc_name));
2407         ap->DID = be32_to_cpu(vport->fc_myDID);
2408
2409         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_RSP,
2410                 "Issue ACC ADISC: did:x%x flg:x%x",
2411                 ndlp->nlp_DID, ndlp->nlp_flag, 0);
2412
2413         phba->fc_stat.elsXmitACC++;
2414         elsiocb->iocb_cmpl = lpfc_cmpl_els_rsp;
2415         rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
2416         if (rc == IOCB_ERROR) {
2417                 lpfc_els_free_iocb(phba, elsiocb);
2418                 return 1;
2419         }
2420         return 0;
2421 }
2422
2423 int
2424 lpfc_els_rsp_prli_acc(struct lpfc_vport *vport, struct lpfc_iocbq *oldiocb,
2425                       struct lpfc_nodelist *ndlp)
2426 {
2427         struct lpfc_hba  *phba = vport->phba;
2428         PRLI *npr;
2429         lpfc_vpd_t *vpd;
2430         IOCB_t *icmd;
2431         IOCB_t *oldcmd;
2432         struct lpfc_iocbq *elsiocb;
2433         struct lpfc_sli_ring *pring;
2434         struct lpfc_sli *psli;
2435         uint8_t *pcmd;
2436         uint16_t cmdsize;
2437         int rc;
2438
2439         psli = &phba->sli;
2440         pring = &psli->ring[LPFC_ELS_RING];     /* ELS ring */
2441
2442         cmdsize = sizeof(uint32_t) + sizeof(PRLI);
2443         elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry, ndlp,
2444                 ndlp->nlp_DID, (ELS_CMD_ACC | (ELS_CMD_PRLI & ~ELS_RSP_MASK)));
2445         if (!elsiocb)
2446                 return 1;
2447
2448         icmd = &elsiocb->iocb;
2449         oldcmd = &oldiocb->iocb;
2450         icmd->ulpContext = oldcmd->ulpContext;  /* Xri */
2451         /* Xmit PRLI ACC response tag <ulpIoTag> */
2452         lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
2453                          "0131 Xmit PRLI ACC response tag x%x xri x%x, "
2454                          "did x%x, nlp_flag x%x, nlp_state x%x, rpi x%x\n",
2455                          elsiocb->iotag, elsiocb->iocb.ulpContext,
2456                          ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_state,
2457                          ndlp->nlp_rpi);
2458         pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2459
2460         *((uint32_t *) (pcmd)) = (ELS_CMD_ACC | (ELS_CMD_PRLI & ~ELS_RSP_MASK));
2461         pcmd += sizeof(uint32_t);
2462
2463         /* For PRLI, remainder of payload is PRLI parameter page */
2464         memset(pcmd, 0, sizeof(PRLI));
2465
2466         npr = (PRLI *) pcmd;
2467         vpd = &phba->vpd;
2468         /*
2469          * If our firmware version is 3.20 or later,
2470          * set the following bits for FC-TAPE support.
2471          */
2472         if (vpd->rev.feaLevelHigh >= 0x02) {
2473                 npr->ConfmComplAllowed = 1;
2474                 npr->Retry = 1;
2475                 npr->TaskRetryIdReq = 1;
2476         }
2477
2478         npr->acceptRspCode = PRLI_REQ_EXECUTED;
2479         npr->estabImagePair = 1;
2480         npr->readXferRdyDis = 1;
2481         npr->ConfmComplAllowed = 1;
2482
2483         npr->prliType = PRLI_FCP_TYPE;
2484         npr->initiatorFunc = 1;
2485
2486         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_RSP,
2487                 "Issue ACC PRLI:  did:x%x flg:x%x",
2488                 ndlp->nlp_DID, ndlp->nlp_flag, 0);
2489
2490         phba->fc_stat.elsXmitACC++;
2491         elsiocb->iocb_cmpl = lpfc_cmpl_els_rsp;
2492
2493         rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
2494         if (rc == IOCB_ERROR) {
2495                 lpfc_els_free_iocb(phba, elsiocb);
2496                 return 1;
2497         }
2498         return 0;
2499 }
2500
2501 static int
2502 lpfc_els_rsp_rnid_acc(struct lpfc_vport *vport, uint8_t format,
2503                       struct lpfc_iocbq *oldiocb, struct lpfc_nodelist *ndlp)
2504 {
2505         struct lpfc_hba  *phba = vport->phba;
2506         RNID *rn;
2507         IOCB_t *icmd, *oldcmd;
2508         struct lpfc_iocbq *elsiocb;
2509         struct lpfc_sli_ring *pring;
2510         struct lpfc_sli *psli;
2511         uint8_t *pcmd;
2512         uint16_t cmdsize;
2513         int rc;
2514
2515         psli = &phba->sli;
2516         pring = &psli->ring[LPFC_ELS_RING];
2517
2518         cmdsize = sizeof(uint32_t) + sizeof(uint32_t)
2519                                         + (2 * sizeof(struct lpfc_name));
2520         if (format)
2521                 cmdsize += sizeof(RNID_TOP_DISC);
2522
2523         elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry, ndlp,
2524                                      ndlp->nlp_DID, ELS_CMD_ACC);
2525         if (!elsiocb)
2526                 return 1;
2527
2528         icmd = &elsiocb->iocb;
2529         oldcmd = &oldiocb->iocb;
2530         icmd->ulpContext = oldcmd->ulpContext;  /* Xri */
2531         /* Xmit RNID ACC response tag <ulpIoTag> */
2532         lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
2533                          "0132 Xmit RNID ACC response tag x%x xri x%x\n",
2534                          elsiocb->iotag, elsiocb->iocb.ulpContext);
2535         pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2536         *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
2537         pcmd += sizeof(uint32_t);
2538
2539         memset(pcmd, 0, sizeof(RNID));
2540         rn = (RNID *) (pcmd);
2541         rn->Format = format;
2542         rn->CommonLen = (2 * sizeof(struct lpfc_name));
2543         memcpy(&rn->portName, &vport->fc_portname, sizeof(struct lpfc_name));
2544         memcpy(&rn->nodeName, &vport->fc_nodename, sizeof(struct lpfc_name));
2545         switch (format) {
2546         case 0:
2547                 rn->SpecificLen = 0;
2548                 break;
2549         case RNID_TOPOLOGY_DISC:
2550                 rn->SpecificLen = sizeof(RNID_TOP_DISC);
2551                 memcpy(&rn->un.topologyDisc.portName,
2552                        &vport->fc_portname, sizeof(struct lpfc_name));
2553                 rn->un.topologyDisc.unitType = RNID_HBA;
2554                 rn->un.topologyDisc.physPort = 0;
2555                 rn->un.topologyDisc.attachedNodes = 0;
2556                 break;
2557         default:
2558                 rn->CommonLen = 0;
2559                 rn->SpecificLen = 0;
2560                 break;
2561         }
2562
2563         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_RSP,
2564                 "Issue ACC RNID:  did:x%x flg:x%x",
2565                 ndlp->nlp_DID, ndlp->nlp_flag, 0);
2566
2567         phba->fc_stat.elsXmitACC++;
2568         elsiocb->iocb_cmpl = lpfc_cmpl_els_rsp;
2569         lpfc_nlp_put(ndlp);
2570         elsiocb->context1 = NULL;  /* Don't need ndlp for cmpl,
2571                                     * it could be freed */
2572
2573         rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
2574         if (rc == IOCB_ERROR) {
2575                 lpfc_els_free_iocb(phba, elsiocb);
2576                 return 1;
2577         }
2578         return 0;
2579 }
2580
2581 int
2582 lpfc_els_disc_adisc(struct lpfc_vport *vport)
2583 {
2584         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2585         struct lpfc_nodelist *ndlp, *next_ndlp;
2586         int sentadisc = 0;
2587
2588         /* go thru NPR nodes and issue any remaining ELS ADISCs */
2589         list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
2590                 if (ndlp->nlp_state == NLP_STE_NPR_NODE &&
2591                     (ndlp->nlp_flag & NLP_NPR_2B_DISC) != 0 &&
2592                     (ndlp->nlp_flag & NLP_NPR_ADISC) != 0) {
2593                         spin_lock_irq(shost->host_lock);
2594                         ndlp->nlp_flag &= ~NLP_NPR_ADISC;
2595                         spin_unlock_irq(shost->host_lock);
2596                         ndlp->nlp_prev_state = ndlp->nlp_state;
2597                         lpfc_nlp_set_state(vport, ndlp, NLP_STE_ADISC_ISSUE);
2598                         lpfc_issue_els_adisc(vport, ndlp, 0);
2599                         sentadisc++;
2600                         vport->num_disc_nodes++;
2601                         if (vport->num_disc_nodes >=
2602                             vport->cfg_discovery_threads) {
2603                                 spin_lock_irq(shost->host_lock);
2604                                 vport->fc_flag |= FC_NLP_MORE;
2605                                 spin_unlock_irq(shost->host_lock);
2606                                 break;
2607                         }
2608                 }
2609         }
2610         if (sentadisc == 0) {
2611                 spin_lock_irq(shost->host_lock);
2612                 vport->fc_flag &= ~FC_NLP_MORE;
2613                 spin_unlock_irq(shost->host_lock);
2614         }
2615         return sentadisc;
2616 }
2617
2618 int
2619 lpfc_els_disc_plogi(struct lpfc_vport *vport)
2620 {
2621         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2622         struct lpfc_nodelist *ndlp, *next_ndlp;
2623         int sentplogi = 0;
2624
2625         /* go thru NPR nodes and issue any remaining ELS PLOGIs */
2626         list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
2627                 if (ndlp->nlp_state == NLP_STE_NPR_NODE &&
2628                     (ndlp->nlp_flag & NLP_NPR_2B_DISC) != 0 &&
2629                     (ndlp->nlp_flag & NLP_DELAY_TMO) == 0 &&
2630                     (ndlp->nlp_flag & NLP_NPR_ADISC) == 0) {
2631                         ndlp->nlp_prev_state = ndlp->nlp_state;
2632                         lpfc_nlp_set_state(vport, ndlp, NLP_STE_PLOGI_ISSUE);
2633                         lpfc_issue_els_plogi(vport, ndlp->nlp_DID, 0);
2634                         sentplogi++;
2635                         vport->num_disc_nodes++;
2636                         if (vport->num_disc_nodes >=
2637                             vport->cfg_discovery_threads) {
2638                                 spin_lock_irq(shost->host_lock);
2639                                 vport->fc_flag |= FC_NLP_MORE;
2640                                 spin_unlock_irq(shost->host_lock);
2641                                 break;
2642                         }
2643                 }
2644         }
2645         if (sentplogi == 0) {
2646                 spin_lock_irq(shost->host_lock);
2647                 vport->fc_flag &= ~FC_NLP_MORE;
2648                 spin_unlock_irq(shost->host_lock);
2649         }
2650         return sentplogi;
2651 }
2652
2653 void
2654 lpfc_els_flush_rscn(struct lpfc_vport *vport)
2655 {
2656         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2657         struct lpfc_hba  *phba = vport->phba;
2658         int i;
2659
2660         for (i = 0; i < vport->fc_rscn_id_cnt; i++) {
2661                 lpfc_in_buf_free(phba, vport->fc_rscn_id_list[i]);
2662                 vport->fc_rscn_id_list[i] = NULL;
2663         }
2664         spin_lock_irq(shost->host_lock);
2665         vport->fc_rscn_id_cnt = 0;
2666         vport->fc_flag &= ~(FC_RSCN_MODE | FC_RSCN_DISCOVERY);
2667         spin_unlock_irq(shost->host_lock);
2668         lpfc_can_disctmo(vport);
2669 }
2670
2671 int
2672 lpfc_rscn_payload_check(struct lpfc_vport *vport, uint32_t did)
2673 {
2674         D_ID ns_did;
2675         D_ID rscn_did;
2676         uint32_t *lp;
2677         uint32_t payload_len, i;
2678
2679         ns_did.un.word = did;
2680
2681         /* Never match fabric nodes for RSCNs */
2682         if ((did & Fabric_DID_MASK) == Fabric_DID_MASK)
2683                 return 0;
2684
2685         /* If we are doing a FULL RSCN rediscovery, match everything */
2686         if (vport->fc_flag & FC_RSCN_DISCOVERY)
2687                 return did;
2688
2689         for (i = 0; i < vport->fc_rscn_id_cnt; i++) {
2690                 lp = vport->fc_rscn_id_list[i]->virt;
2691                 payload_len = be32_to_cpu(*lp++ & ~ELS_CMD_MASK);
2692                 payload_len -= sizeof(uint32_t);        /* take off word 0 */
2693                 while (payload_len) {
2694                         rscn_did.un.word = be32_to_cpu(*lp++);
2695                         payload_len -= sizeof(uint32_t);
2696                         switch (rscn_did.un.b.resv) {
2697                         case 0: /* Single N_Port ID effected */
2698                                 if (ns_did.un.word == rscn_did.un.word)
2699                                         return did;
2700                                 break;
2701                         case 1: /* Whole N_Port Area effected */
2702                                 if ((ns_did.un.b.domain == rscn_did.un.b.domain)
2703                                     && (ns_did.un.b.area == rscn_did.un.b.area))
2704                                         return did;
2705                                 break;
2706                         case 2: /* Whole N_Port Domain effected */
2707                                 if (ns_did.un.b.domain == rscn_did.un.b.domain)
2708                                         return did;
2709                                 break;
2710                         default:
2711                                 /* Unknown Identifier in RSCN node */
2712                                 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
2713                                                  "0217 Unknown Identifier in "
2714                                                  "RSCN payload Data: x%x\n",
2715                                                  rscn_did.un.word);
2716                         case 3: /* Whole Fabric effected */
2717                                 return did;
2718                         }
2719                 }
2720         }
2721         return 0;
2722 }
2723
2724 static int
2725 lpfc_rscn_recovery_check(struct lpfc_vport *vport)
2726 {
2727         struct lpfc_nodelist *ndlp = NULL;
2728
2729         /* Look at all nodes effected by pending RSCNs and move
2730          * them to NPR state.
2731          */
2732
2733         list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
2734                 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE ||
2735                     lpfc_rscn_payload_check(vport, ndlp->nlp_DID) == 0)
2736                         continue;
2737
2738                 lpfc_disc_state_machine(vport, ndlp, NULL,
2739                                                 NLP_EVT_DEVICE_RECOVERY);
2740
2741                 /*
2742                  * Make sure NLP_DELAY_TMO is NOT running after a device
2743                  * recovery event.
2744                  */
2745                 if (ndlp->nlp_flag & NLP_DELAY_TMO)
2746                         lpfc_cancel_retry_delay_tmo(vport, ndlp);
2747         }
2748
2749         return 0;
2750 }
2751
2752 static int
2753 lpfc_els_rcv_rscn(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
2754                   struct lpfc_nodelist *ndlp)
2755 {
2756         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2757         struct lpfc_hba  *phba = vport->phba;
2758         struct lpfc_dmabuf *pcmd;
2759         uint32_t *lp, *datap;
2760         IOCB_t *icmd;
2761         uint32_t payload_len, length, nportid, *cmd;
2762         int rscn_cnt = vport->fc_rscn_id_cnt;
2763         int rscn_id = 0, hba_id = 0;
2764         int i;
2765
2766         icmd = &cmdiocb->iocb;
2767         pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
2768         lp = (uint32_t *) pcmd->virt;
2769
2770         payload_len = be32_to_cpu(*lp++ & ~ELS_CMD_MASK);
2771         payload_len -= sizeof(uint32_t);        /* take off word 0 */
2772         /* RSCN received */
2773         lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
2774                          "0214 RSCN received Data: x%x x%x x%x x%x\n",
2775                          vport->fc_flag, payload_len, *lp, rscn_cnt);
2776         for (i = 0; i < payload_len/sizeof(uint32_t); i++)
2777                 fc_host_post_event(shost, fc_get_event_number(),
2778                         FCH_EVT_RSCN, lp[i]);
2779
2780         /* If we are about to begin discovery, just ACC the RSCN.
2781          * Discovery processing will satisfy it.
2782          */
2783         if (vport->port_state <= LPFC_NS_QRY) {
2784                 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
2785                         "RCV RSCN ignore: did:x%x/ste:x%x flg:x%x",
2786                         ndlp->nlp_DID, vport->port_state, ndlp->nlp_flag);
2787
2788                 lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL);
2789                 return 0;
2790         }
2791
2792         /* If this RSCN just contains NPortIDs for other vports on this HBA,
2793          * just ACC and ignore it.
2794          */
2795         if ((phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) &&
2796                 !(vport->cfg_peer_port_login)) {
2797                 i = payload_len;
2798                 datap = lp;
2799                 while (i > 0) {
2800                         nportid = *datap++;
2801                         nportid = ((be32_to_cpu(nportid)) & Mask_DID);
2802                         i -= sizeof(uint32_t);
2803                         rscn_id++;
2804                         if (lpfc_find_vport_by_did(phba, nportid))
2805                                 hba_id++;
2806                 }
2807                 if (rscn_id == hba_id) {
2808                         /* ALL NPortIDs in RSCN are on HBA */
2809                         lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
2810                                          "0214 Ignore RSCN "
2811                                          "Data: x%x x%x x%x x%x\n",
2812                                          vport->fc_flag, payload_len,
2813                                          *lp, rscn_cnt);
2814                         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
2815                                 "RCV RSCN vport:  did:x%x/ste:x%x flg:x%x",
2816                                 ndlp->nlp_DID, vport->port_state,
2817                                 ndlp->nlp_flag);
2818
2819                         lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb,
2820                                 ndlp, NULL);
2821                         return 0;
2822                 }
2823         }
2824
2825         /* If we are already processing an RSCN, save the received
2826          * RSCN payload buffer, cmdiocb->context2 to process later.
2827          */
2828         if (vport->fc_flag & (FC_RSCN_MODE | FC_NDISC_ACTIVE)) {
2829                 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
2830                         "RCV RSCN defer:  did:x%x/ste:x%x flg:x%x",
2831                         ndlp->nlp_DID, vport->port_state, ndlp->nlp_flag);
2832
2833                 vport->fc_flag |= FC_RSCN_DEFERRED;
2834                 if ((rscn_cnt < FC_MAX_HOLD_RSCN) &&
2835                     !(vport->fc_flag & FC_RSCN_DISCOVERY)) {
2836                         spin_lock_irq(shost->host_lock);
2837                         vport->fc_flag |= FC_RSCN_MODE;
2838                         spin_unlock_irq(shost->host_lock);
2839                         if (rscn_cnt) {
2840                                 cmd = vport->fc_rscn_id_list[rscn_cnt-1]->virt;
2841                                 length = be32_to_cpu(*cmd & ~ELS_CMD_MASK);
2842                         }
2843                         if ((rscn_cnt) &&
2844                             (payload_len + length <= LPFC_BPL_SIZE)) {
2845                                 *cmd &= ELS_CMD_MASK;
2846                                 *cmd |= be32_to_cpu(payload_len + length);
2847                                 memcpy(((uint8_t *)cmd) + length, lp,
2848                                        payload_len);
2849                         } else {
2850                                 vport->fc_rscn_id_list[rscn_cnt] = pcmd;
2851                                 vport->fc_rscn_id_cnt++;
2852                                 /* If we zero, cmdiocb->context2, the calling
2853                                  * routine will not try to free it.
2854                                  */
2855                                 cmdiocb->context2 = NULL;
2856                         }
2857
2858                         /* Deferred RSCN */
2859                         lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
2860                                          "0235 Deferred RSCN "
2861                                          "Data: x%x x%x x%x\n",
2862                                          vport->fc_rscn_id_cnt, vport->fc_flag,
2863                                          vport->port_state);
2864                 } else {
2865                         spin_lock_irq(shost->host_lock);
2866                         vport->fc_flag |= FC_RSCN_DISCOVERY;
2867                         spin_unlock_irq(shost->host_lock);
2868                         /* ReDiscovery RSCN */
2869                         lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
2870                                          "0234 ReDiscovery RSCN "
2871                                          "Data: x%x x%x x%x\n",
2872                                          vport->fc_rscn_id_cnt, vport->fc_flag,
2873                                          vport->port_state);
2874                 }
2875                 /* Send back ACC */
2876                 lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL);
2877
2878                 /* send RECOVERY event for ALL nodes that match RSCN payload */
2879                 lpfc_rscn_recovery_check(vport);
2880                 vport->fc_flag &= ~FC_RSCN_DEFERRED;
2881                 return 0;
2882         }
2883
2884         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
2885                 "RCV RSCN:        did:x%x/ste:x%x flg:x%x",
2886                 ndlp->nlp_DID, vport->port_state, ndlp->nlp_flag);
2887
2888         spin_lock_irq(shost->host_lock);
2889         vport->fc_flag |= FC_RSCN_MODE;
2890         spin_unlock_irq(shost->host_lock);
2891         vport->fc_rscn_id_list[vport->fc_rscn_id_cnt++] = pcmd;
2892         /*
2893          * If we zero, cmdiocb->context2, the calling routine will
2894          * not try to free it.
2895          */
2896         cmdiocb->context2 = NULL;
2897
2898         lpfc_set_disctmo(vport);
2899
2900         /* Send back ACC */
2901         lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL);
2902
2903         /* send RECOVERY event for ALL nodes that match RSCN payload */
2904         lpfc_rscn_recovery_check(vport);
2905
2906         return lpfc_els_handle_rscn(vport);
2907 }
2908
2909 int
2910 lpfc_els_handle_rscn(struct lpfc_vport *vport)
2911 {
2912         struct lpfc_nodelist *ndlp;
2913         struct lpfc_hba *phba = vport->phba;
2914
2915         /* Ignore RSCN if the port is being torn down. */
2916         if (vport->load_flag & FC_UNLOADING) {
2917                 lpfc_els_flush_rscn(vport);
2918                 return 0;
2919         }
2920
2921         /* Start timer for RSCN processing */
2922         lpfc_set_disctmo(vport);
2923
2924         /* RSCN processed */
2925         lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
2926                          "0215 RSCN processed Data: x%x x%x x%x x%x\n",
2927                          vport->fc_flag, 0, vport->fc_rscn_id_cnt,
2928                          vport->port_state);
2929
2930         /* To process RSCN, first compare RSCN data with NameServer */
2931         vport->fc_ns_retry = 0;
2932         ndlp = lpfc_findnode_did(vport, NameServer_DID);
2933         if (ndlp && ndlp->nlp_state == NLP_STE_UNMAPPED_NODE) {
2934                 /* Good ndlp, issue CT Request to NameServer */
2935                 if (lpfc_ns_cmd(vport, SLI_CTNS_GID_FT, 0, 0) == 0)
2936                         /* Wait for NameServer query cmpl before we can
2937                            continue */
2938                         return 1;
2939         } else {
2940                 /* If login to NameServer does not exist, issue one */
2941                 /* Good status, issue PLOGI to NameServer */
2942                 ndlp = lpfc_findnode_did(vport, NameServer_DID);
2943                 if (ndlp)
2944                         /* Wait for NameServer login cmpl before we can
2945                            continue */
2946                         return 1;
2947
2948                 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
2949                 if (!ndlp) {
2950                         lpfc_els_flush_rscn(vport);
2951                         return 0;
2952                 } else {
2953                         lpfc_nlp_init(vport, ndlp, NameServer_DID);
2954                         ndlp->nlp_type |= NLP_FABRIC;
2955                         ndlp->nlp_prev_state = ndlp->nlp_state;
2956                         lpfc_nlp_set_state(vport, ndlp, NLP_STE_PLOGI_ISSUE);
2957                         lpfc_issue_els_plogi(vport, NameServer_DID, 0);
2958                         /* Wait for NameServer login cmpl before we can
2959                            continue */
2960                         return 1;
2961                 }
2962         }
2963
2964         lpfc_els_flush_rscn(vport);
2965         return 0;
2966 }
2967
2968 static int
2969 lpfc_els_rcv_flogi(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
2970                    struct lpfc_nodelist *ndlp)
2971 {
2972         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2973         struct lpfc_hba  *phba = vport->phba;
2974         struct lpfc_dmabuf *pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
2975         uint32_t *lp = (uint32_t *) pcmd->virt;
2976         IOCB_t *icmd = &cmdiocb->iocb;
2977         struct serv_parm *sp;
2978         LPFC_MBOXQ_t *mbox;
2979         struct ls_rjt stat;
2980         uint32_t cmd, did;
2981         int rc;
2982
2983         cmd = *lp++;
2984         sp = (struct serv_parm *) lp;
2985
2986         /* FLOGI received */
2987
2988         lpfc_set_disctmo(vport);
2989
2990         if (phba->fc_topology == TOPOLOGY_LOOP) {
2991                 /* We should never receive a FLOGI in loop mode, ignore it */
2992                 did = icmd->un.elsreq64.remoteID;
2993
2994                 /* An FLOGI ELS command <elsCmd> was received from DID <did> in
2995                    Loop Mode */
2996                 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
2997                                  "0113 An FLOGI ELS command x%x was "
2998                                  "received from DID x%x in Loop Mode\n",
2999                                  cmd, did);
3000                 return 1;
3001         }
3002
3003         did = Fabric_DID;
3004
3005         if ((lpfc_check_sparm(vport, ndlp, sp, CLASS3))) {
3006                 /* For a FLOGI we accept, then if our portname is greater
3007                  * then the remote portname we initiate Nport login.
3008                  */
3009
3010                 rc = memcmp(&vport->fc_portname, &sp->portName,
3011                             sizeof(struct lpfc_name));
3012
3013                 if (!rc) {
3014                         mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
3015                         if (!mbox)
3016                                 return 1;
3017
3018                         lpfc_linkdown(phba);
3019                         lpfc_init_link(phba, mbox,
3020                                        phba->cfg_topology,
3021                                        phba->cfg_link_speed);
3022                         mbox->mb.un.varInitLnk.lipsr_AL_PA = 0;
3023                         mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
3024                         mbox->vport = vport;
3025                         rc = lpfc_sli_issue_mbox
3026                                 (phba, mbox, (MBX_NOWAIT | MBX_STOP_IOCB));
3027                         lpfc_set_loopback_flag(phba);
3028                         if (rc == MBX_NOT_FINISHED) {
3029                                 mempool_free(mbox, phba->mbox_mem_pool);
3030                         }
3031                         return 1;
3032                 } else if (rc > 0) {    /* greater than */
3033                         spin_lock_irq(shost->host_lock);
3034                         vport->fc_flag |= FC_PT2PT_PLOGI;
3035                         spin_unlock_irq(shost->host_lock);
3036                 }
3037                 spin_lock_irq(shost->host_lock);
3038                 vport->fc_flag |= FC_PT2PT;
3039                 vport->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP);
3040                 spin_unlock_irq(shost->host_lock);
3041         } else {
3042                 /* Reject this request because invalid parameters */
3043                 stat.un.b.lsRjtRsvd0 = 0;
3044                 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
3045                 stat.un.b.lsRjtRsnCodeExp = LSEXP_SPARM_OPTIONS;
3046                 stat.un.b.vendorUnique = 0;
3047                 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp,
3048                         NULL);
3049                 return 1;
3050         }
3051
3052         /* Send back ACC */
3053         lpfc_els_rsp_acc(vport, ELS_CMD_PLOGI, cmdiocb, ndlp, NULL);
3054
3055         return 0;
3056 }
3057
3058 static int
3059 lpfc_els_rcv_rnid(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
3060                   struct lpfc_nodelist *ndlp)
3061 {
3062         struct lpfc_dmabuf *pcmd;
3063         uint32_t *lp;
3064         IOCB_t *icmd;
3065         RNID *rn;
3066         struct ls_rjt stat;
3067         uint32_t cmd, did;
3068
3069         icmd = &cmdiocb->iocb;
3070         did = icmd->un.elsreq64.remoteID;
3071         pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
3072         lp = (uint32_t *) pcmd->virt;
3073
3074         cmd = *lp++;
3075         rn = (RNID *) lp;
3076
3077         /* RNID received */
3078
3079         switch (rn->Format) {
3080         case 0:
3081         case RNID_TOPOLOGY_DISC:
3082                 /* Send back ACC */
3083                 lpfc_els_rsp_rnid_acc(vport, rn->Format, cmdiocb, ndlp);
3084                 break;
3085         default:
3086                 /* Reject this request because format not supported */
3087                 stat.un.b.lsRjtRsvd0 = 0;
3088                 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
3089                 stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
3090                 stat.un.b.vendorUnique = 0;
3091                 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp,
3092                         NULL);
3093         }
3094         return 0;
3095 }
3096
3097 static int
3098 lpfc_els_rcv_lirr(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
3099                   struct lpfc_nodelist *ndlp)
3100 {
3101         struct ls_rjt stat;
3102
3103         /* For now, unconditionally reject this command */
3104         stat.un.b.lsRjtRsvd0 = 0;
3105         stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
3106         stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
3107         stat.un.b.vendorUnique = 0;
3108         lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp, NULL);
3109         return 0;
3110 }
3111
3112 static void
3113 lpfc_els_rsp_rps_acc(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
3114 {
3115         struct lpfc_sli *psli = &phba->sli;
3116         struct lpfc_sli_ring *pring = &psli->ring[LPFC_ELS_RING];
3117         MAILBOX_t *mb;
3118         IOCB_t *icmd;
3119         RPS_RSP *rps_rsp;
3120         uint8_t *pcmd;
3121         struct lpfc_iocbq *elsiocb;
3122         struct lpfc_nodelist *ndlp;
3123         uint16_t xri, status;
3124         uint32_t cmdsize;
3125
3126         mb = &pmb->mb;
3127
3128         ndlp = (struct lpfc_nodelist *) pmb->context2;
3129         xri = (uint16_t) ((unsigned long)(pmb->context1));
3130         pmb->context1 = NULL;
3131         pmb->context2 = NULL;
3132
3133         if (mb->mbxStatus) {
3134                 mempool_free(pmb, phba->mbox_mem_pool);
3135                 return;
3136         }
3137
3138         cmdsize = sizeof(RPS_RSP) + sizeof(uint32_t);
3139         mempool_free(pmb, phba->mbox_mem_pool);
3140         elsiocb = lpfc_prep_els_iocb(phba->pport, 0, cmdsize,
3141                                      lpfc_max_els_tries, ndlp,
3142                                      ndlp->nlp_DID, ELS_CMD_ACC);
3143         lpfc_nlp_put(ndlp);
3144         if (!elsiocb)
3145                 return;
3146
3147         icmd = &elsiocb->iocb;
3148         icmd->ulpContext = xri;
3149
3150         pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
3151         *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
3152         pcmd += sizeof(uint32_t); /* Skip past command */
3153         rps_rsp = (RPS_RSP *)pcmd;
3154
3155         if (phba->fc_topology != TOPOLOGY_LOOP)
3156                 status = 0x10;
3157         else
3158                 status = 0x8;
3159         if (phba->pport->fc_flag & FC_FABRIC)
3160                 status |= 0x4;
3161
3162         rps_rsp->rsvd1 = 0;
3163         rps_rsp->portStatus = be16_to_cpu(status);
3164         rps_rsp->linkFailureCnt = be32_to_cpu(mb->un.varRdLnk.linkFailureCnt);
3165         rps_rsp->lossSyncCnt = be32_to_cpu(mb->un.varRdLnk.lossSyncCnt);
3166         rps_rsp->lossSignalCnt = be32_to_cpu(mb->un.varRdLnk.lossSignalCnt);
3167         rps_rsp->primSeqErrCnt = be32_to_cpu(mb->un.varRdLnk.primSeqErrCnt);
3168         rps_rsp->invalidXmitWord = be32_to_cpu(mb->un.varRdLnk.invalidXmitWord);
3169         rps_rsp->crcCnt = be32_to_cpu(mb->un.varRdLnk.crcCnt);
3170         /* Xmit ELS RPS ACC response tag <ulpIoTag> */
3171         lpfc_printf_vlog(ndlp->vport, KERN_INFO, LOG_ELS,
3172                          "0118 Xmit ELS RPS ACC response tag x%x xri x%x, "
3173                          "did x%x, nlp_flag x%x, nlp_state x%x, rpi x%x\n",
3174                          elsiocb->iotag, elsiocb->iocb.ulpContext,
3175                          ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_state,
3176                          ndlp->nlp_rpi);
3177         elsiocb->iocb_cmpl = lpfc_cmpl_els_rsp;
3178         phba->fc_stat.elsXmitACC++;
3179         if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR)
3180                 lpfc_els_free_iocb(phba, elsiocb);
3181         return;
3182 }
3183
3184 static int
3185 lpfc_els_rcv_rps(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
3186                  struct lpfc_nodelist *ndlp)
3187 {
3188         struct lpfc_hba *phba = vport->phba;
3189         uint32_t *lp;
3190         uint8_t flag;
3191         LPFC_MBOXQ_t *mbox;
3192         struct lpfc_dmabuf *pcmd;
3193         RPS *rps;
3194         struct ls_rjt stat;
3195
3196         if ((ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) &&
3197             (ndlp->nlp_state != NLP_STE_MAPPED_NODE)) {
3198                 stat.un.b.lsRjtRsvd0 = 0;
3199                 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
3200                 stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
3201                 stat.un.b.vendorUnique = 0;
3202                 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp,
3203                         NULL);
3204         }
3205
3206         pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
3207         lp = (uint32_t *) pcmd->virt;
3208         flag = (be32_to_cpu(*lp++) & 0xf);
3209         rps = (RPS *) lp;
3210
3211         if ((flag == 0) ||
3212             ((flag == 1) && (be32_to_cpu(rps->un.portNum) == 0)) ||
3213             ((flag == 2) && (memcmp(&rps->un.portName, &vport->fc_portname,
3214                                     sizeof(struct lpfc_name)) == 0))) {
3215
3216                 printk("Fix me....\n");
3217                 dump_stack();
3218                 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_ATOMIC);
3219                 if (mbox) {
3220                         lpfc_read_lnk_stat(phba, mbox);
3221                         mbox->context1 =
3222                             (void *)((unsigned long) cmdiocb->iocb.ulpContext);
3223                         mbox->context2 = lpfc_nlp_get(ndlp);
3224                         mbox->vport = vport;
3225                         mbox->mbox_cmpl = lpfc_els_rsp_rps_acc;
3226                         if (lpfc_sli_issue_mbox (phba, mbox,
3227                             (MBX_NOWAIT | MBX_STOP_IOCB)) != MBX_NOT_FINISHED)
3228                                 /* Mbox completion will send ELS Response */
3229                                 return 0;
3230
3231                         lpfc_nlp_put(ndlp);
3232                         mempool_free(mbox, phba->mbox_mem_pool);
3233                 }
3234         }
3235         stat.un.b.lsRjtRsvd0 = 0;
3236         stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
3237         stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
3238         stat.un.b.vendorUnique = 0;
3239         lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp, NULL);
3240         return 0;
3241 }
3242
3243 static int
3244 lpfc_els_rsp_rpl_acc(struct lpfc_vport *vport, uint16_t cmdsize,
3245                      struct lpfc_iocbq *oldiocb, struct lpfc_nodelist *ndlp)
3246 {
3247         struct lpfc_hba *phba = vport->phba;
3248         IOCB_t *icmd, *oldcmd;
3249         RPL_RSP rpl_rsp;
3250         struct lpfc_iocbq *elsiocb;
3251         struct lpfc_sli *psli = &phba->sli;
3252         struct lpfc_sli_ring *pring = &psli->ring[LPFC_ELS_RING];
3253         uint8_t *pcmd;
3254
3255         elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry, ndlp,
3256                                      ndlp->nlp_DID, ELS_CMD_ACC);
3257
3258         if (!elsiocb)
3259                 return 1;
3260
3261         icmd = &elsiocb->iocb;
3262         oldcmd = &oldiocb->iocb;
3263         icmd->ulpContext = oldcmd->ulpContext;  /* Xri */
3264
3265         pcmd = (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
3266         *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
3267         pcmd += sizeof(uint16_t);
3268         *((uint16_t *)(pcmd)) = be16_to_cpu(cmdsize);
3269         pcmd += sizeof(uint16_t);
3270
3271         /* Setup the RPL ACC payload */
3272         rpl_rsp.listLen = be32_to_cpu(1);
3273         rpl_rsp.index = 0;
3274         rpl_rsp.port_num_blk.portNum = 0;
3275         rpl_rsp.port_num_blk.portID = be32_to_cpu(vport->fc_myDID);
3276         memcpy(&rpl_rsp.port_num_blk.portName, &vport->fc_portname,
3277             sizeof(struct lpfc_name));
3278         memcpy(pcmd, &rpl_rsp, cmdsize - sizeof(uint32_t));
3279         /* Xmit ELS RPL ACC response tag <ulpIoTag> */
3280         lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
3281                          "0120 Xmit ELS RPL ACC response tag x%x "
3282                          "xri x%x, did x%x, nlp_flag x%x, nlp_state x%x, "
3283                          "rpi x%x\n",
3284                          elsiocb->iotag, elsiocb->iocb.ulpContext,
3285                          ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_state,
3286                          ndlp->nlp_rpi);
3287         elsiocb->iocb_cmpl = lpfc_cmpl_els_rsp;
3288         phba->fc_stat.elsXmitACC++;
3289         if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
3290                 lpfc_els_free_iocb(phba, elsiocb);
3291                 return 1;
3292         }
3293         return 0;
3294 }
3295
3296 static int
3297 lpfc_els_rcv_rpl(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
3298                  struct lpfc_nodelist *ndlp)
3299 {
3300         struct lpfc_dmabuf *pcmd;
3301         uint32_t *lp;
3302         uint32_t maxsize;
3303         uint16_t cmdsize;
3304         RPL *rpl;
3305         struct ls_rjt stat;
3306
3307         if ((ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) &&
3308             (ndlp->nlp_state != NLP_STE_MAPPED_NODE)) {
3309                 stat.un.b.lsRjtRsvd0 = 0;
3310                 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
3311                 stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
3312                 stat.un.b.vendorUnique = 0;
3313                 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp,
3314                         NULL);
3315         }
3316
3317         pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
3318         lp = (uint32_t *) pcmd->virt;
3319         rpl = (RPL *) (lp + 1);
3320
3321         maxsize = be32_to_cpu(rpl->maxsize);
3322
3323         /* We support only one port */
3324         if ((rpl->index == 0) &&
3325             ((maxsize == 0) ||
3326              ((maxsize * sizeof(uint32_t)) >= sizeof(RPL_RSP)))) {
3327                 cmdsize = sizeof(uint32_t) + sizeof(RPL_RSP);
3328         } else {
3329                 cmdsize = sizeof(uint32_t) + maxsize * sizeof(uint32_t);
3330         }
3331         lpfc_els_rsp_rpl_acc(vport, cmdsize, cmdiocb, ndlp);
3332
3333         return 0;
3334 }
3335
3336 static int
3337 lpfc_els_rcv_farp(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
3338                   struct lpfc_nodelist *ndlp)
3339 {
3340         struct lpfc_dmabuf *pcmd;
3341         uint32_t *lp;
3342         IOCB_t *icmd;
3343         FARP *fp;
3344         uint32_t cmd, cnt, did;
3345
3346         icmd = &cmdiocb->iocb;
3347         did = icmd->un.elsreq64.remoteID;
3348         pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
3349         lp = (uint32_t *) pcmd->virt;
3350
3351         cmd = *lp++;
3352         fp = (FARP *) lp;
3353         /* FARP-REQ received from DID <did> */
3354         lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
3355                          "0601 FARP-REQ received from DID x%x\n", did);
3356         /* We will only support match on WWPN or WWNN */
3357         if (fp->Mflags & ~(FARP_MATCH_NODE | FARP_MATCH_PORT)) {
3358                 return 0;
3359         }
3360
3361         cnt = 0;
3362         /* If this FARP command is searching for my portname */
3363         if (fp->Mflags & FARP_MATCH_PORT) {
3364                 if (memcmp(&fp->RportName, &vport->fc_portname,
3365                            sizeof(struct lpfc_name)) == 0)
3366                         cnt = 1;
3367         }
3368
3369         /* If this FARP command is searching for my nodename */
3370         if (fp->Mflags & FARP_MATCH_NODE) {
3371                 if (memcmp(&fp->RnodeName, &vport->fc_nodename,
3372                            sizeof(struct lpfc_name)) == 0)
3373                         cnt = 1;
3374         }
3375
3376         if (cnt) {
3377                 if ((ndlp->nlp_state == NLP_STE_UNMAPPED_NODE) ||
3378                    (ndlp->nlp_state == NLP_STE_MAPPED_NODE)) {
3379                         /* Log back into the node before sending the FARP. */
3380                         if (fp->Rflags & FARP_REQUEST_PLOGI) {
3381                                 ndlp->nlp_prev_state = ndlp->nlp_state;
3382                                 lpfc_nlp_set_state(vport, ndlp,
3383                                                    NLP_STE_PLOGI_ISSUE);
3384                                 lpfc_issue_els_plogi(vport, ndlp->nlp_DID, 0);
3385                         }
3386
3387                         /* Send a FARP response to that node */
3388                         if (fp->Rflags & FARP_REQUEST_FARPR)
3389                                 lpfc_issue_els_farpr(vport, did, 0);
3390                 }
3391         }
3392         return 0;
3393 }
3394
3395 static int
3396 lpfc_els_rcv_farpr(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
3397                    struct lpfc_nodelist  *ndlp)
3398 {
3399         struct lpfc_dmabuf *pcmd;
3400         uint32_t *lp;
3401         IOCB_t *icmd;
3402         uint32_t cmd, did;
3403
3404         icmd = &cmdiocb->iocb;
3405         did = icmd->un.elsreq64.remoteID;
3406         pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
3407         lp = (uint32_t *) pcmd->virt;
3408
3409         cmd = *lp++;
3410         /* FARP-RSP received from DID <did> */
3411         lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
3412                          "0600 FARP-RSP received from DID x%x\n", did);
3413         /* ACCEPT the Farp resp request */
3414         lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL);
3415
3416         return 0;
3417 }
3418
3419 static int
3420 lpfc_els_rcv_fan(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
3421                  struct lpfc_nodelist *fan_ndlp)
3422 {
3423         struct lpfc_dmabuf *pcmd;
3424         uint32_t *lp;
3425         IOCB_t *icmd;
3426         uint32_t cmd, did;
3427         FAN *fp;
3428         struct lpfc_nodelist *ndlp, *next_ndlp;
3429         struct lpfc_hba *phba = vport->phba;
3430
3431         /* FAN received */
3432         lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
3433                          "0265 FAN received\n");
3434         icmd = &cmdiocb->iocb;
3435         did = icmd->un.elsreq64.remoteID;
3436         pcmd = (struct lpfc_dmabuf *)cmdiocb->context2;
3437         lp = (uint32_t *)pcmd->virt;
3438
3439         cmd = *lp++;
3440         fp = (FAN *) lp;
3441
3442         /* FAN received; Fan does not have a reply sequence */
3443
3444         if (phba->pport->port_state == LPFC_LOCAL_CFG_LINK) {
3445                 if ((memcmp(&phba->fc_fabparam.nodeName, &fp->FnodeName,
3446                         sizeof(struct lpfc_name)) != 0) ||
3447                     (memcmp(&phba->fc_fabparam.portName, &fp->FportName,
3448                         sizeof(struct lpfc_name)) != 0)) {
3449                         /*
3450                          * This node has switched fabrics.  FLOGI is required
3451                          * Clean up the old rpi's
3452                          */
3453
3454                         list_for_each_entry_safe(ndlp, next_ndlp,
3455                                                  &vport->fc_nodes, nlp_listp) {
3456                                 if (ndlp->nlp_state != NLP_STE_NPR_NODE)
3457                                         continue;
3458                                 if (ndlp->nlp_type & NLP_FABRIC) {
3459                                         /*
3460                                          * Clean up old Fabric, Nameserver and
3461                                          * other NLP_FABRIC logins
3462                                          */
3463                                         lpfc_drop_node(vport, ndlp);
3464                                 } else if (!(ndlp->nlp_flag & NLP_NPR_ADISC)) {
3465                                         /* Fail outstanding I/O now since this
3466                                          * device is marked for PLOGI
3467                                          */
3468                                         lpfc_unreg_rpi(vport, ndlp);
3469                                 }
3470                         }
3471
3472                         vport->port_state = LPFC_FLOGI;
3473                         lpfc_set_disctmo(vport);
3474                         lpfc_initial_flogi(vport);
3475                         return 0;
3476                 }
3477                 /* Discovery not needed,
3478                  * move the nodes to their original state.
3479                  */
3480                 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes,
3481                                          nlp_listp) {
3482                         if (ndlp->nlp_state != NLP_STE_NPR_NODE)
3483                                 continue;
3484
3485                         switch (ndlp->nlp_prev_state) {
3486                         case NLP_STE_UNMAPPED_NODE:
3487                                 ndlp->nlp_prev_state = NLP_STE_NPR_NODE;
3488                                 lpfc_nlp_set_state(vport, ndlp,
3489                                                    NLP_STE_UNMAPPED_NODE);
3490                                 break;
3491
3492                         case NLP_STE_MAPPED_NODE:
3493                                 ndlp->nlp_prev_state = NLP_STE_NPR_NODE;
3494                                 lpfc_nlp_set_state(vport, ndlp,
3495                                                    NLP_STE_MAPPED_NODE);
3496                                 break;
3497
3498                         default:
3499                                 break;
3500                         }
3501                 }
3502
3503                 /* Start discovery - this should just do CLEAR_LA */
3504                 lpfc_disc_start(vport);
3505         }
3506         return 0;
3507 }
3508
3509 void
3510 lpfc_els_timeout(unsigned long ptr)
3511 {
3512         struct lpfc_vport *vport = (struct lpfc_vport *) ptr;
3513         struct lpfc_hba   *phba = vport->phba;
3514         unsigned long iflag;
3515
3516         spin_lock_irqsave(&vport->work_port_lock, iflag);
3517         if ((vport->work_port_events & WORKER_ELS_TMO) == 0) {
3518                 vport->work_port_events |= WORKER_ELS_TMO;
3519                 spin_unlock_irqrestore(&vport->work_port_lock, iflag);
3520
3521                 spin_lock_irqsave(&phba->hbalock, iflag);
3522                 if (phba->work_wait)
3523                         lpfc_worker_wake_up(phba);
3524                 spin_unlock_irqrestore(&phba->hbalock, iflag);
3525         }
3526         else
3527                 spin_unlock_irqrestore(&vport->work_port_lock, iflag);
3528         return;
3529 }
3530
3531 void
3532 lpfc_els_timeout_handler(struct lpfc_vport *vport)
3533 {
3534         struct lpfc_hba  *phba = vport->phba;
3535         struct lpfc_sli_ring *pring;
3536         struct lpfc_iocbq *tmp_iocb, *piocb;
3537         IOCB_t *cmd = NULL;
3538         struct lpfc_dmabuf *pcmd;
3539         uint32_t els_command = 0;
3540         uint32_t timeout;
3541         uint32_t remote_ID = 0xffffffff;
3542
3543         /* If the timer is already canceled do nothing */
3544         if ((vport->work_port_events & WORKER_ELS_TMO) == 0) {
3545                 return;
3546         }
3547         spin_lock_irq(&phba->hbalock);
3548         timeout = (uint32_t)(phba->fc_ratov << 1);
3549
3550         pring = &phba->sli.ring[LPFC_ELS_RING];
3551
3552         list_for_each_entry_safe(piocb, tmp_iocb, &pring->txcmplq, list) {
3553                 cmd = &piocb->iocb;
3554
3555                 if ((piocb->iocb_flag & LPFC_IO_LIBDFC) != 0 ||
3556                     piocb->iocb.ulpCommand == CMD_ABORT_XRI_CN ||
3557                     piocb->iocb.ulpCommand == CMD_CLOSE_XRI_CN)
3558                         continue;
3559
3560                 if (piocb->vport != vport)
3561                         continue;
3562
3563                 pcmd = (struct lpfc_dmabuf *) piocb->context2;
3564                 if (pcmd)
3565                         els_command = *(uint32_t *) (pcmd->virt);
3566
3567                 if (els_command == ELS_CMD_FARP ||
3568                     els_command == ELS_CMD_FARPR ||
3569                     els_command == ELS_CMD_FDISC)
3570                         continue;
3571
3572                 if (vport != piocb->vport)
3573                         continue;
3574
3575                 if (piocb->drvrTimeout > 0) {
3576                         if (piocb->drvrTimeout >= timeout)
3577                                 piocb->drvrTimeout -= timeout;
3578                         else
3579                                 piocb->drvrTimeout = 0;
3580                         continue;
3581                 }
3582
3583                 remote_ID = 0xffffffff;
3584                 if (cmd->ulpCommand != CMD_GEN_REQUEST64_CR)
3585                         remote_ID = cmd->un.elsreq64.remoteID;
3586                 else {
3587                         struct lpfc_nodelist *ndlp;
3588                         ndlp = __lpfc_findnode_rpi(vport, cmd->ulpContext);
3589                         if (ndlp)
3590                                 remote_ID = ndlp->nlp_DID;
3591                 }
3592                 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
3593                                  "0127 ELS timeout Data: x%x x%x x%x "
3594                                  "x%x\n", els_command,
3595                                  remote_ID, cmd->ulpCommand, cmd->ulpIoTag);
3596                 lpfc_sli_issue_abort_iotag(phba, pring, piocb);
3597         }
3598         spin_unlock_irq(&phba->hbalock);
3599
3600         if (phba->sli.ring[LPFC_ELS_RING].txcmplq_cnt)
3601                 mod_timer(&vport->els_tmofunc, jiffies + HZ * timeout);
3602 }
3603
3604 void
3605 lpfc_els_flush_cmd(struct lpfc_vport *vport)
3606 {
3607         LIST_HEAD(completions);
3608         struct lpfc_hba  *phba = vport->phba;
3609         struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
3610         struct lpfc_iocbq *tmp_iocb, *piocb;
3611         IOCB_t *cmd = NULL;
3612
3613         lpfc_fabric_abort_vport(vport);
3614
3615         spin_lock_irq(&phba->hbalock);
3616         list_for_each_entry_safe(piocb, tmp_iocb, &pring->txq, list) {
3617                 cmd = &piocb->iocb;
3618
3619                 if (piocb->iocb_flag & LPFC_IO_LIBDFC) {
3620                         continue;
3621                 }
3622
3623                 /* Do not flush out the QUE_RING and ABORT/CLOSE iocbs */
3624                 if (cmd->ulpCommand == CMD_QUE_RING_BUF_CN ||
3625                     cmd->ulpCommand == CMD_QUE_RING_BUF64_CN ||
3626                     cmd->ulpCommand == CMD_CLOSE_XRI_CN ||
3627                     cmd->ulpCommand == CMD_ABORT_XRI_CN)
3628                         continue;
3629
3630                 if (piocb->vport != vport)
3631                         continue;
3632
3633                 list_move_tail(&piocb->list, &completions);
3634                 pring->txq_cnt--;
3635         }
3636
3637         list_for_each_entry_safe(piocb, tmp_iocb, &pring->txcmplq, list) {
3638                 if (piocb->iocb_flag & LPFC_IO_LIBDFC) {
3639                         continue;
3640                 }
3641
3642                 if (piocb->vport != vport)
3643                         continue;
3644
3645                 lpfc_sli_issue_abort_iotag(phba, pring, piocb);
3646         }
3647         spin_unlock_irq(&phba->hbalock);
3648
3649         while (!list_empty(&completions)) {
3650                 piocb = list_get_first(&completions, struct lpfc_iocbq, list);
3651                 cmd = &piocb->iocb;
3652                 list_del_init(&piocb->list);
3653
3654                 if (!piocb->iocb_cmpl)
3655                         lpfc_sli_release_iocbq(phba, piocb);
3656                 else {
3657                         cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
3658                         cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
3659                         (piocb->iocb_cmpl) (phba, piocb, piocb);
3660                 }
3661         }
3662
3663         return;
3664 }
3665
3666 void
3667 lpfc_els_flush_all_cmd(struct lpfc_hba  *phba)
3668 {
3669         LIST_HEAD(completions);
3670         struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
3671         struct lpfc_iocbq *tmp_iocb, *piocb;
3672         IOCB_t *cmd = NULL;
3673
3674         lpfc_fabric_abort_hba(phba);
3675         spin_lock_irq(&phba->hbalock);
3676         list_for_each_entry_safe(piocb, tmp_iocb, &pring->txq, list) {
3677                 cmd = &piocb->iocb;
3678                 if (piocb->iocb_flag & LPFC_IO_LIBDFC)
3679                         continue;
3680                 /* Do not flush out the QUE_RING and ABORT/CLOSE iocbs */
3681                 if (cmd->ulpCommand == CMD_QUE_RING_BUF_CN ||
3682                     cmd->ulpCommand == CMD_QUE_RING_BUF64_CN ||
3683                     cmd->ulpCommand == CMD_CLOSE_XRI_CN ||
3684                     cmd->ulpCommand == CMD_ABORT_XRI_CN)
3685                         continue;
3686                 list_move_tail(&piocb->list, &completions);
3687                 pring->txq_cnt--;
3688         }
3689         list_for_each_entry_safe(piocb, tmp_iocb, &pring->txcmplq, list) {
3690                 if (piocb->iocb_flag & LPFC_IO_LIBDFC)
3691                         continue;
3692                 lpfc_sli_issue_abort_iotag(phba, pring, piocb);
3693         }
3694         spin_unlock_irq(&phba->hbalock);
3695         while (!list_empty(&completions)) {
3696                 piocb = list_get_first(&completions, struct lpfc_iocbq, list);
3697                 cmd = &piocb->iocb;
3698                 list_del_init(&piocb->list);
3699                 if (!piocb->iocb_cmpl)
3700                         lpfc_sli_release_iocbq(phba, piocb);
3701                 else {
3702                         cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
3703                         cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
3704                         (piocb->iocb_cmpl) (phba, piocb, piocb);
3705                 }
3706         }
3707         return;
3708 }
3709
3710 static void
3711 lpfc_els_unsol_buffer(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
3712                       struct lpfc_vport *vport, struct lpfc_iocbq *elsiocb)
3713 {
3714         struct lpfc_nodelist *ndlp;
3715         struct ls_rjt stat;
3716         uint32_t *payload;
3717         uint32_t cmd, did, newnode, rjt_err = 0;
3718         IOCB_t *icmd = &elsiocb->iocb;
3719
3720         if (vport == NULL || elsiocb->context2 == NULL)
3721                 goto dropit;
3722
3723         newnode = 0;
3724         payload = ((struct lpfc_dmabuf *)elsiocb->context2)->virt;
3725         cmd = *payload;
3726         if ((phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) == 0)
3727                 lpfc_post_buffer(phba, pring, 1, 1);
3728
3729         did = icmd->un.rcvels.remoteID;
3730         if (icmd->ulpStatus) {
3731                 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3732                         "RCV Unsol ELS:  status:x%x/x%x did:x%x",
3733                         icmd->ulpStatus, icmd->un.ulpWord[4], did);
3734                 goto dropit;
3735         }
3736
3737         /* Check to see if link went down during discovery */
3738         if (lpfc_els_chk_latt(vport))
3739                 goto dropit;
3740
3741         /* Ignore traffic recevied during vport shutdown. */
3742         if (vport->load_flag & FC_UNLOADING)
3743                 goto dropit;
3744
3745         ndlp = lpfc_findnode_did(vport, did);
3746         if (!ndlp) {
3747                 /* Cannot find existing Fabric ndlp, so allocate a new one */
3748                 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
3749                 if (!ndlp)
3750                         goto dropit;
3751
3752                 lpfc_nlp_init(vport, ndlp, did);
3753                 newnode = 1;
3754                 if ((did & Fabric_DID_MASK) == Fabric_DID_MASK) {
3755                         ndlp->nlp_type |= NLP_FABRIC;
3756                 }
3757                 lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNUSED_NODE);
3758         }
3759
3760         phba->fc_stat.elsRcvFrame++;
3761         if (elsiocb->context1)
3762                 lpfc_nlp_put(elsiocb->context1);
3763         elsiocb->context1 = lpfc_nlp_get(ndlp);
3764         elsiocb->vport = vport;
3765
3766         if ((cmd & ELS_CMD_MASK) == ELS_CMD_RSCN) {
3767                 cmd &= ELS_CMD_MASK;
3768         }
3769         /* ELS command <elsCmd> received from NPORT <did> */
3770         lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
3771                          "0112 ELS command x%x received from NPORT x%x "
3772                          "Data: x%x\n", cmd, did, vport->port_state);
3773         switch (cmd) {
3774         case ELS_CMD_PLOGI:
3775                 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3776                         "RCV PLOGI:       did:x%x/ste:x%x flg:x%x",
3777                         did, vport->port_state, ndlp->nlp_flag);
3778
3779                 phba->fc_stat.elsRcvPLOGI++;
3780                 ndlp = lpfc_plogi_confirm_nport(phba, payload, ndlp);
3781
3782                 if (vport->port_state < LPFC_DISC_AUTH) {
3783                         rjt_err = LSRJT_UNABLE_TPC;
3784                         break;
3785                 }
3786                 lpfc_disc_state_machine(vport, ndlp, elsiocb,
3787                                         NLP_EVT_RCV_PLOGI);
3788
3789                 break;
3790         case ELS_CMD_FLOGI:
3791                 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3792                         "RCV FLOGI:       did:x%x/ste:x%x flg:x%x",
3793                         did, vport->port_state, ndlp->nlp_flag);
3794
3795                 phba->fc_stat.elsRcvFLOGI++;
3796                 lpfc_els_rcv_flogi(vport, elsiocb, ndlp);
3797                 if (newnode)
3798                         lpfc_drop_node(vport, ndlp);
3799                 break;
3800         case ELS_CMD_LOGO:
3801                 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3802                         "RCV LOGO:        did:x%x/ste:x%x flg:x%x",
3803                         did, vport->port_state, ndlp->nlp_flag);
3804
3805                 phba->fc_stat.elsRcvLOGO++;
3806                 if (vport->port_state < LPFC_DISC_AUTH) {
3807                         rjt_err = LSRJT_UNABLE_TPC;
3808                         break;
3809                 }
3810                 lpfc_disc_state_machine(vport, ndlp, elsiocb, NLP_EVT_RCV_LOGO);
3811                 break;
3812         case ELS_CMD_PRLO:
3813                 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3814                         "RCV PRLO:        did:x%x/ste:x%x flg:x%x",
3815                         did, vport->port_state, ndlp->nlp_flag);
3816
3817                 phba->fc_stat.elsRcvPRLO++;
3818                 if (vport->port_state < LPFC_DISC_AUTH) {
3819                         rjt_err = LSRJT_UNABLE_TPC;
3820                         break;
3821                 }
3822                 lpfc_disc_state_machine(vport, ndlp, elsiocb, NLP_EVT_RCV_PRLO);
3823                 break;
3824         case ELS_CMD_RSCN:
3825                 phba->fc_stat.elsRcvRSCN++;
3826                 lpfc_els_rcv_rscn(vport, elsiocb, ndlp);
3827                 if (newnode)
3828                         lpfc_drop_node(vport, ndlp);
3829                 break;
3830         case ELS_CMD_ADISC:
3831                 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3832                         "RCV ADISC:       did:x%x/ste:x%x flg:x%x",
3833                         did, vport->port_state, ndlp->nlp_flag);
3834
3835                 phba->fc_stat.elsRcvADISC++;
3836                 if (vport->port_state < LPFC_DISC_AUTH) {
3837                         rjt_err = LSRJT_UNABLE_TPC;
3838                         break;
3839                 }
3840                 lpfc_disc_state_machine(vport, ndlp, elsiocb,
3841                                         NLP_EVT_RCV_ADISC);
3842                 break;
3843         case ELS_CMD_PDISC:
3844                 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3845                         "RCV PDISC:       did:x%x/ste:x%x flg:x%x",
3846                         did, vport->port_state, ndlp->nlp_flag);
3847
3848                 phba->fc_stat.elsRcvPDISC++;
3849                 if (vport->port_state < LPFC_DISC_AUTH) {
3850                         rjt_err = LSRJT_UNABLE_TPC;
3851                         break;
3852                 }
3853                 lpfc_disc_state_machine(vport, ndlp, elsiocb,
3854                                         NLP_EVT_RCV_PDISC);
3855                 break;
3856         case ELS_CMD_FARPR:
3857                 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3858                         "RCV FARPR:       did:x%x/ste:x%x flg:x%x",
3859                         did, vport->port_state, ndlp->nlp_flag);
3860
3861                 phba->fc_stat.elsRcvFARPR++;
3862                 lpfc_els_rcv_farpr(vport, elsiocb, ndlp);
3863                 break;
3864         case ELS_CMD_FARP:
3865                 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3866                         "RCV FARP:        did:x%x/ste:x%x flg:x%x",
3867                         did, vport->port_state, ndlp->nlp_flag);
3868
3869                 phba->fc_stat.elsRcvFARP++;
3870                 lpfc_els_rcv_farp(vport, elsiocb, ndlp);
3871                 break;
3872         case ELS_CMD_FAN:
3873                 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3874                         "RCV FAN:         did:x%x/ste:x%x flg:x%x",
3875                         did, vport->port_state, ndlp->nlp_flag);
3876
3877                 phba->fc_stat.elsRcvFAN++;
3878                 lpfc_els_rcv_fan(vport, elsiocb, ndlp);
3879                 break;
3880         case ELS_CMD_PRLI:
3881                 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3882                         "RCV PRLI:        did:x%x/ste:x%x flg:x%x",
3883                         did, vport->port_state, ndlp->nlp_flag);
3884
3885                 phba->fc_stat.elsRcvPRLI++;
3886                 if (vport->port_state < LPFC_DISC_AUTH) {
3887                         rjt_err = LSRJT_UNABLE_TPC;
3888                         break;
3889                 }
3890                 lpfc_disc_state_machine(vport, ndlp, elsiocb, NLP_EVT_RCV_PRLI);
3891                 break;
3892         case ELS_CMD_LIRR:
3893                 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3894                         "RCV LIRR:        did:x%x/ste:x%x flg:x%x",
3895                         did, vport->port_state, ndlp->nlp_flag);
3896
3897                 phba->fc_stat.elsRcvLIRR++;
3898                 lpfc_els_rcv_lirr(vport, elsiocb, ndlp);
3899                 if (newnode)
3900                         lpfc_drop_node(vport, ndlp);
3901                 break;
3902         case ELS_CMD_RPS:
3903                 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3904                         "RCV RPS:         did:x%x/ste:x%x flg:x%x",
3905                         did, vport->port_state, ndlp->nlp_flag);
3906
3907                 phba->fc_stat.elsRcvRPS++;
3908                 lpfc_els_rcv_rps(vport, elsiocb, ndlp);
3909                 if (newnode)
3910                         lpfc_drop_node(vport, ndlp);
3911                 break;
3912         case ELS_CMD_RPL:
3913                 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3914                         "RCV RPL:         did:x%x/ste:x%x flg:x%x",
3915                         did, vport->port_state, ndlp->nlp_flag);
3916
3917                 phba->fc_stat.elsRcvRPL++;
3918                 lpfc_els_rcv_rpl(vport, elsiocb, ndlp);
3919                 if (newnode)
3920                         lpfc_drop_node(vport, ndlp);
3921                 break;
3922         case ELS_CMD_RNID:
3923                 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3924                         "RCV RNID:        did:x%x/ste:x%x flg:x%x",
3925                         did, vport->port_state, ndlp->nlp_flag);
3926
3927                 phba->fc_stat.elsRcvRNID++;
3928                 lpfc_els_rcv_rnid(vport, elsiocb, ndlp);
3929                 if (newnode)
3930                         lpfc_drop_node(vport, ndlp);
3931                 break;
3932         default:
3933                 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3934                         "RCV ELS cmd:     cmd:x%x did:x%x/ste:x%x",
3935                         cmd, did, vport->port_state);
3936
3937                 /* Unsupported ELS command, reject */
3938                 rjt_err = LSRJT_INVALID_CMD;
3939
3940                 /* Unknown ELS command <elsCmd> received from NPORT <did> */
3941                 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
3942                                  "0115 Unknown ELS command x%x "
3943                                  "received from NPORT x%x\n", cmd, did);
3944                 if (newnode)
3945                         lpfc_drop_node(vport, ndlp);
3946                 break;
3947         }
3948
3949         /* check if need to LS_RJT received ELS cmd */
3950         if (rjt_err) {
3951                 memset(&stat, 0, sizeof(stat));
3952                 stat.un.b.lsRjtRsnCode = rjt_err;
3953                 stat.un.b.lsRjtRsnCodeExp = LSEXP_NOTHING_MORE;
3954                 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, elsiocb, ndlp,
3955                         NULL);
3956         }
3957
3958         return;
3959
3960 dropit:
3961         lpfc_printf_log(phba, KERN_ERR, LOG_ELS,
3962                         "(%d):0111 Dropping received ELS cmd "
3963                         "Data: x%x x%x x%x\n",
3964                         vport ? vport->vpi : 0xffff, icmd->ulpStatus,
3965                         icmd->un.ulpWord[4], icmd->ulpTimeout);
3966         phba->fc_stat.elsRcvDrop++;
3967 }
3968
3969 static struct lpfc_vport *
3970 lpfc_find_vport_by_vpid(struct lpfc_hba *phba, uint16_t vpi)
3971 {
3972         struct lpfc_vport *vport;
3973         unsigned long flags;
3974
3975         spin_lock_irqsave(&phba->hbalock, flags);
3976         list_for_each_entry(vport, &phba->port_list, listentry) {
3977                 if (vport->vpi == vpi) {
3978                         spin_unlock_irqrestore(&phba->hbalock, flags);
3979                         return vport;
3980                 }
3981         }
3982         spin_unlock_irqrestore(&phba->hbalock, flags);
3983         return NULL;
3984 }
3985
3986 void
3987 lpfc_els_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
3988                      struct lpfc_iocbq *elsiocb)
3989 {
3990         struct lpfc_vport *vport = phba->pport;
3991         IOCB_t *icmd = &elsiocb->iocb;
3992         dma_addr_t paddr;
3993         struct lpfc_dmabuf *bdeBuf1 = elsiocb->context2;
3994         struct lpfc_dmabuf *bdeBuf2 = elsiocb->context3;
3995
3996         elsiocb->context2 = NULL;
3997         elsiocb->context3 = NULL;
3998
3999         if (icmd->ulpStatus == IOSTAT_NEED_BUFFER) {
4000                 lpfc_sli_hbqbuf_add_hbqs(phba, LPFC_ELS_HBQ);
4001         } else if (icmd->ulpStatus == IOSTAT_LOCAL_REJECT &&
4002             (icmd->un.ulpWord[4] & 0xff) == IOERR_RCV_BUFFER_WAITING) {
4003                 phba->fc_stat.NoRcvBuf++;
4004                 /* Not enough posted buffers; Try posting more buffers */
4005                 if (!(phba->sli3_options & LPFC_SLI3_HBQ_ENABLED))
4006                         lpfc_post_buffer(phba, pring, 0, 1);
4007                 return;
4008         }
4009
4010         if ((phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) &&
4011             (icmd->ulpCommand == CMD_IOCB_RCV_ELS64_CX ||
4012              icmd->ulpCommand == CMD_IOCB_RCV_SEQ64_CX)) {
4013                 if (icmd->unsli3.rcvsli3.vpi == 0xffff)
4014                         vport = phba->pport;
4015                 else {
4016                         uint16_t vpi = icmd->unsli3.rcvsli3.vpi;
4017                         vport = lpfc_find_vport_by_vpid(phba, vpi);
4018                 }
4019         }
4020                                 /* If there are no BDEs associated
4021                                  * with this IOCB, there is nothing to do.
4022                                  */
4023         if (icmd->ulpBdeCount == 0)
4024                 return;
4025
4026                                 /* type of ELS cmd is first 32bit word
4027                                  * in packet
4028                                  */
4029         if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {
4030                 elsiocb->context2 = bdeBuf1;
4031         } else {
4032                 paddr = getPaddr(icmd->un.cont64[0].addrHigh,
4033                                  icmd->un.cont64[0].addrLow);
4034                 elsiocb->context2 = lpfc_sli_ringpostbuf_get(phba, pring,
4035                                                              paddr);
4036         }
4037
4038         lpfc_els_unsol_buffer(phba, pring, vport, elsiocb);
4039         /*
4040          * The different unsolicited event handlers would tell us
4041          * if they are done with "mp" by setting context2 to NULL.
4042          */
4043         lpfc_nlp_put(elsiocb->context1);
4044         elsiocb->context1 = NULL;
4045         if (elsiocb->context2) {
4046                 lpfc_in_buf_free(phba, (struct lpfc_dmabuf *)elsiocb->context2);
4047                 elsiocb->context2 = NULL;
4048         }
4049
4050         /* RCV_ELS64_CX provide for 2 BDEs - process 2nd if included */
4051         if ((phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) &&
4052             icmd->ulpBdeCount == 2) {
4053                 elsiocb->context2 = bdeBuf2;
4054                 lpfc_els_unsol_buffer(phba, pring, vport, elsiocb);
4055                 /* free mp if we are done with it */
4056                 if (elsiocb->context2) {
4057                         lpfc_in_buf_free(phba, elsiocb->context2);
4058                         elsiocb->context2 = NULL;
4059                 }
4060         }
4061 }
4062
4063 void
4064 lpfc_do_scr_ns_plogi(struct lpfc_hba *phba, struct lpfc_vport *vport)
4065 {
4066         struct lpfc_nodelist *ndlp, *ndlp_fdmi;
4067
4068         ndlp = lpfc_findnode_did(vport, NameServer_DID);
4069         if (!ndlp) {
4070                 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
4071                 if (!ndlp) {
4072                         if (phba->fc_topology == TOPOLOGY_LOOP) {
4073                                 lpfc_disc_start(vport);
4074                                 return;
4075                         }
4076                         lpfc_vport_set_state(vport, FC_VPORT_FAILED);
4077                         lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
4078                                          "0251 NameServer login: no memory\n");
4079                         return;
4080                 }
4081                 lpfc_nlp_init(vport, ndlp, NameServer_DID);
4082                 ndlp->nlp_type |= NLP_FABRIC;
4083         }
4084
4085         lpfc_nlp_set_state(vport, ndlp, NLP_STE_PLOGI_ISSUE);
4086
4087         if (lpfc_issue_els_plogi(vport, ndlp->nlp_DID, 0)) {
4088                 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
4089                 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
4090                                  "0252 Cannot issue NameServer login\n");
4091                 return;
4092         }
4093
4094         if (vport->cfg_fdmi_on) {
4095                 ndlp_fdmi = mempool_alloc(phba->nlp_mem_pool,
4096                                           GFP_KERNEL);
4097                 if (ndlp_fdmi) {
4098                         lpfc_nlp_init(vport, ndlp_fdmi, FDMI_DID);
4099                         ndlp_fdmi->nlp_type |= NLP_FABRIC;
4100                         ndlp_fdmi->nlp_state =
4101                                 NLP_STE_PLOGI_ISSUE;
4102                         lpfc_issue_els_plogi(vport, ndlp_fdmi->nlp_DID,
4103                                              0);
4104                 }
4105         }
4106         return;
4107 }
4108
4109 static void
4110 lpfc_cmpl_reg_new_vport(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
4111 {
4112         struct lpfc_vport *vport = pmb->vport;
4113         struct Scsi_Host  *shost = lpfc_shost_from_vport(vport);
4114         struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) pmb->context2;
4115         MAILBOX_t *mb = &pmb->mb;
4116
4117         vport->fc_flag &= ~FC_VPORT_NEEDS_REG_VPI;
4118         lpfc_nlp_put(ndlp);
4119
4120         if (mb->mbxStatus) {
4121                 lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX,
4122                                  "0915 Register VPI failed: 0x%x\n",
4123                                  mb->mbxStatus);
4124
4125                 switch (mb->mbxStatus) {
4126                 case 0x11:      /* unsupported feature */
4127                 case 0x9603:    /* max_vpi exceeded */
4128                         /* giving up on vport registration */
4129                         lpfc_vport_set_state(vport, FC_VPORT_FAILED);
4130                         spin_lock_irq(shost->host_lock);
4131                         vport->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP);
4132                         spin_unlock_irq(shost->host_lock);
4133                         lpfc_can_disctmo(vport);
4134                         break;
4135                 default:
4136                         /* Try to recover from this error */
4137                         lpfc_mbx_unreg_vpi(vport);
4138                         vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
4139                         lpfc_initial_fdisc(vport);
4140                         break;
4141                 }
4142
4143         } else {
4144                 if (vport == phba->pport)
4145                         lpfc_issue_fabric_reglogin(vport);
4146                 else
4147                         lpfc_do_scr_ns_plogi(phba, vport);
4148         }
4149         mempool_free(pmb, phba->mbox_mem_pool);
4150         return;
4151 }
4152
4153 void
4154 lpfc_register_new_vport(struct lpfc_hba *phba, struct lpfc_vport *vport,
4155                         struct lpfc_nodelist *ndlp)
4156 {
4157         LPFC_MBOXQ_t *mbox;
4158
4159         mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
4160         if (mbox) {
4161                 lpfc_reg_vpi(phba, vport->vpi, vport->fc_myDID, mbox);
4162                 mbox->vport = vport;
4163                 mbox->context2 = lpfc_nlp_get(ndlp);
4164                 mbox->mbox_cmpl = lpfc_cmpl_reg_new_vport;
4165                 if (lpfc_sli_issue_mbox(phba, mbox,
4166                                         MBX_NOWAIT | MBX_STOP_IOCB)
4167                     == MBX_NOT_FINISHED) {
4168                         mempool_free(mbox, phba->mbox_mem_pool);
4169                         vport->fc_flag &= ~FC_VPORT_NEEDS_REG_VPI;
4170
4171                         lpfc_vport_set_state(vport, FC_VPORT_FAILED);
4172                         lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX,
4173                                 "0253 Register VPI: Can't send mbox\n");
4174                 }
4175         } else {
4176                 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
4177
4178                 lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX,
4179                                  "0254 Register VPI: no memory\n");
4180
4181                 vport->fc_flag &= ~FC_VPORT_NEEDS_REG_VPI;
4182                 lpfc_nlp_put(ndlp);
4183         }
4184 }
4185
4186 static void
4187 lpfc_cmpl_els_fdisc(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
4188                     struct lpfc_iocbq *rspiocb)
4189 {
4190         struct lpfc_vport *vport = cmdiocb->vport;
4191         struct Scsi_Host  *shost = lpfc_shost_from_vport(vport);
4192         struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
4193         struct lpfc_nodelist *np;
4194         struct lpfc_nodelist *next_np;
4195         IOCB_t *irsp = &rspiocb->iocb;
4196         struct lpfc_iocbq *piocb;
4197
4198         lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
4199                          "0123 FDISC completes. x%x/x%x prevDID: x%x\n",
4200                          irsp->ulpStatus, irsp->un.ulpWord[4],
4201                          vport->fc_prevDID);
4202         /* Since all FDISCs are being single threaded, we
4203          * must reset the discovery timer for ALL vports
4204          * waiting to send FDISC when one completes.
4205          */
4206         list_for_each_entry(piocb, &phba->fabric_iocb_list, list) {
4207                 lpfc_set_disctmo(piocb->vport);
4208         }
4209
4210         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
4211                 "FDISC cmpl:      status:x%x/x%x prevdid:x%x",
4212                 irsp->ulpStatus, irsp->un.ulpWord[4], vport->fc_prevDID);
4213
4214         if (irsp->ulpStatus) {
4215                 /* Check for retry */
4216                 if (lpfc_els_retry(phba, cmdiocb, rspiocb))
4217                         goto out;
4218                 /* FDISC failed */
4219                 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
4220                                  "0124 FDISC failed. (%d/%d)\n",
4221                                  irsp->ulpStatus, irsp->un.ulpWord[4]);
4222                 if (vport->fc_vport->vport_state == FC_VPORT_INITIALIZING)
4223                         lpfc_vport_set_state(vport, FC_VPORT_FAILED);
4224
4225                 lpfc_nlp_put(ndlp);
4226                 /* giving up on FDISC. Cancel discovery timer */
4227                 lpfc_can_disctmo(vport);
4228         } else {
4229                 spin_lock_irq(shost->host_lock);
4230                 vport->fc_flag |= FC_FABRIC;
4231                 if (vport->phba->fc_topology == TOPOLOGY_LOOP)
4232                         vport->fc_flag |=  FC_PUBLIC_LOOP;
4233                 spin_unlock_irq(shost->host_lock);
4234
4235                 vport->fc_myDID = irsp->un.ulpWord[4] & Mask_DID;
4236                 lpfc_vport_set_state(vport, FC_VPORT_ACTIVE);
4237                 if ((vport->fc_prevDID != vport->fc_myDID) &&
4238                         !(vport->fc_flag & FC_VPORT_NEEDS_REG_VPI)) {
4239                         /* If our NportID changed, we need to ensure all
4240                          * remaining NPORTs get unreg_login'ed so we can
4241                          * issue unreg_vpi.
4242                          */
4243                         list_for_each_entry_safe(np, next_np,
4244                                 &vport->fc_nodes, nlp_listp) {
4245                                 if (np->nlp_state != NLP_STE_NPR_NODE
4246                                    || !(np->nlp_flag & NLP_NPR_ADISC))
4247                                         continue;
4248                                 spin_lock_irq(shost->host_lock);
4249                                 np->nlp_flag &= ~NLP_NPR_ADISC;
4250                                 spin_unlock_irq(shost->host_lock);
4251                                 lpfc_unreg_rpi(vport, np);
4252                         }
4253                         lpfc_mbx_unreg_vpi(vport);
4254                         vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
4255                 }
4256
4257                 if (vport->fc_flag & FC_VPORT_NEEDS_REG_VPI)
4258                         lpfc_register_new_vport(phba, vport, ndlp);
4259                 else
4260                         lpfc_do_scr_ns_plogi(phba, vport);
4261
4262                 lpfc_nlp_put(ndlp); /* Free Fabric ndlp for vports */
4263         }
4264
4265 out:
4266         lpfc_els_free_iocb(phba, cmdiocb);
4267 }
4268
4269 int
4270 lpfc_issue_els_fdisc(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
4271                      uint8_t retry)
4272 {
4273         struct lpfc_hba *phba = vport->phba;
4274         IOCB_t *icmd;
4275         struct lpfc_iocbq *elsiocb;
4276         struct serv_parm *sp;
4277         uint8_t *pcmd;
4278         uint16_t cmdsize;
4279         int did = ndlp->nlp_DID;
4280         int rc;
4281
4282         cmdsize = (sizeof(uint32_t) + sizeof(struct serv_parm));
4283         elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, ndlp, did,
4284                                      ELS_CMD_FDISC);
4285         if (!elsiocb) {
4286                 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
4287                 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
4288                                  "0255 Issue FDISC: no IOCB\n");
4289                 return 1;
4290         }
4291
4292         icmd = &elsiocb->iocb;
4293         icmd->un.elsreq64.myID = 0;
4294         icmd->un.elsreq64.fl = 1;
4295
4296         /* For FDISC, Let FDISC rsp set the NPortID for this VPI */
4297         icmd->ulpCt_h = 1;
4298         icmd->ulpCt_l = 0;
4299
4300         pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
4301         *((uint32_t *) (pcmd)) = ELS_CMD_FDISC;
4302         pcmd += sizeof(uint32_t); /* CSP Word 1 */
4303         memcpy(pcmd, &vport->phba->pport->fc_sparam, sizeof(struct serv_parm));
4304         sp = (struct serv_parm *) pcmd;
4305         /* Setup CSPs accordingly for Fabric */
4306         sp->cmn.e_d_tov = 0;
4307         sp->cmn.w2.r_a_tov = 0;
4308         sp->cls1.classValid = 0;
4309         sp->cls2.seqDelivery = 1;
4310         sp->cls3.seqDelivery = 1;
4311
4312         pcmd += sizeof(uint32_t); /* CSP Word 2 */
4313         pcmd += sizeof(uint32_t); /* CSP Word 3 */
4314         pcmd += sizeof(uint32_t); /* CSP Word 4 */
4315         pcmd += sizeof(uint32_t); /* Port Name */
4316         memcpy(pcmd, &vport->fc_portname, 8);
4317         pcmd += sizeof(uint32_t); /* Node Name */
4318         pcmd += sizeof(uint32_t); /* Node Name */
4319         memcpy(pcmd, &vport->fc_nodename, 8);
4320
4321         lpfc_set_disctmo(vport);
4322
4323         phba->fc_stat.elsXmitFDISC++;
4324         elsiocb->iocb_cmpl = lpfc_cmpl_els_fdisc;
4325
4326         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
4327                 "Issue FDISC:     did:x%x",
4328                 did, 0, 0);
4329
4330         rc = lpfc_issue_fabric_iocb(phba, elsiocb);
4331         if (rc == IOCB_ERROR) {
4332                 lpfc_els_free_iocb(phba, elsiocb);
4333                 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
4334                 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
4335                                  "0256 Issue FDISC: Cannot send IOCB\n");
4336                 return 1;
4337         }
4338         lpfc_vport_set_state(vport, FC_VPORT_INITIALIZING);
4339         vport->port_state = LPFC_FDISC;
4340         return 0;
4341 }
4342
4343 static void
4344 lpfc_cmpl_els_npiv_logo(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
4345                         struct lpfc_iocbq *rspiocb)
4346 {
4347         struct lpfc_vport *vport = cmdiocb->vport;
4348         IOCB_t *irsp;
4349
4350         irsp = &rspiocb->iocb;
4351         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
4352                 "LOGO npiv cmpl:  status:x%x/x%x did:x%x",
4353                 irsp->ulpStatus, irsp->un.ulpWord[4], irsp->un.rcvels.remoteID);
4354
4355         lpfc_els_free_iocb(phba, cmdiocb);
4356         vport->unreg_vpi_cmpl = VPORT_ERROR;
4357 }
4358
4359 int
4360 lpfc_issue_els_npiv_logo(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp)
4361 {
4362         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
4363         struct lpfc_hba  *phba = vport->phba;
4364         struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
4365         IOCB_t *icmd;
4366         struct lpfc_iocbq *elsiocb;
4367         uint8_t *pcmd;
4368         uint16_t cmdsize;
4369
4370         cmdsize = 2 * sizeof(uint32_t) + sizeof(struct lpfc_name);
4371         elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, 0, ndlp, ndlp->nlp_DID,
4372                                      ELS_CMD_LOGO);
4373         if (!elsiocb)
4374                 return 1;
4375
4376         icmd = &elsiocb->iocb;
4377         pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
4378         *((uint32_t *) (pcmd)) = ELS_CMD_LOGO;
4379         pcmd += sizeof(uint32_t);
4380
4381         /* Fill in LOGO payload */
4382         *((uint32_t *) (pcmd)) = be32_to_cpu(vport->fc_myDID);
4383         pcmd += sizeof(uint32_t);
4384         memcpy(pcmd, &vport->fc_portname, sizeof(struct lpfc_name));
4385
4386         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
4387                 "Issue LOGO npiv  did:x%x flg:x%x",
4388                 ndlp->nlp_DID, ndlp->nlp_flag, 0);
4389
4390         elsiocb->iocb_cmpl = lpfc_cmpl_els_npiv_logo;
4391         spin_lock_irq(shost->host_lock);
4392         ndlp->nlp_flag |= NLP_LOGO_SND;
4393         spin_unlock_irq(shost->host_lock);
4394         if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
4395                 spin_lock_irq(shost->host_lock);
4396                 ndlp->nlp_flag &= ~NLP_LOGO_SND;
4397                 spin_unlock_irq(shost->host_lock);
4398                 lpfc_els_free_iocb(phba, elsiocb);
4399                 return 1;
4400         }
4401         return 0;
4402 }
4403
4404 void
4405 lpfc_fabric_block_timeout(unsigned long ptr)
4406 {
4407         struct lpfc_hba  *phba = (struct lpfc_hba *) ptr;
4408         unsigned long iflags;
4409         uint32_t tmo_posted;
4410         spin_lock_irqsave(&phba->pport->work_port_lock, iflags);
4411         tmo_posted = phba->pport->work_port_events & WORKER_FABRIC_BLOCK_TMO;
4412         if (!tmo_posted)
4413                 phba->pport->work_port_events |= WORKER_FABRIC_BLOCK_TMO;
4414         spin_unlock_irqrestore(&phba->pport->work_port_lock, iflags);
4415
4416         if (!tmo_posted) {
4417                 spin_lock_irqsave(&phba->hbalock, iflags);
4418                 if (phba->work_wait)
4419                         lpfc_worker_wake_up(phba);
4420                 spin_unlock_irqrestore(&phba->hbalock, iflags);
4421         }
4422 }
4423
4424 static void
4425 lpfc_resume_fabric_iocbs(struct lpfc_hba *phba)
4426 {
4427         struct lpfc_iocbq *iocb;
4428         unsigned long iflags;
4429         int ret;
4430         struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
4431         IOCB_t *cmd;
4432
4433 repeat:
4434         iocb = NULL;
4435         spin_lock_irqsave(&phba->hbalock, iflags);
4436                                 /* Post any pending iocb to the SLI layer */
4437         if (atomic_read(&phba->fabric_iocb_count) == 0) {
4438                 list_remove_head(&phba->fabric_iocb_list, iocb, typeof(*iocb),
4439                                  list);
4440                 if (iocb)
4441                         atomic_inc(&phba->fabric_iocb_count);
4442         }
4443         spin_unlock_irqrestore(&phba->hbalock, iflags);
4444         if (iocb) {
4445                 iocb->fabric_iocb_cmpl = iocb->iocb_cmpl;
4446                 iocb->iocb_cmpl = lpfc_cmpl_fabric_iocb;
4447                 iocb->iocb_flag |= LPFC_IO_FABRIC;
4448
4449                 lpfc_debugfs_disc_trc(iocb->vport, LPFC_DISC_TRC_ELS_CMD,
4450                         "Fabric sched1:   ste:x%x",
4451                         iocb->vport->port_state, 0, 0);
4452
4453                 ret = lpfc_sli_issue_iocb(phba, pring, iocb, 0);
4454
4455                 if (ret == IOCB_ERROR) {
4456                         iocb->iocb_cmpl = iocb->fabric_iocb_cmpl;
4457                         iocb->fabric_iocb_cmpl = NULL;
4458                         iocb->iocb_flag &= ~LPFC_IO_FABRIC;
4459                         cmd = &iocb->iocb;
4460                         cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
4461                         cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
4462                         iocb->iocb_cmpl(phba, iocb, iocb);
4463
4464                         atomic_dec(&phba->fabric_iocb_count);
4465                         goto repeat;
4466                 }
4467         }
4468
4469         return;
4470 }
4471
4472 void
4473 lpfc_unblock_fabric_iocbs(struct lpfc_hba *phba)
4474 {
4475         clear_bit(FABRIC_COMANDS_BLOCKED, &phba->bit_flags);
4476
4477         lpfc_resume_fabric_iocbs(phba);
4478         return;
4479 }
4480
4481 static void
4482 lpfc_block_fabric_iocbs(struct lpfc_hba *phba)
4483 {
4484         int blocked;
4485
4486         blocked = test_and_set_bit(FABRIC_COMANDS_BLOCKED, &phba->bit_flags);
4487                                 /* Start a timer to unblock fabric
4488                                  * iocbs after 100ms
4489                                  */
4490         if (!blocked)
4491                 mod_timer(&phba->fabric_block_timer, jiffies + HZ/10 );
4492
4493         return;
4494 }
4495
4496 static void
4497 lpfc_cmpl_fabric_iocb(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
4498         struct lpfc_iocbq *rspiocb)
4499 {
4500         struct ls_rjt stat;
4501
4502         if ((cmdiocb->iocb_flag & LPFC_IO_FABRIC) != LPFC_IO_FABRIC)
4503                 BUG();
4504
4505         switch (rspiocb->iocb.ulpStatus) {
4506                 case IOSTAT_NPORT_RJT:
4507                 case IOSTAT_FABRIC_RJT:
4508                         if (rspiocb->iocb.un.ulpWord[4] & RJT_UNAVAIL_TEMP) {
4509                                 lpfc_block_fabric_iocbs(phba);
4510                         }
4511                         break;
4512
4513                 case IOSTAT_NPORT_BSY:
4514                 case IOSTAT_FABRIC_BSY:
4515                         lpfc_block_fabric_iocbs(phba);
4516                         break;
4517
4518                 case IOSTAT_LS_RJT:
4519                         stat.un.lsRjtError =
4520                                 be32_to_cpu(rspiocb->iocb.un.ulpWord[4]);
4521                         if ((stat.un.b.lsRjtRsnCode == LSRJT_UNABLE_TPC) ||
4522                                 (stat.un.b.lsRjtRsnCode == LSRJT_LOGICAL_BSY))
4523                                 lpfc_block_fabric_iocbs(phba);
4524                         break;
4525         }
4526
4527         if (atomic_read(&phba->fabric_iocb_count) == 0)
4528                 BUG();
4529
4530         cmdiocb->iocb_cmpl = cmdiocb->fabric_iocb_cmpl;
4531         cmdiocb->fabric_iocb_cmpl = NULL;
4532         cmdiocb->iocb_flag &= ~LPFC_IO_FABRIC;
4533         cmdiocb->iocb_cmpl(phba, cmdiocb, rspiocb);
4534
4535         atomic_dec(&phba->fabric_iocb_count);
4536         if (!test_bit(FABRIC_COMANDS_BLOCKED, &phba->bit_flags)) {
4537                                 /* Post any pending iocbs to HBA */
4538                     lpfc_resume_fabric_iocbs(phba);
4539         }
4540 }
4541
4542 int
4543 lpfc_issue_fabric_iocb(struct lpfc_hba *phba, struct lpfc_iocbq *iocb)
4544 {
4545         unsigned long iflags;
4546         struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
4547         int ready;
4548         int ret;
4549
4550         if (atomic_read(&phba->fabric_iocb_count) > 1)
4551                 BUG();
4552
4553         spin_lock_irqsave(&phba->hbalock, iflags);
4554         ready = atomic_read(&phba->fabric_iocb_count) == 0 &&
4555                 !test_bit(FABRIC_COMANDS_BLOCKED, &phba->bit_flags);
4556
4557         spin_unlock_irqrestore(&phba->hbalock, iflags);
4558         if (ready) {
4559                 iocb->fabric_iocb_cmpl = iocb->iocb_cmpl;
4560                 iocb->iocb_cmpl = lpfc_cmpl_fabric_iocb;
4561                 iocb->iocb_flag |= LPFC_IO_FABRIC;
4562
4563                 lpfc_debugfs_disc_trc(iocb->vport, LPFC_DISC_TRC_ELS_CMD,
4564                         "Fabric sched2:   ste:x%x",
4565                         iocb->vport->port_state, 0, 0);
4566
4567                 atomic_inc(&phba->fabric_iocb_count);
4568                 ret = lpfc_sli_issue_iocb(phba, pring, iocb, 0);
4569
4570                 if (ret == IOCB_ERROR) {
4571                         iocb->iocb_cmpl = iocb->fabric_iocb_cmpl;
4572                         iocb->fabric_iocb_cmpl = NULL;
4573                         iocb->iocb_flag &= ~LPFC_IO_FABRIC;
4574                         atomic_dec(&phba->fabric_iocb_count);
4575                 }
4576         } else {
4577                 spin_lock_irqsave(&phba->hbalock, iflags);
4578                 list_add_tail(&iocb->list, &phba->fabric_iocb_list);
4579                 spin_unlock_irqrestore(&phba->hbalock, iflags);
4580                 ret = IOCB_SUCCESS;
4581         }
4582         return ret;
4583 }
4584
4585
4586 void lpfc_fabric_abort_vport(struct lpfc_vport *vport)
4587 {
4588         LIST_HEAD(completions);
4589         struct lpfc_hba  *phba = vport->phba;
4590         struct lpfc_iocbq *tmp_iocb, *piocb;
4591         IOCB_t *cmd;
4592
4593         spin_lock_irq(&phba->hbalock);
4594         list_for_each_entry_safe(piocb, tmp_iocb, &phba->fabric_iocb_list,
4595                                  list) {
4596
4597                 if (piocb->vport != vport)
4598                         continue;
4599
4600                 list_move_tail(&piocb->list, &completions);
4601         }
4602         spin_unlock_irq(&phba->hbalock);
4603
4604         while (!list_empty(&completions)) {
4605                 piocb = list_get_first(&completions, struct lpfc_iocbq, list);
4606                 list_del_init(&piocb->list);
4607
4608                 cmd = &piocb->iocb;
4609                 cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
4610                 cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
4611                 (piocb->iocb_cmpl) (phba, piocb, piocb);
4612         }
4613 }
4614
4615 void lpfc_fabric_abort_nport(struct lpfc_nodelist *ndlp)
4616 {
4617         LIST_HEAD(completions);
4618         struct lpfc_hba  *phba = ndlp->vport->phba;
4619         struct lpfc_iocbq *tmp_iocb, *piocb;
4620         struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
4621         IOCB_t *cmd;
4622
4623         spin_lock_irq(&phba->hbalock);
4624         list_for_each_entry_safe(piocb, tmp_iocb, &phba->fabric_iocb_list,
4625                                  list) {
4626                 if ((lpfc_check_sli_ndlp(phba, pring, piocb, ndlp))) {
4627
4628                         list_move_tail(&piocb->list, &completions);
4629                 }
4630         }
4631         spin_unlock_irq(&phba->hbalock);
4632
4633         while (!list_empty(&completions)) {
4634                 piocb = list_get_first(&completions, struct lpfc_iocbq, list);
4635                 list_del_init(&piocb->list);
4636
4637                 cmd = &piocb->iocb;
4638                 cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
4639                 cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
4640                 (piocb->iocb_cmpl) (phba, piocb, piocb);
4641         }
4642 }
4643
4644 void lpfc_fabric_abort_hba(struct lpfc_hba *phba)
4645 {
4646         LIST_HEAD(completions);
4647         struct lpfc_iocbq *piocb;
4648         IOCB_t *cmd;
4649
4650         spin_lock_irq(&phba->hbalock);
4651         list_splice_init(&phba->fabric_iocb_list, &completions);
4652         spin_unlock_irq(&phba->hbalock);
4653
4654         while (!list_empty(&completions)) {
4655                 piocb = list_get_first(&completions, struct lpfc_iocbq, list);
4656                 list_del_init(&piocb->list);
4657
4658                 cmd = &piocb->iocb;
4659                 cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
4660                 cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
4661                 (piocb->iocb_cmpl) (phba, piocb, piocb);
4662         }
4663 }
4664
4665
4666 void lpfc_fabric_abort_flogi(struct lpfc_hba *phba)
4667 {
4668         LIST_HEAD(completions);
4669         struct lpfc_iocbq *tmp_iocb, *piocb;
4670         IOCB_t *cmd;
4671         struct lpfc_nodelist *ndlp;
4672
4673         spin_lock_irq(&phba->hbalock);
4674         list_for_each_entry_safe(piocb, tmp_iocb, &phba->fabric_iocb_list,
4675                                  list) {
4676
4677                 cmd = &piocb->iocb;
4678                 ndlp = (struct lpfc_nodelist *) piocb->context1;
4679                 if (cmd->ulpCommand == CMD_ELS_REQUEST64_CR &&
4680                     ndlp != NULL &&
4681                     ndlp->nlp_DID == Fabric_DID)
4682                         list_move_tail(&piocb->list, &completions);
4683         }
4684         spin_unlock_irq(&phba->hbalock);
4685
4686         while (!list_empty(&completions)) {
4687                 piocb = list_get_first(&completions, struct lpfc_iocbq, list);
4688                 list_del_init(&piocb->list);
4689
4690                 cmd = &piocb->iocb;
4691                 cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
4692                 cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
4693                 (piocb->iocb_cmpl) (phba, piocb, piocb);
4694         }
4695 }
4696
4697