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

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