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