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-2006 Emulex.  All rights reserved.           *
   5  * EMULEX and SLI are trademarks of Emulex.                        *
   6  * www.emulex.com                                                  *
   7  * Portions Copyright (C) 2004-2005 Christoph Hellwig              *
   8  *                                                                 *
   9  * This program is free software; you can redistribute it and/or   *
  10  * modify it under the terms of version 2 of the GNU General       *
  11  * Public License as published by the Free Software Foundation.    *
  12  * This program is distributed in the hope that it will be useful. *
  13  * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND          *
  14  * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,  *
  15  * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE      *
  16  * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
  17  * TO BE LEGALLY INVALID.  See the GNU General Public License for  *
  18  * more details, a copy of which can be found in the file COPYING  *
  19  * included with this package.                                     *
  20  *******************************************************************/
  21
  22 #include <linux/blkdev.h>
  23 #include <linux/pci.h>
  24 #include <linux/interrupt.h>
  25
  26 #include <scsi/scsi.h>
  27 #include <scsi/scsi_device.h>
  28 #include <scsi/scsi_host.h>
  29 #include <scsi/scsi_transport_fc.h>
  30
  31 #include "lpfc_hw.h"
  32 #include "lpfc_sli.h"
  33 #include "lpfc_disc.h"
  34 #include "lpfc_scsi.h"
  35 #include "lpfc.h"
  36 #include "lpfc_logmsg.h"
  37 #include "lpfc_crtn.h"
  38
  39 static int lpfc_els_retry(struct lpfc_hba *, struct lpfc_iocbq *,
  40                           struct lpfc_iocbq *);
  41 static int lpfc_max_els_tries = 3;
  42
  43 static int
  44 lpfc_els_chk_latt(struct lpfc_hba * phba)
  45 {
  46         struct lpfc_sli *psli;
  47         LPFC_MBOXQ_t *mbox;
  48         uint32_t ha_copy;
  49         int rc;
  50
  51         psli = &phba->sli;
  52
  53         if ((phba->hba_state >= LPFC_HBA_READY) ||
  54             (phba->hba_state == LPFC_LINK_DOWN))
  55                 return 0;
  56
  57         /* Read the HBA Host Attention Register */
  58         spin_lock_irq(phba->host->host_lock);
  59         ha_copy = readl(phba->HAregaddr);
  60         spin_unlock_irq(phba->host->host_lock);
  61
  62         if (!(ha_copy & HA_LATT))
  63                 return 0;
  64
  65         /* Pending Link Event during Discovery */
  66         lpfc_printf_log(phba, KERN_WARNING, LOG_DISCOVERY,
  67                         "%d:0237 Pending Link Event during "
  68                         "Discovery: State x%x\n",
  69                         phba->brd_no, phba->hba_state);
  70
  71         /* CLEAR_LA should re-enable link attention events and
  72          * we should then imediately take a LATT event. The
  73          * LATT processing should call lpfc_linkdown() which
  74          * will cleanup any left over in-progress discovery
  75          * events.
  76          */
  77         spin_lock_irq(phba->host->host_lock);
  78         phba->fc_flag |= FC_ABORT_DISCOVERY;
  79         spin_unlock_irq(phba->host->host_lock);
  80
  81         if (phba->hba_state != LPFC_CLEAR_LA) {
  82                 if ((mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL))) {
  83                         phba->hba_state = LPFC_CLEAR_LA;
  84                         lpfc_clear_la(phba, mbox);
  85                         mbox->mbox_cmpl = lpfc_mbx_cmpl_clear_la;
  86                         rc = lpfc_sli_issue_mbox (phba, mbox,
  87                                                   (MBX_NOWAIT | MBX_STOP_IOCB));
  88                         if (rc == MBX_NOT_FINISHED) {
  89                                 mempool_free(mbox, phba->mbox_mem_pool);
  90                                 phba->hba_state = LPFC_HBA_ERROR;
  91                         }
  92                 }
  93         }
  94
  95         return 1;
  96
  97 }
  98
  99 static struct lpfc_iocbq *
 100 lpfc_prep_els_iocb(struct lpfc_hba * phba, uint8_t expectRsp,
 101                    uint16_t cmdSize, uint8_t retry, struct lpfc_nodelist * ndlp,
 102                    uint32_t did, uint32_t elscmd)
 103 {
 104         struct lpfc_sli_ring *pring;
 105         struct lpfc_iocbq *elsiocb;
 106         struct lpfc_dmabuf *pcmd, *prsp, *pbuflist;
 107         struct ulp_bde64 *bpl;
 108         IOCB_t *icmd;
 109
 110         pring = &phba->sli.ring[LPFC_ELS_RING];
 111
 112         if (phba->hba_state < LPFC_LINK_UP)
 113                 return  NULL;
 114
 115         /* Allocate buffer for  command iocb */
 116         spin_lock_irq(phba->host->host_lock);
 117         elsiocb = lpfc_sli_get_iocbq(phba);
 118         spin_unlock_irq(phba->host->host_lock);
 119
 120         if (elsiocb == NULL)
 121                 return NULL;
 122         icmd = &elsiocb->iocb;
 123
 124         /* fill in BDEs for command */
 125         /* Allocate buffer for command payload */
 126         if (((pcmd = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL)) == 0) ||
 127             ((pcmd->virt = lpfc_mbuf_alloc(phba,
 128                                            MEM_PRI, &(pcmd->phys))) == 0)) {
 129                 kfree(pcmd);
 130
 131                 spin_lock_irq(phba->host->host_lock);
 132                 lpfc_sli_release_iocbq(phba, elsiocb);
 133                 spin_unlock_irq(phba->host->host_lock);
 134                 return NULL;
 135         }
 136
 137         INIT_LIST_HEAD(&pcmd->list);
 138
 139         /* Allocate buffer for response payload */
 140         if (expectRsp) {
 141                 prsp = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
 142                 if (prsp)
 143                         prsp->virt = lpfc_mbuf_alloc(phba, MEM_PRI,
 144                                                      &prsp->phys);
 145                 if (prsp == 0 || prsp->virt == 0) {
 146                         kfree(prsp);
 147                         lpfc_mbuf_free(phba, pcmd->virt, pcmd->phys);
 148                         kfree(pcmd);
 149                         spin_lock_irq(phba->host->host_lock);
 150                         lpfc_sli_release_iocbq(phba, elsiocb);
 151                         spin_unlock_irq(phba->host->host_lock);
 152                         return NULL;
 153                 }
 154                 INIT_LIST_HEAD(&prsp->list);
 155         } else {
 156                 prsp = NULL;
 157         }
 158
 159         /* Allocate buffer for Buffer ptr list */
 160         pbuflist = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
 161         if (pbuflist)
 162             pbuflist->virt = lpfc_mbuf_alloc(phba, MEM_PRI,
 163                                              &pbuflist->phys);
 164         if (pbuflist == 0 || pbuflist->virt == 0) {
 165                 spin_lock_irq(phba->host->host_lock);
 166                 lpfc_sli_release_iocbq(phba, elsiocb);
 167                 spin_unlock_irq(phba->host->host_lock);
 168                 lpfc_mbuf_free(phba, pcmd->virt, pcmd->phys);
 169                 lpfc_mbuf_free(phba, prsp->virt, prsp->phys);
 170                 kfree(pcmd);
 171                 kfree(prsp);
 172                 kfree(pbuflist);
 173                 return NULL;
 174         }
 175
 176         INIT_LIST_HEAD(&pbuflist->list);
 177
 178         icmd->un.elsreq64.bdl.addrHigh = putPaddrHigh(pbuflist->phys);
 179         icmd->un.elsreq64.bdl.addrLow = putPaddrLow(pbuflist->phys);
 180         icmd->un.elsreq64.bdl.bdeFlags = BUFF_TYPE_BDL;
 181         if (expectRsp) {
 182                 icmd->un.elsreq64.bdl.bdeSize = (2 * sizeof (struct ulp_bde64));
 183                 icmd->un.elsreq64.remoteID = did;       /* DID */
 184                 icmd->ulpCommand = CMD_ELS_REQUEST64_CR;
 185         } else {
 186                 icmd->un.elsreq64.bdl.bdeSize = sizeof (struct ulp_bde64);
 187                 icmd->ulpCommand = CMD_XMIT_ELS_RSP64_CX;
 188         }
 189
 190         icmd->ulpBdeCount = 1;
 191         icmd->ulpLe = 1;
 192         icmd->ulpClass = CLASS3;
 193
 194         bpl = (struct ulp_bde64 *) pbuflist->virt;
 195         bpl->addrLow = le32_to_cpu(putPaddrLow(pcmd->phys));
 196         bpl->addrHigh = le32_to_cpu(putPaddrHigh(pcmd->phys));
 197         bpl->tus.f.bdeSize = cmdSize;
 198         bpl->tus.f.bdeFlags = 0;
 199         bpl->tus.w = le32_to_cpu(bpl->tus.w);
 200
 201         if (expectRsp) {
 202                 bpl++;
 203                 bpl->addrLow = le32_to_cpu(putPaddrLow(prsp->phys));
 204                 bpl->addrHigh = le32_to_cpu(putPaddrHigh(prsp->phys));
 205                 bpl->tus.f.bdeSize = FCELSSIZE;
 206                 bpl->tus.f.bdeFlags = BUFF_USE_RCV;
 207                 bpl->tus.w = le32_to_cpu(bpl->tus.w);
 208         }
 209
 210         /* Save for completion so we can release these resources */
 211         elsiocb->context1 = (uint8_t *) ndlp;
 212         elsiocb->context2 = (uint8_t *) pcmd;
 213         elsiocb->context3 = (uint8_t *) pbuflist;
 214         elsiocb->retry = retry;
 215         elsiocb->drvrTimeout = (phba->fc_ratov << 1) + LPFC_DRVR_TIMEOUT;
 216
 217         if (prsp) {
 218                 list_add(&prsp->list, &pcmd->list);
 219         }
 220
 221         if (expectRsp) {
 222                 /* Xmit ELS command <elsCmd> to remote NPORT <did> */
 223                 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
 224                                 "%d:0116 Xmit ELS command x%x to remote "
 225                                 "NPORT x%x Data: x%x x%x\n",
 226                                 phba->brd_no, elscmd,
 227                                 did, icmd->ulpIoTag, phba->hba_state);
 228         } else {
 229                 /* Xmit ELS response <elsCmd> to remote NPORT <did> */
 230                 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
 231                                 "%d:0117 Xmit ELS response x%x to remote "
 232                                 "NPORT x%x Data: x%x x%x\n",
 233                                 phba->brd_no, elscmd,
 234                                 ndlp->nlp_DID, icmd->ulpIoTag, cmdSize);
 235         }
 236
 237         return elsiocb;
 238 }
 239
 240
 241 static int
 242 lpfc_cmpl_els_flogi_fabric(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
 243                 struct serv_parm *sp, IOCB_t *irsp)
 244 {
 245         LPFC_MBOXQ_t *mbox;
 246         struct lpfc_dmabuf *mp;
 247         int rc;
 248
 249         spin_lock_irq(phba->host->host_lock);
 250         phba->fc_flag |= FC_FABRIC;
 251         spin_unlock_irq(phba->host->host_lock);
 252
 253         phba->fc_edtov = be32_to_cpu(sp->cmn.e_d_tov);
 254         if (sp->cmn.edtovResolution)    /* E_D_TOV ticks are in nanoseconds */
 255                 phba->fc_edtov = (phba->fc_edtov + 999999) / 1000000;
 256
 257         phba->fc_ratov = (be32_to_cpu(sp->cmn.w2.r_a_tov) + 999) / 1000;
 258
 259         if (phba->fc_topology == TOPOLOGY_LOOP) {
 260                 spin_lock_irq(phba->host->host_lock);
 261                 phba->fc_flag |= FC_PUBLIC_LOOP;
 262                 spin_unlock_irq(phba->host->host_lock);
 263         } else {
 264                 /*
 265                  * If we are a N-port connected to a Fabric, fixup sparam's so
 266                  * logins to devices on remote loops work.
 267                  */
 268                 phba->fc_sparam.cmn.altBbCredit = 1;
 269         }
 270
 271         phba->fc_myDID = irsp->un.ulpWord[4] & Mask_DID;
 272         memcpy(&ndlp->nlp_portname, &sp->portName, sizeof(struct lpfc_name));
 273         memcpy(&ndlp->nlp_nodename, &sp->nodeName, sizeof (struct lpfc_name));
 274         ndlp->nlp_class_sup = 0;
 275         if (sp->cls1.classValid)
 276                 ndlp->nlp_class_sup |= FC_COS_CLASS1;
 277         if (sp->cls2.classValid)
 278                 ndlp->nlp_class_sup |= FC_COS_CLASS2;
 279         if (sp->cls3.classValid)
 280                 ndlp->nlp_class_sup |= FC_COS_CLASS3;
 281         if (sp->cls4.classValid)
 282                 ndlp->nlp_class_sup |= FC_COS_CLASS4;
 283         ndlp->nlp_maxframe = ((sp->cmn.bbRcvSizeMsb & 0x0F) << 8) |
 284                                 sp->cmn.bbRcvSizeLsb;
 285         memcpy(&phba->fc_fabparam, sp, sizeof(struct serv_parm));
 286
 287         mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 288         if (!mbox)
 289                 goto fail;
 290
 291         phba->hba_state = LPFC_FABRIC_CFG_LINK;
 292         lpfc_config_link(phba, mbox);
 293         mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
 294
 295         rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT | MBX_STOP_IOCB);
 296         if (rc == MBX_NOT_FINISHED)
 297                 goto fail_free_mbox;
 298
 299         mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 300         if (!mbox)
 301                 goto fail;
 302
 303         if (lpfc_reg_login(phba, Fabric_DID, (uint8_t *) sp, mbox, 0))
 304                 goto fail_free_mbox;
 305
 306         mbox->mbox_cmpl = lpfc_mbx_cmpl_fabric_reg_login;
 307         mbox->context2 = ndlp;
 308
 309         rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT | MBX_STOP_IOCB);
 310         if (rc == MBX_NOT_FINISHED)
 311                 goto fail_issue_reg_login;
 312
 313         return 0;
 314
 315  fail_issue_reg_login:
 316         mp = (struct lpfc_dmabuf *) mbox->context1;
 317         lpfc_mbuf_free(phba, mp->virt, mp->phys);
 318         kfree(mp);
 319  fail_free_mbox:
 320         mempool_free(mbox, phba->mbox_mem_pool);
 321  fail:
 322         return -ENXIO;
 323 }
 324
 325 /*
 326  * We FLOGIed into an NPort, initiate pt2pt protocol
 327  */
 328 static int
 329 lpfc_cmpl_els_flogi_nport(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
 330                 struct serv_parm *sp)
 331 {
 332         LPFC_MBOXQ_t *mbox;
 333         int rc;
 334
 335         spin_lock_irq(phba->host->host_lock);
 336         phba->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP);
 337         spin_unlock_irq(phba->host->host_lock);
 338
 339         phba->fc_edtov = FF_DEF_EDTOV;
 340         phba->fc_ratov = FF_DEF_RATOV;
 341         rc = memcmp(&phba->fc_portname, &sp->portName,
 342                         sizeof(struct lpfc_name));
 343         if (rc >= 0) {
 344                 /* This side will initiate the PLOGI */
 345                 spin_lock_irq(phba->host->host_lock);
 346                 phba->fc_flag |= FC_PT2PT_PLOGI;
 347                 spin_unlock_irq(phba->host->host_lock);
 348
 349                 /*
 350                  * N_Port ID cannot be 0, set our to LocalID the other
 351                  * side will be RemoteID.
 352                  */
 353
 354                 /* not equal */
 355                 if (rc)
 356                         phba->fc_myDID = PT2PT_LocalID;
 357
 358                 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 359                 if (!mbox)
 360                         goto fail;
 361
 362                 lpfc_config_link(phba, mbox);
 363
 364                 mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
 365                 rc = lpfc_sli_issue_mbox(phba, mbox,
 366                                 MBX_NOWAIT | MBX_STOP_IOCB);
 367                 if (rc == MBX_NOT_FINISHED) {
 368                         mempool_free(mbox, phba->mbox_mem_pool);
 369                         goto fail;
 370                 }
 371                 mempool_free(ndlp, phba->nlp_mem_pool);
 372
 373                 ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, PT2PT_RemoteID);
 374                 if (!ndlp) {
 375                         /*
 376                          * Cannot find existing Fabric ndlp, so allocate a
 377                          * new one
 378                          */
 379                         ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
 380                         if (!ndlp)
 381                                 goto fail;
 382
 383                         lpfc_nlp_init(phba, ndlp, PT2PT_RemoteID);
 384                 }
 385
 386                 memcpy(&ndlp->nlp_portname, &sp->portName,
 387                                 sizeof(struct lpfc_name));
 388                 memcpy(&ndlp->nlp_nodename, &sp->nodeName,
 389                                 sizeof(struct lpfc_name));
 390                 ndlp->nlp_state = NLP_STE_NPR_NODE;
 391                 lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST);
 392                 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
 393         } else {
 394                 /* This side will wait for the PLOGI */
 395                 mempool_free( ndlp, phba->nlp_mem_pool);
 396         }
 397
 398         spin_lock_irq(phba->host->host_lock);
 399         phba->fc_flag |= FC_PT2PT;
 400         spin_unlock_irq(phba->host->host_lock);
 401
 402         /* Start discovery - this should just do CLEAR_LA */
 403         lpfc_disc_start(phba);
 404         return 0;
 405  fail:
 406         return -ENXIO;
 407 }
 408
 409 static void
 410 lpfc_cmpl_els_flogi(struct lpfc_hba * phba,
 411                     struct lpfc_iocbq * cmdiocb, struct lpfc_iocbq * rspiocb)
 412 {
 413         IOCB_t *irsp = &rspiocb->iocb;
 414         struct lpfc_nodelist *ndlp = cmdiocb->context1;
 415         struct lpfc_dmabuf *pcmd = cmdiocb->context2, *prsp;
 416         struct serv_parm *sp;
 417         int rc;
 418
 419         /* Check to see if link went down during discovery */
 420         if (lpfc_els_chk_latt(phba)) {
 421                 lpfc_nlp_remove(phba, ndlp);
 422                 goto out;
 423         }
 424
 425         if (irsp->ulpStatus) {
 426                 /* Check for retry */
 427                 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
 428                         /* ELS command is being retried */
 429                         goto out;
 430                 }
 431                 /* FLOGI failed, so there is no fabric */
 432                 spin_lock_irq(phba->host->host_lock);
 433                 phba->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP);
 434                 spin_unlock_irq(phba->host->host_lock);
 435
 436                 /* If private loop, then allow max outstandting els to be
 437                  * LPFC_MAX_DISC_THREADS (32). Scanning in the case of no
 438                  * alpa map would take too long otherwise.
 439                  */
 440                 if (phba->alpa_map[0] == 0) {
 441                         phba->cfg_discovery_threads =
 442                             LPFC_MAX_DISC_THREADS;
 443                 }
 444
 445                 /* FLOGI failure */
 446                 lpfc_printf_log(phba,
 447                                 KERN_INFO,
 448                                 LOG_ELS,
 449                                 "%d:0100 FLOGI failure Data: x%x x%x x%x\n",
 450                                 phba->brd_no,
 451                                 irsp->ulpStatus, irsp->un.ulpWord[4],
 452                                 irsp->ulpTimeout);
 453                 goto flogifail;
 454         }
 455
 456         /*
 457          * The FLogI succeeded.  Sync the data for the CPU before
 458          * accessing it.
 459          */
 460         prsp = list_get_first(&pcmd->list, struct lpfc_dmabuf, list);
 461
 462         sp = prsp->virt + sizeof(uint32_t);
 463
 464         /* FLOGI completes successfully */
 465         lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
 466                         "%d:0101 FLOGI completes sucessfully "
 467                         "Data: x%x x%x x%x x%x\n",
 468                         phba->brd_no,
 469                         irsp->un.ulpWord[4], sp->cmn.e_d_tov,
 470                         sp->cmn.w2.r_a_tov, sp->cmn.edtovResolution);
 471
 472         if (phba->hba_state == LPFC_FLOGI) {
 473                 /*
 474                  * If Common Service Parameters indicate Nport
 475                  * we are point to point, if Fport we are Fabric.
 476                  */
 477                 if (sp->cmn.fPort)
 478                         rc = lpfc_cmpl_els_flogi_fabric(phba, ndlp, sp, irsp);
 479                 else
 480                         rc = lpfc_cmpl_els_flogi_nport(phba, ndlp, sp);
 481
 482                 if (!rc)
 483                         goto out;
 484         }
 485
 486 flogifail:
 487         lpfc_nlp_remove(phba, ndlp);
 488
 489         if (irsp->ulpStatus != IOSTAT_LOCAL_REJECT ||
 490             (irsp->un.ulpWord[4] != IOERR_SLI_ABORTED &&
 491              irsp->un.ulpWord[4] != IOERR_SLI_DOWN)) {
 492                 /* FLOGI failed, so just use loop map to make discovery list */
 493                 lpfc_disc_list_loopmap(phba);
 494
 495                 /* Start discovery */
 496                 lpfc_disc_start(phba);
 497         }
 498
 499 out:
 500         lpfc_els_free_iocb(phba, cmdiocb);
 501 }
 502
 503 static int
 504 lpfc_issue_els_flogi(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp,
 505                      uint8_t retry)
 506 {
 507         struct serv_parm *sp;
 508         IOCB_t *icmd;
 509         struct lpfc_iocbq *elsiocb;
 510         struct lpfc_sli_ring *pring;
 511         uint8_t *pcmd;
 512         uint16_t cmdsize;
 513         uint32_t tmo;
 514         int rc;
 515
 516         pring = &phba->sli.ring[LPFC_ELS_RING];
 517
 518         cmdsize = (sizeof (uint32_t) + sizeof (struct serv_parm));
 519         elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, ndlp,
 520                                                  ndlp->nlp_DID, ELS_CMD_FLOGI);
 521         if (!elsiocb)
 522                 return 1;
 523
 524         icmd = &elsiocb->iocb;
 525         pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
 526
 527         /* For FLOGI request, remainder of payload is service parameters */
 528         *((uint32_t *) (pcmd)) = ELS_CMD_FLOGI;
 529         pcmd += sizeof (uint32_t);
 530         memcpy(pcmd, &phba->fc_sparam, sizeof (struct serv_parm));
 531         sp = (struct serv_parm *) pcmd;
 532
 533         /* Setup CSPs accordingly for Fabric */
 534         sp->cmn.e_d_tov = 0;
 535         sp->cmn.w2.r_a_tov = 0;
 536         sp->cls1.classValid = 0;
 537         sp->cls2.seqDelivery = 1;
 538         sp->cls3.seqDelivery = 1;
 539         if (sp->cmn.fcphLow < FC_PH3)
 540                 sp->cmn.fcphLow = FC_PH3;
 541         if (sp->cmn.fcphHigh < FC_PH3)
 542                 sp->cmn.fcphHigh = FC_PH3;
 543
 544         tmo = phba->fc_ratov;
 545         phba->fc_ratov = LPFC_DISC_FLOGI_TMO;
 546         lpfc_set_disctmo(phba);
 547         phba->fc_ratov = tmo;
 548
 549         phba->fc_stat.elsXmitFLOGI++;
 550         elsiocb->iocb_cmpl = lpfc_cmpl_els_flogi;
 551         spin_lock_irq(phba->host->host_lock);
 552         rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
 553         spin_unlock_irq(phba->host->host_lock);
 554         if (rc == IOCB_ERROR) {
 555                 lpfc_els_free_iocb(phba, elsiocb);
 556                 return 1;
 557         }
 558         return 0;
 559 }
 560
 561 int
 562 lpfc_els_abort_flogi(struct lpfc_hba * phba)
 563 {
 564         struct lpfc_sli_ring *pring;
 565         struct lpfc_iocbq *iocb, *next_iocb;
 566         struct lpfc_nodelist *ndlp;
 567         IOCB_t *icmd;
 568
 569         /* Abort outstanding I/O on NPort <nlp_DID> */
 570         lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
 571                         "%d:0201 Abort outstanding I/O on NPort x%x\n",
 572                         phba->brd_no, Fabric_DID);
 573
 574         pring = &phba->sli.ring[LPFC_ELS_RING];
 575
 576         /*
 577          * Check the txcmplq for an iocb that matches the nport the driver is
 578          * searching for.
 579          */
 580         spin_lock_irq(phba->host->host_lock);
 581         list_for_each_entry_safe(iocb, next_iocb, &pring->txcmplq, list) {
 582                 icmd = &iocb->iocb;
 583                 if (icmd->ulpCommand == CMD_ELS_REQUEST64_CR) {
 584                         ndlp = (struct lpfc_nodelist *)(iocb->context1);
 585                         if (ndlp && (ndlp->nlp_DID == Fabric_DID)) {
 586                                 list_del(&iocb->list);
 587                                 pring->txcmplq_cnt--;
 588
 589                                 if ((icmd->un.elsreq64.bdl.ulpIoTag32)) {
 590                                         lpfc_sli_issue_abort_iotag32
 591                                                 (phba, pring, iocb);
 592                                 }
 593                                 if (iocb->iocb_cmpl) {
 594                                         icmd->ulpStatus = IOSTAT_LOCAL_REJECT;
 595                                         icmd->un.ulpWord[4] =
 596                                             IOERR_SLI_ABORTED;
 597                                         spin_unlock_irq(phba->host->host_lock);
 598                                         (iocb->iocb_cmpl) (phba, iocb, iocb);
 599                                         spin_lock_irq(phba->host->host_lock);
 600                                 } else
 601                                         lpfc_sli_release_iocbq(phba, iocb);
 602                         }
 603                 }
 604         }
 605         spin_unlock_irq(phba->host->host_lock);
 606
 607         return 0;
 608 }
 609
 610 int
 611 lpfc_initial_flogi(struct lpfc_hba * phba)
 612 {
 613         struct lpfc_nodelist *ndlp;
 614
 615         /* First look for the Fabric ndlp */
 616         ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, Fabric_DID);
 617         if (!ndlp) {
 618                 /* Cannot find existing Fabric ndlp, so allocate a new one */
 619                 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
 620                 if (!ndlp)
 621                         return 0;
 622                 lpfc_nlp_init(phba, ndlp, Fabric_DID);
 623         } else {
 624                 lpfc_nlp_list(phba, ndlp, NLP_JUST_DQ);
 625         }
 626         if (lpfc_issue_els_flogi(phba, ndlp, 0)) {
 627                 mempool_free( ndlp, phba->nlp_mem_pool);
 628         }
 629         return 1;
 630 }
 631
 632 static void
 633 lpfc_more_plogi(struct lpfc_hba * phba)
 634 {
 635         int sentplogi;
 636
 637         if (phba->num_disc_nodes)
 638                 phba->num_disc_nodes--;
 639
 640         /* Continue discovery with <num_disc_nodes> PLOGIs to go */
 641         lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
 642                         "%d:0232 Continue discovery with %d PLOGIs to go "
 643                         "Data: x%x x%x x%x\n",
 644                         phba->brd_no, phba->num_disc_nodes, phba->fc_plogi_cnt,
 645                         phba->fc_flag, phba->hba_state);
 646
 647         /* Check to see if there are more PLOGIs to be sent */
 648         if (phba->fc_flag & FC_NLP_MORE) {
 649                 /* go thru NPR list and issue any remaining ELS PLOGIs */
 650                 sentplogi = lpfc_els_disc_plogi(phba);
 651         }
 652         return;
 653 }
 654
 655 static struct lpfc_nodelist *
 656 lpfc_plogi_confirm_nport(struct lpfc_hba * phba, struct lpfc_dmabuf *prsp,
 657                          struct lpfc_nodelist *ndlp)
 658 {
 659         struct lpfc_nodelist *new_ndlp;
 660         uint32_t *lp;
 661         struct serv_parm *sp;
 662         uint8_t name[sizeof (struct lpfc_name)];
 663         uint32_t rc;
 664
 665         /* Fabric nodes can have the same WWPN so we don't bother searching
 666          * by WWPN.  Just return the ndlp that was given to us.
 667          */
 668         if (ndlp->nlp_type & NLP_FABRIC)
 669                 return ndlp;
 670
 671         lp = (uint32_t *) prsp->virt;
 672         sp = (struct serv_parm *) ((uint8_t *) lp + sizeof (uint32_t));
 673         memset(name, 0, sizeof (struct lpfc_name));
 674
 675         /* Now we to find out if the NPort we are logging into, matches the WWPN
 676          * we have for that ndlp. If not, we have some work to do.
 677          */
 678         new_ndlp = lpfc_findnode_wwpn(phba, NLP_SEARCH_ALL, &sp->portName);
 679
 680         if (new_ndlp == ndlp)
 681                 return ndlp;
 682
 683         if (!new_ndlp) {
 684                 rc =
 685                    memcmp(&ndlp->nlp_portname, name, sizeof(struct lpfc_name));
 686                 if (!rc)
 687                         return ndlp;
 688                 new_ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_ATOMIC);
 689                 if (!new_ndlp)
 690                         return ndlp;
 691
 692                 lpfc_nlp_init(phba, new_ndlp, ndlp->nlp_DID);
 693         }
 694
 695         lpfc_unreg_rpi(phba, new_ndlp);
 696         new_ndlp->nlp_DID = ndlp->nlp_DID;
 697         new_ndlp->nlp_prev_state = ndlp->nlp_prev_state;
 698         new_ndlp->nlp_state = ndlp->nlp_state;
 699         lpfc_nlp_list(phba, new_ndlp, ndlp->nlp_flag & NLP_LIST_MASK);
 700
 701         /* Move this back to NPR list */
 702         if (memcmp(&ndlp->nlp_portname, name, sizeof(struct lpfc_name)) == 0) {
 703                 lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
 704         }
 705         else {
 706                 lpfc_unreg_rpi(phba, ndlp);
 707                 ndlp->nlp_DID = 0; /* Two ndlps cannot have the same did */
 708                 ndlp->nlp_state = NLP_STE_NPR_NODE;
 709                 lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST);
 710         }
 711         return new_ndlp;
 712 }
 713
 714 static void
 715 lpfc_cmpl_els_plogi(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
 716                     struct lpfc_iocbq * rspiocb)
 717 {
 718         IOCB_t *irsp;
 719         struct lpfc_nodelist *ndlp;
 720         struct lpfc_dmabuf *prsp;
 721         int disc, rc, did, type;
 722
 723
 724         /* we pass cmdiocb to state machine which needs rspiocb as well */
 725         cmdiocb->context_un.rsp_iocb = rspiocb;
 726
 727         irsp = &rspiocb->iocb;
 728         ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL,
 729                                                 irsp->un.elsreq64.remoteID);
 730         if (!ndlp)
 731                 goto out;
 732
 733         /* Since ndlp can be freed in the disc state machine, note if this node
 734          * is being used during discovery.
 735          */
 736         disc = (ndlp->nlp_flag & NLP_NPR_2B_DISC);
 737         spin_lock_irq(phba->host->host_lock);
 738         ndlp->nlp_flag &= ~NLP_NPR_2B_DISC;
 739         spin_unlock_irq(phba->host->host_lock);
 740         rc   = 0;
 741
 742         /* PLOGI completes to NPort <nlp_DID> */
 743         lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
 744                         "%d:0102 PLOGI completes to NPort x%x "
 745                         "Data: x%x x%x x%x x%x x%x\n",
 746                         phba->brd_no, ndlp->nlp_DID, irsp->ulpStatus,
 747                         irsp->un.ulpWord[4], irsp->ulpTimeout, disc,
 748                         phba->num_disc_nodes);
 749
 750         /* Check to see if link went down during discovery */
 751         if (lpfc_els_chk_latt(phba)) {
 752                 spin_lock_irq(phba->host->host_lock);
 753                 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
 754                 spin_unlock_irq(phba->host->host_lock);
 755                 goto out;
 756         }
 757
 758         /* ndlp could be freed in DSM, save these values now */
 759         type = ndlp->nlp_type;
 760         did = ndlp->nlp_DID;
 761
 762         if (irsp->ulpStatus) {
 763                 /* Check for retry */
 764                 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
 765                         /* ELS command is being retried */
 766                         if (disc) {
 767                                 spin_lock_irq(phba->host->host_lock);
 768                                 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
 769                                 spin_unlock_irq(phba->host->host_lock);
 770                         }
 771                         goto out;
 772                 }
 773
 774                 /* PLOGI failed */
 775                 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
 776                 if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
 777                    ((irsp->un.ulpWord[4] == IOERR_SLI_ABORTED) ||
 778                    (irsp->un.ulpWord[4] == IOERR_LINK_DOWN) ||
 779                    (irsp->un.ulpWord[4] == IOERR_SLI_DOWN))) {
 780                         rc = NLP_STE_FREED_NODE;
 781                 } else {
 782                         rc = lpfc_disc_state_machine(phba, ndlp, cmdiocb,
 783                                         NLP_EVT_CMPL_PLOGI);
 784                 }
 785         } else {
 786                 /* Good status, call state machine */
 787                 prsp = list_entry(((struct lpfc_dmabuf *)
 788                         cmdiocb->context2)->list.next,
 789                         struct lpfc_dmabuf, list);
 790                 ndlp = lpfc_plogi_confirm_nport(phba, prsp, ndlp);
 791                 rc = lpfc_disc_state_machine(phba, ndlp, cmdiocb,
 792                                         NLP_EVT_CMPL_PLOGI);
 793         }
 794
 795         if (disc && phba->num_disc_nodes) {
 796                 /* Check to see if there are more PLOGIs to be sent */
 797                 lpfc_more_plogi(phba);
 798
 799                 if (phba->num_disc_nodes == 0) {
 800                         spin_lock_irq(phba->host->host_lock);
 801                         phba->fc_flag &= ~FC_NDISC_ACTIVE;
 802                         spin_unlock_irq(phba->host->host_lock);
 803
 804                         lpfc_can_disctmo(phba);
 805                         if (phba->fc_flag & FC_RSCN_MODE) {
 806                                 /*
 807                                  * Check to see if more RSCNs came in while
 808                                  * we were processing this one.
 809                                  */
 810                                 if ((phba->fc_rscn_id_cnt == 0) &&
 811                                 (!(phba->fc_flag & FC_RSCN_DISCOVERY))) {
 812                                         spin_lock_irq(phba->host->host_lock);
 813                                         phba->fc_flag &= ~FC_RSCN_MODE;
 814                                         spin_unlock_irq(phba->host->host_lock);
 815                                 } else {
 816                                         lpfc_els_handle_rscn(phba);
 817                                 }
 818                         }
 819                 }
 820         }
 821
 822 out:
 823         lpfc_els_free_iocb(phba, cmdiocb);
 824         return;
 825 }
 826
 827 int
 828 lpfc_issue_els_plogi(struct lpfc_hba * phba, uint32_t did, uint8_t retry)
 829 {
 830         struct serv_parm *sp;
 831         IOCB_t *icmd;
 832         struct lpfc_iocbq *elsiocb;
 833         struct lpfc_sli_ring *pring;
 834         struct lpfc_sli *psli;
 835         uint8_t *pcmd;
 836         uint16_t cmdsize;
 837
 838         psli = &phba->sli;
 839         pring = &psli->ring[LPFC_ELS_RING];     /* ELS ring */
 840
 841         cmdsize = (sizeof (uint32_t) + sizeof (struct serv_parm));
 842         elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, NULL, did,
 843                                                                 ELS_CMD_PLOGI);
 844         if (!elsiocb)
 845                 return 1;
 846
 847         icmd = &elsiocb->iocb;
 848         pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
 849
 850         /* For PLOGI request, remainder of payload is service parameters */
 851         *((uint32_t *) (pcmd)) = ELS_CMD_PLOGI;
 852         pcmd += sizeof (uint32_t);
 853         memcpy(pcmd, &phba->fc_sparam, sizeof (struct serv_parm));
 854         sp = (struct serv_parm *) pcmd;
 855
 856         if (sp->cmn.fcphLow < FC_PH_4_3)
 857                 sp->cmn.fcphLow = FC_PH_4_3;
 858
 859         if (sp->cmn.fcphHigh < FC_PH3)
 860                 sp->cmn.fcphHigh = FC_PH3;
 861
 862         phba->fc_stat.elsXmitPLOGI++;
 863         elsiocb->iocb_cmpl = lpfc_cmpl_els_plogi;
 864         spin_lock_irq(phba->host->host_lock);
 865         if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
 866                 spin_unlock_irq(phba->host->host_lock);
 867                 lpfc_els_free_iocb(phba, elsiocb);
 868                 return 1;
 869         }
 870         spin_unlock_irq(phba->host->host_lock);
 871         return 0;
 872 }
 873
 874 static void
 875 lpfc_cmpl_els_prli(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
 876                    struct lpfc_iocbq * rspiocb)
 877 {
 878         IOCB_t *irsp;
 879         struct lpfc_sli *psli;
 880         struct lpfc_nodelist *ndlp;
 881
 882         psli = &phba->sli;
 883         /* we pass cmdiocb to state machine which needs rspiocb as well */
 884         cmdiocb->context_un.rsp_iocb = rspiocb;
 885
 886         irsp = &(rspiocb->iocb);
 887         ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
 888         spin_lock_irq(phba->host->host_lock);
 889         ndlp->nlp_flag &= ~NLP_PRLI_SND;
 890         spin_unlock_irq(phba->host->host_lock);
 891
 892         /* PRLI completes to NPort <nlp_DID> */
 893         lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
 894                         "%d:0103 PRLI completes to NPort x%x "
 895                         "Data: x%x x%x x%x x%x\n",
 896                         phba->brd_no, ndlp->nlp_DID, irsp->ulpStatus,
 897                         irsp->un.ulpWord[4], irsp->ulpTimeout,
 898                         phba->num_disc_nodes);
 899
 900         phba->fc_prli_sent--;
 901         /* Check to see if link went down during discovery */
 902         if (lpfc_els_chk_latt(phba))
 903                 goto out;
 904
 905         if (irsp->ulpStatus) {
 906                 /* Check for retry */
 907                 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
 908                         /* ELS command is being retried */
 909                         goto out;
 910                 }
 911                 /* PRLI failed */
 912                 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
 913                 if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
 914                    ((irsp->un.ulpWord[4] == IOERR_SLI_ABORTED) ||
 915                    (irsp->un.ulpWord[4] == IOERR_LINK_DOWN) ||
 916                    (irsp->un.ulpWord[4] == IOERR_SLI_DOWN))) {
 917                         goto out;
 918                 } else {
 919                         lpfc_disc_state_machine(phba, ndlp, cmdiocb,
 920                                         NLP_EVT_CMPL_PRLI);
 921                 }
 922         } else {
 923                 /* Good status, call state machine */
 924                 lpfc_disc_state_machine(phba, ndlp, cmdiocb, NLP_EVT_CMPL_PRLI);
 925         }
 926
 927 out:
 928         lpfc_els_free_iocb(phba, cmdiocb);
 929         return;
 930 }
 931
 932 int
 933 lpfc_issue_els_prli(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp,
 934                     uint8_t retry)
 935 {
 936         PRLI *npr;
 937         IOCB_t *icmd;
 938         struct lpfc_iocbq *elsiocb;
 939         struct lpfc_sli_ring *pring;
 940         struct lpfc_sli *psli;
 941         uint8_t *pcmd;
 942         uint16_t cmdsize;
 943
 944         psli = &phba->sli;
 945         pring = &psli->ring[LPFC_ELS_RING];     /* ELS ring */
 946
 947         cmdsize = (sizeof (uint32_t) + sizeof (PRLI));
 948         elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, ndlp,
 949                                         ndlp->nlp_DID, ELS_CMD_PRLI);
 950         if (!elsiocb)
 951                 return 1;
 952
 953         icmd = &elsiocb->iocb;
 954         pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
 955
 956         /* For PRLI request, remainder of payload is service parameters */
 957         memset(pcmd, 0, (sizeof (PRLI) + sizeof (uint32_t)));
 958         *((uint32_t *) (pcmd)) = ELS_CMD_PRLI;
 959         pcmd += sizeof (uint32_t);
 960
 961         /* For PRLI, remainder of payload is PRLI parameter page */
 962         npr = (PRLI *) pcmd;
 963         /*
 964          * If our firmware version is 3.20 or later,
 965          * set the following bits for FC-TAPE support.
 966          */
 967         if (phba->vpd.rev.feaLevelHigh >= 0x02) {
 968                 npr->ConfmComplAllowed = 1;
 969                 npr->Retry = 1;
 970                 npr->TaskRetryIdReq = 1;
 971         }
 972         npr->estabImagePair = 1;
 973         npr->readXferRdyDis = 1;
 974
 975         /* For FCP support */
 976         npr->prliType = PRLI_FCP_TYPE;
 977         npr->initiatorFunc = 1;
 978
 979         phba->fc_stat.elsXmitPRLI++;
 980         elsiocb->iocb_cmpl = lpfc_cmpl_els_prli;
 981         spin_lock_irq(phba->host->host_lock);
 982         ndlp->nlp_flag |= NLP_PRLI_SND;
 983         if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
 984                 ndlp->nlp_flag &= ~NLP_PRLI_SND;
 985                 spin_unlock_irq(phba->host->host_lock);
 986                 lpfc_els_free_iocb(phba, elsiocb);
 987                 return 1;
 988         }
 989         spin_unlock_irq(phba->host->host_lock);
 990         phba->fc_prli_sent++;
 991         return 0;
 992 }
 993
 994 static void
 995 lpfc_more_adisc(struct lpfc_hba * phba)
 996 {
 997         int sentadisc;
 998
 999         if (phba->num_disc_nodes)
1000                 phba->num_disc_nodes--;
1001
1002         /* Continue discovery with <num_disc_nodes> ADISCs to go */
1003         lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
1004                         "%d:0210 Continue discovery with %d ADISCs to go "
1005                         "Data: x%x x%x x%x\n",
1006                         phba->brd_no, phba->num_disc_nodes, phba->fc_adisc_cnt,
1007                         phba->fc_flag, phba->hba_state);
1008
1009         /* Check to see if there are more ADISCs to be sent */
1010         if (phba->fc_flag & FC_NLP_MORE) {
1011                 lpfc_set_disctmo(phba);
1012
1013                 /* go thru NPR list and issue any remaining ELS ADISCs */
1014                 sentadisc = lpfc_els_disc_adisc(phba);
1015         }
1016         return;
1017 }
1018
1019 static void
1020 lpfc_rscn_disc(struct lpfc_hba * phba)
1021 {
1022         /* RSCN discovery */
1023         /* go thru NPR list and issue ELS PLOGIs */
1024         if (phba->fc_npr_cnt) {
1025                 if (lpfc_els_disc_plogi(phba))
1026                         return;
1027         }
1028         if (phba->fc_flag & FC_RSCN_MODE) {
1029                 /* Check to see if more RSCNs came in while we were
1030                  * processing this one.
1031                  */
1032                 if ((phba->fc_rscn_id_cnt == 0) &&
1033                     (!(phba->fc_flag & FC_RSCN_DISCOVERY))) {
1034                         spin_lock_irq(phba->host->host_lock);
1035                         phba->fc_flag &= ~FC_RSCN_MODE;
1036                         spin_unlock_irq(phba->host->host_lock);
1037                 } else {
1038                         lpfc_els_handle_rscn(phba);
1039                 }
1040         }
1041 }
1042
1043 static void
1044 lpfc_cmpl_els_adisc(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
1045                     struct lpfc_iocbq * rspiocb)
1046 {
1047         IOCB_t *irsp;
1048         struct lpfc_sli *psli;
1049         struct lpfc_nodelist *ndlp;
1050         LPFC_MBOXQ_t *mbox;
1051         int disc, rc;
1052
1053         psli = &phba->sli;
1054
1055         /* we pass cmdiocb to state machine which needs rspiocb as well */
1056         cmdiocb->context_un.rsp_iocb = rspiocb;
1057
1058         irsp = &(rspiocb->iocb);
1059         ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
1060
1061         /* Since ndlp can be freed in the disc state machine, note if this node
1062          * is being used during discovery.
1063          */
1064         disc = (ndlp->nlp_flag & NLP_NPR_2B_DISC);
1065         spin_lock_irq(phba->host->host_lock);
1066         ndlp->nlp_flag &= ~(NLP_ADISC_SND | NLP_NPR_2B_DISC);
1067         spin_unlock_irq(phba->host->host_lock);
1068
1069         /* ADISC completes to NPort <nlp_DID> */
1070         lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
1071                         "%d:0104 ADISC completes to NPort x%x "
1072                         "Data: x%x x%x x%x x%x x%x\n",
1073                         phba->brd_no, ndlp->nlp_DID, irsp->ulpStatus,
1074                         irsp->un.ulpWord[4], irsp->ulpTimeout, disc,
1075                         phba->num_disc_nodes);
1076
1077         /* Check to see if link went down during discovery */
1078         if (lpfc_els_chk_latt(phba)) {
1079                 spin_lock_irq(phba->host->host_lock);
1080                 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
1081                 spin_unlock_irq(phba->host->host_lock);
1082                 goto out;
1083         }
1084
1085         if (irsp->ulpStatus) {
1086                 /* Check for retry */
1087                 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
1088                         /* ELS command is being retried */
1089                         if (disc) {
1090                                 spin_lock_irq(phba->host->host_lock);
1091                                 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
1092                                 spin_unlock_irq(phba->host->host_lock);
1093                                 lpfc_set_disctmo(phba);
1094                         }
1095                         goto out;
1096                 }
1097                 /* ADISC failed */
1098                 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
1099                 if ((irsp->ulpStatus != IOSTAT_LOCAL_REJECT) ||
1100                    ((irsp->un.ulpWord[4] != IOERR_SLI_ABORTED) &&
1101                    (irsp->un.ulpWord[4] != IOERR_LINK_DOWN) &&
1102                    (irsp->un.ulpWord[4] != IOERR_SLI_DOWN))) {
1103                         lpfc_disc_state_machine(phba, ndlp, cmdiocb,
1104                                         NLP_EVT_CMPL_ADISC);
1105                 }
1106         } else {
1107                 /* Good status, call state machine */
1108                 lpfc_disc_state_machine(phba, ndlp, cmdiocb,
1109                                         NLP_EVT_CMPL_ADISC);
1110         }
1111
1112         if (disc && phba->num_disc_nodes) {
1113                 /* Check to see if there are more ADISCs to be sent */
1114                 lpfc_more_adisc(phba);
1115
1116                 /* Check to see if we are done with ADISC authentication */
1117                 if (phba->num_disc_nodes == 0) {
1118                         lpfc_can_disctmo(phba);
1119                         /* If we get here, there is nothing left to wait for */
1120                         if ((phba->hba_state < LPFC_HBA_READY) &&
1121                             (phba->hba_state != LPFC_CLEAR_LA)) {
1122                                 /* Link up discovery */
1123                                 if ((mbox = mempool_alloc(phba->mbox_mem_pool,
1124                                                           GFP_KERNEL))) {
1125                                         phba->hba_state = LPFC_CLEAR_LA;
1126                                         lpfc_clear_la(phba, mbox);
1127                                         mbox->mbox_cmpl =
1128                                             lpfc_mbx_cmpl_clear_la;
1129                                         rc = lpfc_sli_issue_mbox
1130                                                 (phba, mbox,
1131                                                  (MBX_NOWAIT | MBX_STOP_IOCB));
1132                                         if (rc == MBX_NOT_FINISHED) {
1133                                                 mempool_free(mbox,
1134                                                      phba->mbox_mem_pool);
1135                                                 lpfc_disc_flush_list(phba);
1136                                                 psli->ring[(psli->extra_ring)].
1137                                                     flag &=
1138                                                     ~LPFC_STOP_IOCB_EVENT;
1139                                                 psli->ring[(psli->fcp_ring)].
1140                                                     flag &=
1141                                                     ~LPFC_STOP_IOCB_EVENT;
1142                                                 psli->ring[(psli->next_ring)].
1143                                                     flag &=
1144                                                     ~LPFC_STOP_IOCB_EVENT;
1145                                                 phba->hba_state =
1146                                                     LPFC_HBA_READY;
1147                                         }
1148                                 }
1149                         } else {
1150                                 lpfc_rscn_disc(phba);
1151                         }
1152                 }
1153         }
1154 out:
1155         lpfc_els_free_iocb(phba, cmdiocb);
1156         return;
1157 }
1158
1159 int
1160 lpfc_issue_els_adisc(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp,
1161                      uint8_t retry)
1162 {
1163         ADISC *ap;
1164         IOCB_t *icmd;
1165         struct lpfc_iocbq *elsiocb;
1166         struct lpfc_sli_ring *pring;
1167         struct lpfc_sli *psli;
1168         uint8_t *pcmd;
1169         uint16_t cmdsize;
1170
1171         psli = &phba->sli;
1172         pring = &psli->ring[LPFC_ELS_RING];     /* ELS ring */
1173
1174         cmdsize = (sizeof (uint32_t) + sizeof (ADISC));
1175         elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, ndlp,
1176                                                 ndlp->nlp_DID, ELS_CMD_ADISC);
1177         if (!elsiocb)
1178                 return 1;
1179
1180         icmd = &elsiocb->iocb;
1181         pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1182
1183         /* For ADISC request, remainder of payload is service parameters */
1184         *((uint32_t *) (pcmd)) = ELS_CMD_ADISC;
1185         pcmd += sizeof (uint32_t);
1186
1187         /* Fill in ADISC payload */
1188         ap = (ADISC *) pcmd;
1189         ap->hardAL_PA = phba->fc_pref_ALPA;
1190         memcpy(&ap->portName, &phba->fc_portname, sizeof (struct lpfc_name));
1191         memcpy(&ap->nodeName, &phba->fc_nodename, sizeof (struct lpfc_name));
1192         ap->DID = be32_to_cpu(phba->fc_myDID);
1193
1194         phba->fc_stat.elsXmitADISC++;
1195         elsiocb->iocb_cmpl = lpfc_cmpl_els_adisc;
1196         spin_lock_irq(phba->host->host_lock);
1197         ndlp->nlp_flag |= NLP_ADISC_SND;
1198         if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
1199                 ndlp->nlp_flag &= ~NLP_ADISC_SND;
1200                 spin_unlock_irq(phba->host->host_lock);
1201                 lpfc_els_free_iocb(phba, elsiocb);
1202                 return 1;
1203         }
1204         spin_unlock_irq(phba->host->host_lock);
1205         return 0;
1206 }
1207
1208 static void
1209 lpfc_cmpl_els_logo(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
1210                    struct lpfc_iocbq * rspiocb)
1211 {
1212         IOCB_t *irsp;
1213         struct lpfc_sli *psli;
1214         struct lpfc_nodelist *ndlp;
1215
1216         psli = &phba->sli;
1217         /* we pass cmdiocb to state machine which needs rspiocb as well */
1218         cmdiocb->context_un.rsp_iocb = rspiocb;
1219
1220         irsp = &(rspiocb->iocb);
1221         ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
1222         spin_lock_irq(phba->host->host_lock);
1223         ndlp->nlp_flag &= ~NLP_LOGO_SND;
1224         spin_unlock_irq(phba->host->host_lock);
1225
1226         /* LOGO completes to NPort <nlp_DID> */
1227         lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
1228                         "%d:0105 LOGO completes to NPort x%x "
1229                         "Data: x%x x%x x%x x%x\n",
1230                         phba->brd_no, ndlp->nlp_DID, irsp->ulpStatus,
1231                         irsp->un.ulpWord[4], irsp->ulpTimeout,
1232                         phba->num_disc_nodes);
1233
1234         /* Check to see if link went down during discovery */
1235         if (lpfc_els_chk_latt(phba))
1236                 goto out;
1237
1238         if (irsp->ulpStatus) {
1239                 /* Check for retry */
1240                 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
1241                         /* ELS command is being retried */
1242                         goto out;
1243                 }
1244                 /* LOGO failed */
1245                 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
1246                 if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
1247                    ((irsp->un.ulpWord[4] == IOERR_SLI_ABORTED) ||
1248                    (irsp->un.ulpWord[4] == IOERR_LINK_DOWN) ||
1249                    (irsp->un.ulpWord[4] == IOERR_SLI_DOWN))) {
1250                         goto out;
1251                 } else {
1252                         lpfc_disc_state_machine(phba, ndlp, cmdiocb,
1253                                         NLP_EVT_CMPL_LOGO);
1254                 }
1255         } else {
1256                 /* Good status, call state machine.
1257                  * This will unregister the rpi if needed.
1258                  */
1259                 lpfc_disc_state_machine(phba, ndlp, cmdiocb, NLP_EVT_CMPL_LOGO);
1260         }
1261
1262 out:
1263         lpfc_els_free_iocb(phba, cmdiocb);
1264         return;
1265 }
1266
1267 int
1268 lpfc_issue_els_logo(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp,
1269                     uint8_t retry)
1270 {
1271         IOCB_t *icmd;
1272         struct lpfc_iocbq *elsiocb;
1273         struct lpfc_sli_ring *pring;
1274         struct lpfc_sli *psli;
1275         uint8_t *pcmd;
1276         uint16_t cmdsize;
1277
1278         psli = &phba->sli;
1279         pring = &psli->ring[LPFC_ELS_RING];
1280
1281         cmdsize = (2 * sizeof (uint32_t)) + sizeof (struct lpfc_name);
1282         elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, ndlp,
1283                                                 ndlp->nlp_DID, ELS_CMD_LOGO);
1284         if (!elsiocb)
1285                 return 1;
1286
1287         icmd = &elsiocb->iocb;
1288         pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1289         *((uint32_t *) (pcmd)) = ELS_CMD_LOGO;
1290         pcmd += sizeof (uint32_t);
1291
1292         /* Fill in LOGO payload */
1293         *((uint32_t *) (pcmd)) = be32_to_cpu(phba->fc_myDID);
1294         pcmd += sizeof (uint32_t);
1295         memcpy(pcmd, &phba->fc_portname, sizeof (struct lpfc_name));
1296
1297         phba->fc_stat.elsXmitLOGO++;
1298         elsiocb->iocb_cmpl = lpfc_cmpl_els_logo;
1299         spin_lock_irq(phba->host->host_lock);
1300         ndlp->nlp_flag |= NLP_LOGO_SND;
1301         if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
1302                 ndlp->nlp_flag &= ~NLP_LOGO_SND;
1303                 spin_unlock_irq(phba->host->host_lock);
1304                 lpfc_els_free_iocb(phba, elsiocb);
1305                 return 1;
1306         }
1307         spin_unlock_irq(phba->host->host_lock);
1308         return 0;
1309 }
1310
1311 static void
1312 lpfc_cmpl_els_cmd(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
1313                   struct lpfc_iocbq * rspiocb)
1314 {
1315         IOCB_t *irsp;
1316
1317         irsp = &rspiocb->iocb;
1318
1319         /* ELS cmd tag <ulpIoTag> completes */
1320         lpfc_printf_log(phba,
1321                         KERN_INFO,
1322                         LOG_ELS,
1323                         "%d:0106 ELS cmd tag x%x completes Data: x%x x%x x%x\n",
1324                         phba->brd_no,
1325                         irsp->ulpIoTag, irsp->ulpStatus,
1326                         irsp->un.ulpWord[4], irsp->ulpTimeout);
1327
1328         /* Check to see if link went down during discovery */
1329         lpfc_els_chk_latt(phba);
1330         lpfc_els_free_iocb(phba, cmdiocb);
1331         return;
1332 }
1333
1334 int
1335 lpfc_issue_els_scr(struct lpfc_hba * phba, uint32_t nportid, uint8_t retry)
1336 {
1337         IOCB_t *icmd;
1338         struct lpfc_iocbq *elsiocb;
1339         struct lpfc_sli_ring *pring;
1340         struct lpfc_sli *psli;
1341         uint8_t *pcmd;
1342         uint16_t cmdsize;
1343         struct lpfc_nodelist *ndlp;
1344
1345         psli = &phba->sli;
1346         pring = &psli->ring[LPFC_ELS_RING];     /* ELS ring */
1347         cmdsize = (sizeof (uint32_t) + sizeof (SCR));
1348         ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
1349         if (!ndlp)
1350                 return 1;
1351
1352         lpfc_nlp_init(phba, ndlp, nportid);
1353
1354         elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, ndlp,
1355                                                 ndlp->nlp_DID, ELS_CMD_SCR);
1356         if (!elsiocb) {
1357                 mempool_free( ndlp, phba->nlp_mem_pool);
1358                 return 1;
1359         }
1360
1361         icmd = &elsiocb->iocb;
1362         pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1363
1364         *((uint32_t *) (pcmd)) = ELS_CMD_SCR;
1365         pcmd += sizeof (uint32_t);
1366
1367         /* For SCR, remainder of payload is SCR parameter page */
1368         memset(pcmd, 0, sizeof (SCR));
1369         ((SCR *) pcmd)->Function = SCR_FUNC_FULL;
1370
1371         phba->fc_stat.elsXmitSCR++;
1372         elsiocb->iocb_cmpl = lpfc_cmpl_els_cmd;
1373         spin_lock_irq(phba->host->host_lock);
1374         if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
1375                 spin_unlock_irq(phba->host->host_lock);
1376                 mempool_free( ndlp, phba->nlp_mem_pool);
1377                 lpfc_els_free_iocb(phba, elsiocb);
1378                 return 1;
1379         }
1380         spin_unlock_irq(phba->host->host_lock);
1381         mempool_free( ndlp, phba->nlp_mem_pool);
1382         return 0;
1383 }
1384
1385 static int
1386 lpfc_issue_els_farpr(struct lpfc_hba * phba, uint32_t nportid, uint8_t retry)
1387 {
1388         IOCB_t *icmd;
1389         struct lpfc_iocbq *elsiocb;
1390         struct lpfc_sli_ring *pring;
1391         struct lpfc_sli *psli;
1392         FARP *fp;
1393         uint8_t *pcmd;
1394         uint32_t *lp;
1395         uint16_t cmdsize;
1396         struct lpfc_nodelist *ondlp;
1397         struct lpfc_nodelist *ndlp;
1398
1399         psli = &phba->sli;
1400         pring = &psli->ring[LPFC_ELS_RING];     /* ELS ring */
1401         cmdsize = (sizeof (uint32_t) + sizeof (FARP));
1402         ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
1403         if (!ndlp)
1404                 return 1;
1405         lpfc_nlp_init(phba, ndlp, nportid);
1406
1407         elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, ndlp,
1408                                                 ndlp->nlp_DID, ELS_CMD_RNID);
1409         if (!elsiocb) {
1410                 mempool_free( ndlp, phba->nlp_mem_pool);
1411                 return 1;
1412         }
1413
1414         icmd = &elsiocb->iocb;
1415         pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1416
1417         *((uint32_t *) (pcmd)) = ELS_CMD_FARPR;
1418         pcmd += sizeof (uint32_t);
1419
1420         /* Fill in FARPR payload */
1421         fp = (FARP *) (pcmd);
1422         memset(fp, 0, sizeof (FARP));
1423         lp = (uint32_t *) pcmd;
1424         *lp++ = be32_to_cpu(nportid);
1425         *lp++ = be32_to_cpu(phba->fc_myDID);
1426         fp->Rflags = 0;
1427         fp->Mflags = (FARP_MATCH_PORT | FARP_MATCH_NODE);
1428
1429         memcpy(&fp->RportName, &phba->fc_portname, sizeof (struct lpfc_name));
1430         memcpy(&fp->RnodeName, &phba->fc_nodename, sizeof (struct lpfc_name));
1431         if ((ondlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, nportid))) {
1432                 memcpy(&fp->OportName, &ondlp->nlp_portname,
1433                        sizeof (struct lpfc_name));
1434                 memcpy(&fp->OnodeName, &ondlp->nlp_nodename,
1435                        sizeof (struct lpfc_name));
1436         }
1437
1438         phba->fc_stat.elsXmitFARPR++;
1439         elsiocb->iocb_cmpl = lpfc_cmpl_els_cmd;
1440         spin_lock_irq(phba->host->host_lock);
1441         if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
1442                 spin_unlock_irq(phba->host->host_lock);
1443                 mempool_free( ndlp, phba->nlp_mem_pool);
1444                 lpfc_els_free_iocb(phba, elsiocb);
1445                 return 1;
1446         }
1447         spin_unlock_irq(phba->host->host_lock);
1448         mempool_free( ndlp, phba->nlp_mem_pool);
1449         return 0;
1450 }
1451
1452 void
1453 lpfc_cancel_retry_delay_tmo(struct lpfc_hba *phba, struct lpfc_nodelist * nlp)
1454 {
1455         nlp->nlp_flag &= ~NLP_DELAY_TMO;
1456         del_timer_sync(&nlp->nlp_delayfunc);
1457         nlp->nlp_last_elscmd = 0;
1458
1459         if (!list_empty(&nlp->els_retry_evt.evt_listp))
1460                 list_del_init(&nlp->els_retry_evt.evt_listp);
1461
1462         if (nlp->nlp_flag & NLP_NPR_2B_DISC) {
1463                 nlp->nlp_flag &= ~NLP_NPR_2B_DISC;
1464                 if (phba->num_disc_nodes) {
1465                         /* Check to see if there are more
1466                          * PLOGIs to be sent
1467                          */
1468                         lpfc_more_plogi(phba);
1469
1470                         if (phba->num_disc_nodes == 0) {
1471                                 phba->fc_flag &= ~FC_NDISC_ACTIVE;
1472                                 lpfc_can_disctmo(phba);
1473                                 if (phba->fc_flag & FC_RSCN_MODE) {
1474                                         /*
1475                                          * Check to see if more RSCNs
1476                                          * came in while we were
1477                                          * processing this one.
1478                                          */
1479                                         if((phba->fc_rscn_id_cnt==0) &&
1480                                          !(phba->fc_flag & FC_RSCN_DISCOVERY)) {
1481                                                 phba->fc_flag &= ~FC_RSCN_MODE;
1482                                         }
1483                                         else {
1484                                                 lpfc_els_handle_rscn(phba);
1485                                         }
1486                                 }
1487                         }
1488                 }
1489         }
1490         return;
1491 }
1492
1493 void
1494 lpfc_els_retry_delay(unsigned long ptr)
1495 {
1496         struct lpfc_nodelist *ndlp;
1497         struct lpfc_hba *phba;
1498         unsigned long iflag;
1499         struct lpfc_work_evt  *evtp;
1500
1501         ndlp = (struct lpfc_nodelist *)ptr;
1502         phba = ndlp->nlp_phba;
1503         evtp = &ndlp->els_retry_evt;
1504
1505         spin_lock_irqsave(phba->host->host_lock, iflag);
1506         if (!list_empty(&evtp->evt_listp)) {
1507                 spin_unlock_irqrestore(phba->host->host_lock, iflag);
1508                 return;
1509         }
1510
1511         evtp->evt_arg1  = ndlp;
1512         evtp->evt       = LPFC_EVT_ELS_RETRY;
1513         list_add_tail(&evtp->evt_listp, &phba->work_list);
1514         if (phba->work_wait)
1515                 wake_up(phba->work_wait);
1516
1517         spin_unlock_irqrestore(phba->host->host_lock, iflag);
1518         return;
1519 }
1520
1521 void
1522 lpfc_els_retry_delay_handler(struct lpfc_nodelist *ndlp)
1523 {
1524         struct lpfc_hba *phba;
1525         uint32_t cmd;
1526         uint32_t did;
1527         uint8_t retry;
1528
1529         phba = ndlp->nlp_phba;
1530         spin_lock_irq(phba->host->host_lock);
1531         did = ndlp->nlp_DID;
1532         cmd = ndlp->nlp_last_elscmd;
1533         ndlp->nlp_last_elscmd = 0;
1534
1535         if (!(ndlp->nlp_flag & NLP_DELAY_TMO)) {
1536                 spin_unlock_irq(phba->host->host_lock);
1537                 return;
1538         }
1539
1540         ndlp->nlp_flag &= ~NLP_DELAY_TMO;
1541         spin_unlock_irq(phba->host->host_lock);
1542         /*
1543          * If a discovery event readded nlp_delayfunc after timer
1544          * firing and before processing the timer, cancel the
1545          * nlp_delayfunc.
1546          */
1547         del_timer_sync(&ndlp->nlp_delayfunc);
1548         retry = ndlp->nlp_retry;
1549
1550         switch (cmd) {
1551         case ELS_CMD_FLOGI:
1552                 lpfc_issue_els_flogi(phba, ndlp, retry);
1553                 break;
1554         case ELS_CMD_PLOGI:
1555                 if(!lpfc_issue_els_plogi(phba, ndlp->nlp_DID, retry)) {
1556                         ndlp->nlp_prev_state = ndlp->nlp_state;
1557                         ndlp->nlp_state = NLP_STE_PLOGI_ISSUE;
1558                         lpfc_nlp_list(phba, ndlp, NLP_PLOGI_LIST);
1559                 }
1560                 break;
1561         case ELS_CMD_ADISC:
1562                 if (!lpfc_issue_els_adisc(phba, ndlp, retry)) {
1563                         ndlp->nlp_prev_state = ndlp->nlp_state;
1564                         ndlp->nlp_state = NLP_STE_ADISC_ISSUE;
1565                         lpfc_nlp_list(phba, ndlp, NLP_ADISC_LIST);
1566                 }
1567                 break;
1568         case ELS_CMD_PRLI:
1569                 if (!lpfc_issue_els_prli(phba, ndlp, retry)) {
1570                         ndlp->nlp_prev_state = ndlp->nlp_state;
1571                         ndlp->nlp_state = NLP_STE_PRLI_ISSUE;
1572                         lpfc_nlp_list(phba, ndlp, NLP_PRLI_LIST);
1573                 }
1574                 break;
1575         case ELS_CMD_LOGO:
1576                 if (!lpfc_issue_els_logo(phba, ndlp, retry)) {
1577                         ndlp->nlp_prev_state = ndlp->nlp_state;
1578                         ndlp->nlp_state = NLP_STE_NPR_NODE;
1579                         lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST);
1580                 }
1581                 break;
1582         }
1583         return;
1584 }
1585
1586 static int
1587 lpfc_els_retry(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
1588                struct lpfc_iocbq * rspiocb)
1589 {
1590         IOCB_t *irsp;
1591         struct lpfc_dmabuf *pcmd;
1592         struct lpfc_nodelist *ndlp;
1593         uint32_t *elscmd;
1594         struct ls_rjt stat;
1595         int retry, maxretry;
1596         int delay;
1597         uint32_t cmd;
1598         uint32_t did;
1599
1600         retry = 0;
1601         delay = 0;
1602         maxretry = lpfc_max_els_tries;
1603         irsp = &rspiocb->iocb;
1604         ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
1605         pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
1606         cmd = 0;
1607
1608         /* Note: context2 may be 0 for internal driver abort
1609          * of delays ELS command.
1610          */
1611
1612         if (pcmd && pcmd->virt) {
1613                 elscmd = (uint32_t *) (pcmd->virt);
1614                 cmd = *elscmd++;
1615         }
1616
1617         if(ndlp)
1618                 did = ndlp->nlp_DID;
1619         else {
1620                 /* We should only hit this case for retrying PLOGI */
1621                 did = irsp->un.elsreq64.remoteID;
1622                 ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, did);
1623                 if (!ndlp && (cmd != ELS_CMD_PLOGI))
1624                         return 1;
1625         }
1626
1627         switch (irsp->ulpStatus) {
1628         case IOSTAT_FCP_RSP_ERROR:
1629         case IOSTAT_REMOTE_STOP:
1630                 break;
1631
1632         case IOSTAT_LOCAL_REJECT:
1633                 switch ((irsp->un.ulpWord[4] & 0xff)) {
1634                 case IOERR_LOOP_OPEN_FAILURE:
1635                         if (cmd == ELS_CMD_PLOGI) {
1636                                 if (cmdiocb->retry == 0) {
1637                                         delay = 1;
1638                                 }
1639                         }
1640                         retry = 1;
1641                         break;
1642
1643                 case IOERR_SEQUENCE_TIMEOUT:
1644                         retry = 1;
1645                         break;
1646
1647                 case IOERR_NO_RESOURCES:
1648                         if (cmd == ELS_CMD_PLOGI) {
1649                                 delay = 1;
1650                         }
1651                         retry = 1;
1652                         break;
1653
1654                 case IOERR_INVALID_RPI:
1655                         retry = 1;
1656                         break;
1657                 }
1658                 break;
1659
1660         case IOSTAT_NPORT_RJT:
1661         case IOSTAT_FABRIC_RJT:
1662                 if (irsp->un.ulpWord[4] & RJT_UNAVAIL_TEMP) {
1663                         retry = 1;
1664                         break;
1665                 }
1666                 break;
1667
1668         case IOSTAT_NPORT_BSY:
1669         case IOSTAT_FABRIC_BSY:
1670                 retry = 1;
1671                 break;
1672
1673         case IOSTAT_LS_RJT:
1674                 stat.un.lsRjtError = be32_to_cpu(irsp->un.ulpWord[4]);
1675                 /* Added for Vendor specifc support
1676                  * Just keep retrying for these Rsn / Exp codes
1677                  */
1678                 switch (stat.un.b.lsRjtRsnCode) {
1679                 case LSRJT_UNABLE_TPC:
1680                         if (stat.un.b.lsRjtRsnCodeExp ==
1681                             LSEXP_CMD_IN_PROGRESS) {
1682                                 if (cmd == ELS_CMD_PLOGI) {
1683                                         delay = 1;
1684                                         maxretry = 48;
1685                                 }
1686                                 retry = 1;
1687                                 break;
1688                         }
1689                         if (cmd == ELS_CMD_PLOGI) {
1690                                 delay = 1;
1691                                 maxretry = lpfc_max_els_tries + 1;
1692                                 retry = 1;
1693                                 break;
1694                         }
1695                         break;
1696
1697                 case LSRJT_LOGICAL_BSY:
1698                         if (cmd == ELS_CMD_PLOGI) {
1699                                 delay = 1;
1700                                 maxretry = 48;
1701                         }
1702                         retry = 1;
1703                         break;
1704                 }
1705                 break;
1706
1707         case IOSTAT_INTERMED_RSP:
1708         case IOSTAT_BA_RJT:
1709                 break;
1710
1711         default:
1712                 break;
1713         }
1714
1715         if (did == FDMI_DID)
1716                 retry = 1;
1717
1718         if ((++cmdiocb->retry) >= maxretry) {
1719                 phba->fc_stat.elsRetryExceeded++;
1720                 retry = 0;
1721         }
1722
1723         if (retry) {
1724
1725                 /* Retry ELS command <elsCmd> to remote NPORT <did> */
1726                 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
1727                                 "%d:0107 Retry ELS command x%x to remote "
1728                                 "NPORT x%x Data: x%x x%x\n",
1729                                 phba->brd_no,
1730                                 cmd, did, cmdiocb->retry, delay);
1731
1732                 if ((cmd == ELS_CMD_PLOGI) || (cmd == ELS_CMD_ADISC)) {
1733                         /* If discovery / RSCN timer is running, reset it */
1734                         if (timer_pending(&phba->fc_disctmo) ||
1735                               (phba->fc_flag & FC_RSCN_MODE)) {
1736                                 lpfc_set_disctmo(phba);
1737                         }
1738                 }
1739
1740                 phba->fc_stat.elsXmitRetry++;
1741                 if (ndlp && delay) {
1742                         phba->fc_stat.elsDelayRetry++;
1743                         ndlp->nlp_retry = cmdiocb->retry;
1744
1745                         mod_timer(&ndlp->nlp_delayfunc, jiffies + HZ);
1746                         ndlp->nlp_flag |= NLP_DELAY_TMO;
1747
1748                         ndlp->nlp_prev_state = ndlp->nlp_state;
1749                         ndlp->nlp_state = NLP_STE_NPR_NODE;
1750                         lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST);
1751                         ndlp->nlp_last_elscmd = cmd;
1752
1753                         return 1;
1754                 }
1755                 switch (cmd) {
1756                 case ELS_CMD_FLOGI:
1757                         lpfc_issue_els_flogi(phba, ndlp, cmdiocb->retry);
1758                         return 1;
1759                 case ELS_CMD_PLOGI:
1760                         if (ndlp) {
1761                                 ndlp->nlp_prev_state = ndlp->nlp_state;
1762                                 ndlp->nlp_state = NLP_STE_PLOGI_ISSUE;
1763                                 lpfc_nlp_list(phba, ndlp, NLP_PLOGI_LIST);
1764                         }
1765                         lpfc_issue_els_plogi(phba, did, cmdiocb->retry);
1766                         return 1;
1767                 case ELS_CMD_ADISC:
1768                         ndlp->nlp_prev_state = ndlp->nlp_state;
1769                         ndlp->nlp_state = NLP_STE_ADISC_ISSUE;
1770                         lpfc_nlp_list(phba, ndlp, NLP_ADISC_LIST);
1771                         lpfc_issue_els_adisc(phba, ndlp, cmdiocb->retry);
1772                         return 1;
1773                 case ELS_CMD_PRLI:
1774                         ndlp->nlp_prev_state = ndlp->nlp_state;
1775                         ndlp->nlp_state = NLP_STE_PRLI_ISSUE;
1776                         lpfc_nlp_list(phba, ndlp, NLP_PRLI_LIST);
1777                         lpfc_issue_els_prli(phba, ndlp, cmdiocb->retry);
1778                         return 1;
1779                 case ELS_CMD_LOGO:
1780                         ndlp->nlp_prev_state = ndlp->nlp_state;
1781                         ndlp->nlp_state = NLP_STE_NPR_NODE;
1782                         lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST);
1783                         lpfc_issue_els_logo(phba, ndlp, cmdiocb->retry);
1784                         return 1;
1785                 }
1786         }
1787
1788         /* No retry ELS command <elsCmd> to remote NPORT <did> */
1789         lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
1790                         "%d:0108 No retry ELS command x%x to remote NPORT x%x "
1791                         "Data: x%x\n",
1792                         phba->brd_no,
1793                         cmd, did, cmdiocb->retry);
1794
1795         return 0;
1796 }
1797
1798 int
1799 lpfc_els_free_iocb(struct lpfc_hba * phba, struct lpfc_iocbq * elsiocb)
1800 {
1801         struct lpfc_dmabuf *buf_ptr, *buf_ptr1;
1802
1803         /* context2  = cmd,  context2->next = rsp, context3 = bpl */
1804         if (elsiocb->context2) {
1805                 buf_ptr1 = (struct lpfc_dmabuf *) elsiocb->context2;
1806                 /* Free the response before processing the command.  */
1807                 if (!list_empty(&buf_ptr1->list)) {
1808                         list_remove_head(&buf_ptr1->list, buf_ptr,
1809                                          struct lpfc_dmabuf,
1810                                          list);
1811                         lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
1812                         kfree(buf_ptr);
1813                 }
1814                 lpfc_mbuf_free(phba, buf_ptr1->virt, buf_ptr1->phys);
1815                 kfree(buf_ptr1);
1816         }
1817
1818         if (elsiocb->context3) {
1819                 buf_ptr = (struct lpfc_dmabuf *) elsiocb->context3;
1820                 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
1821                 kfree(buf_ptr);
1822         }
1823         spin_lock_irq(phba->host->host_lock);
1824         lpfc_sli_release_iocbq(phba, elsiocb);
1825         spin_unlock_irq(phba->host->host_lock);
1826         return 0;
1827 }
1828
1829 static void
1830 lpfc_cmpl_els_logo_acc(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
1831                        struct lpfc_iocbq * rspiocb)
1832 {
1833         struct lpfc_nodelist *ndlp;
1834
1835         ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
1836
1837         /* ACC to LOGO completes to NPort <nlp_DID> */
1838         lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
1839                         "%d:0109 ACC to LOGO completes to NPort x%x "
1840                         "Data: x%x x%x x%x\n",
1841                         phba->brd_no, ndlp->nlp_DID, ndlp->nlp_flag,
1842                         ndlp->nlp_state, ndlp->nlp_rpi);
1843
1844         switch (ndlp->nlp_state) {
1845         case NLP_STE_UNUSED_NODE:       /* node is just allocated */
1846                 lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
1847                 break;
1848         case NLP_STE_NPR_NODE:          /* NPort Recovery mode */
1849                 lpfc_unreg_rpi(phba, ndlp);
1850                 break;
1851         default:
1852                 break;
1853         }
1854         lpfc_els_free_iocb(phba, cmdiocb);
1855         return;
1856 }
1857
1858 static void
1859 lpfc_cmpl_els_acc(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
1860                   struct lpfc_iocbq * rspiocb)
1861 {
1862         IOCB_t *irsp;
1863         struct lpfc_nodelist *ndlp;
1864         LPFC_MBOXQ_t *mbox = NULL;
1865         struct lpfc_dmabuf *mp;
1866
1867         irsp = &rspiocb->iocb;
1868
1869         ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
1870         if (cmdiocb->context_un.mbox)
1871                 mbox = cmdiocb->context_un.mbox;
1872
1873
1874         /* Check to see if link went down during discovery */
1875         if ((lpfc_els_chk_latt(phba)) || !ndlp) {
1876                 if (mbox) {
1877                         mp = (struct lpfc_dmabuf *) mbox->context1;
1878                         if (mp) {
1879                                 lpfc_mbuf_free(phba, mp->virt, mp->phys);
1880                                 kfree(mp);
1881                         }
1882                         mempool_free( mbox, phba->mbox_mem_pool);
1883                 }
1884                 goto out;
1885         }
1886
1887         /* ELS response tag <ulpIoTag> completes */
1888         lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
1889                         "%d:0110 ELS response tag x%x completes "
1890                         "Data: x%x x%x x%x x%x x%x x%x x%x\n",
1891                         phba->brd_no,
1892                         cmdiocb->iocb.ulpIoTag, rspiocb->iocb.ulpStatus,
1893                         rspiocb->iocb.un.ulpWord[4], rspiocb->iocb.ulpTimeout,
1894                         ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_state,
1895                         ndlp->nlp_rpi);
1896
1897         if (mbox) {
1898                 if ((rspiocb->iocb.ulpStatus == 0)
1899                     && (ndlp->nlp_flag & NLP_ACC_REGLOGIN)) {
1900                         lpfc_unreg_rpi(phba, ndlp);
1901                         mbox->mbox_cmpl = lpfc_mbx_cmpl_reg_login;
1902                         mbox->context2 = ndlp;
1903                         ndlp->nlp_prev_state = ndlp->nlp_state;
1904                         ndlp->nlp_state = NLP_STE_REG_LOGIN_ISSUE;
1905                         lpfc_nlp_list(phba, ndlp, NLP_REGLOGIN_LIST);
1906                         if (lpfc_sli_issue_mbox(phba, mbox,
1907                                                 (MBX_NOWAIT | MBX_STOP_IOCB))
1908                             != MBX_NOT_FINISHED) {
1909                                 goto out;
1910                         }
1911                         /* NOTE: we should have messages for unsuccessful
1912                            reglogin */
1913                 } else {
1914                         /* Do not call NO_LIST for lpfc_els_abort'ed ELS cmds */
1915                         if (!((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
1916                               ((irsp->un.ulpWord[4] == IOERR_SLI_ABORTED) ||
1917                                (irsp->un.ulpWord[4] == IOERR_LINK_DOWN) ||
1918                                (irsp->un.ulpWord[4] == IOERR_SLI_DOWN)))) {
1919                                 if (ndlp->nlp_flag & NLP_ACC_REGLOGIN) {
1920                                         lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
1921                                         ndlp = NULL;
1922                                 }
1923                         }
1924                 }
1925                 mp = (struct lpfc_dmabuf *) mbox->context1;
1926                 if (mp) {
1927                         lpfc_mbuf_free(phba, mp->virt, mp->phys);
1928                         kfree(mp);
1929                 }
1930                 mempool_free(mbox, phba->mbox_mem_pool);
1931         }
1932 out:
1933         if (ndlp) {
1934                 spin_lock_irq(phba->host->host_lock);
1935                 ndlp->nlp_flag &= ~NLP_ACC_REGLOGIN;
1936                 spin_unlock_irq(phba->host->host_lock);
1937         }
1938         lpfc_els_free_iocb(phba, cmdiocb);
1939         return;
1940 }
1941
1942 int
1943 lpfc_els_rsp_acc(struct lpfc_hba * phba, uint32_t flag,
1944                  struct lpfc_iocbq * oldiocb, struct lpfc_nodelist * ndlp,
1945                  LPFC_MBOXQ_t * mbox, uint8_t newnode)
1946 {
1947         IOCB_t *icmd;
1948         IOCB_t *oldcmd;
1949         struct lpfc_iocbq *elsiocb;
1950         struct lpfc_sli_ring *pring;
1951         struct lpfc_sli *psli;
1952         uint8_t *pcmd;
1953         uint16_t cmdsize;
1954         int rc;
1955         ELS_PKT *els_pkt_ptr;
1956
1957         psli = &phba->sli;
1958         pring = &psli->ring[LPFC_ELS_RING];     /* ELS ring */
1959         oldcmd = &oldiocb->iocb;
1960
1961         switch (flag) {
1962         case ELS_CMD_ACC:
1963                 cmdsize = sizeof (uint32_t);
1964                 elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry,
1965                                         ndlp, ndlp->nlp_DID, ELS_CMD_ACC);
1966                 if (!elsiocb) {
1967                         ndlp->nlp_flag &= ~NLP_LOGO_ACC;
1968                         return 1;
1969                 }
1970                 icmd = &elsiocb->iocb;
1971                 icmd->ulpContext = oldcmd->ulpContext;  /* Xri */
1972                 pcmd = (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1973                 *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
1974                 pcmd += sizeof (uint32_t);
1975                 break;
1976         case ELS_CMD_PLOGI:
1977                 cmdsize = (sizeof (struct serv_parm) + sizeof (uint32_t));
1978                 elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry,
1979                                         ndlp, ndlp->nlp_DID, ELS_CMD_ACC);
1980                 if (!elsiocb)
1981                         return 1;
1982
1983                 icmd = &elsiocb->iocb;
1984                 icmd->ulpContext = oldcmd->ulpContext;  /* Xri */
1985                 pcmd = (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1986
1987                 if (mbox)
1988                         elsiocb->context_un.mbox = mbox;
1989
1990                 *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
1991                 pcmd += sizeof (uint32_t);
1992                 memcpy(pcmd, &phba->fc_sparam, sizeof (struct serv_parm));
1993                 break;
1994         case ELS_CMD_PRLO:
1995                 cmdsize = sizeof (uint32_t) + sizeof (PRLO);
1996                 elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry,
1997                                              ndlp, ndlp->nlp_DID, ELS_CMD_PRLO);
1998                 if (!elsiocb)
1999                         return 1;
2000
2001                 icmd = &elsiocb->iocb;
2002                 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
2003                 pcmd = (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2004
2005                 memcpy(pcmd, ((struct lpfc_dmabuf *) oldiocb->context2)->virt,
2006                        sizeof (uint32_t) + sizeof (PRLO));
2007                 *((uint32_t *) (pcmd)) = ELS_CMD_PRLO_ACC;
2008                 els_pkt_ptr = (ELS_PKT *) pcmd;
2009                 els_pkt_ptr->un.prlo.acceptRspCode = PRLO_REQ_EXECUTED;
2010                 break;
2011         default:
2012                 return 1;
2013         }
2014
2015         if (newnode)
2016                 elsiocb->context1 = NULL;
2017
2018         /* Xmit ELS ACC response tag <ulpIoTag> */
2019         lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
2020                         "%d:0128 Xmit ELS ACC response tag x%x "
2021                         "Data: x%x x%x x%x x%x x%x\n",
2022                         phba->brd_no,
2023                         elsiocb->iocb.ulpIoTag,
2024                         elsiocb->iocb.ulpContext, ndlp->nlp_DID,
2025                         ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi);
2026
2027         if (ndlp->nlp_flag & NLP_LOGO_ACC) {
2028                 spin_lock_irq(phba->host->host_lock);
2029                 ndlp->nlp_flag &= ~NLP_LOGO_ACC;
2030                 spin_unlock_irq(phba->host->host_lock);
2031                 elsiocb->iocb_cmpl = lpfc_cmpl_els_logo_acc;
2032         } else {
2033                 elsiocb->iocb_cmpl = lpfc_cmpl_els_acc;
2034         }
2035
2036         phba->fc_stat.elsXmitACC++;
2037         spin_lock_irq(phba->host->host_lock);
2038         rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
2039         spin_unlock_irq(phba->host->host_lock);
2040         if (rc == IOCB_ERROR) {
2041                 lpfc_els_free_iocb(phba, elsiocb);
2042                 return 1;
2043         }
2044         return 0;
2045 }
2046
2047 int
2048 lpfc_els_rsp_reject(struct lpfc_hba * phba, uint32_t rejectError,
2049                     struct lpfc_iocbq * oldiocb, struct lpfc_nodelist * ndlp)
2050 {
2051         IOCB_t *icmd;
2052         IOCB_t *oldcmd;
2053         struct lpfc_iocbq *elsiocb;
2054         struct lpfc_sli_ring *pring;
2055         struct lpfc_sli *psli;
2056         uint8_t *pcmd;
2057         uint16_t cmdsize;
2058         int rc;
2059
2060         psli = &phba->sli;
2061         pring = &psli->ring[LPFC_ELS_RING];     /* ELS ring */
2062
2063         cmdsize = 2 * sizeof (uint32_t);
2064         elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry,
2065                                         ndlp, ndlp->nlp_DID, ELS_CMD_LS_RJT);
2066         if (!elsiocb)
2067                 return 1;
2068
2069         icmd = &elsiocb->iocb;
2070         oldcmd = &oldiocb->iocb;
2071         icmd->ulpContext = oldcmd->ulpContext;  /* Xri */
2072         pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2073
2074         *((uint32_t *) (pcmd)) = ELS_CMD_LS_RJT;
2075         pcmd += sizeof (uint32_t);
2076         *((uint32_t *) (pcmd)) = rejectError;
2077
2078         /* Xmit ELS RJT <err> response tag <ulpIoTag> */
2079         lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
2080                         "%d:0129 Xmit ELS RJT x%x response tag x%x "
2081                         "Data: x%x x%x x%x x%x x%x\n",
2082                         phba->brd_no,
2083                         rejectError, elsiocb->iocb.ulpIoTag,
2084                         elsiocb->iocb.ulpContext, ndlp->nlp_DID,
2085                         ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi);
2086
2087         phba->fc_stat.elsXmitLSRJT++;
2088         elsiocb->iocb_cmpl = lpfc_cmpl_els_acc;
2089         spin_lock_irq(phba->host->host_lock);
2090         rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
2091         spin_unlock_irq(phba->host->host_lock);
2092         if (rc == IOCB_ERROR) {
2093                 lpfc_els_free_iocb(phba, elsiocb);
2094                 return 1;
2095         }
2096         return 0;
2097 }
2098
2099 int
2100 lpfc_els_rsp_adisc_acc(struct lpfc_hba * phba,
2101                        struct lpfc_iocbq * oldiocb, struct lpfc_nodelist * ndlp)
2102 {
2103         ADISC *ap;
2104         IOCB_t *icmd;
2105         IOCB_t *oldcmd;
2106         struct lpfc_iocbq *elsiocb;
2107         struct lpfc_sli_ring *pring;
2108         struct lpfc_sli *psli;
2109         uint8_t *pcmd;
2110         uint16_t cmdsize;
2111         int rc;
2112
2113         psli = &phba->sli;
2114         pring = &psli->ring[LPFC_ELS_RING];     /* ELS ring */
2115
2116         cmdsize = sizeof (uint32_t) + sizeof (ADISC);
2117         elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry,
2118                                         ndlp, ndlp->nlp_DID, ELS_CMD_ACC);
2119         if (!elsiocb)
2120                 return 1;
2121
2122         /* Xmit ADISC ACC response tag <ulpIoTag> */
2123         lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
2124                         "%d:0130 Xmit ADISC ACC response tag x%x "
2125                         "Data: x%x x%x x%x x%x x%x\n",
2126                         phba->brd_no,
2127                         elsiocb->iocb.ulpIoTag,
2128                         elsiocb->iocb.ulpContext, ndlp->nlp_DID,
2129                         ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi);
2130
2131         icmd = &elsiocb->iocb;
2132         oldcmd = &oldiocb->iocb;
2133         icmd->ulpContext = oldcmd->ulpContext;  /* Xri */
2134         pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2135
2136         *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
2137         pcmd += sizeof (uint32_t);
2138
2139         ap = (ADISC *) (pcmd);
2140         ap->hardAL_PA = phba->fc_pref_ALPA;
2141         memcpy(&ap->portName, &phba->fc_portname, sizeof (struct lpfc_name));
2142         memcpy(&ap->nodeName, &phba->fc_nodename, sizeof (struct lpfc_name));
2143         ap->DID = be32_to_cpu(phba->fc_myDID);
2144
2145         phba->fc_stat.elsXmitACC++;
2146         elsiocb->iocb_cmpl = lpfc_cmpl_els_acc;
2147         spin_lock_irq(phba->host->host_lock);
2148         rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
2149         spin_unlock_irq(phba->host->host_lock);
2150         if (rc == IOCB_ERROR) {
2151                 lpfc_els_free_iocb(phba, elsiocb);
2152                 return 1;
2153         }
2154         return 0;
2155 }
2156
2157 int
2158 lpfc_els_rsp_prli_acc(struct lpfc_hba * phba,
2159                       struct lpfc_iocbq * oldiocb, struct lpfc_nodelist * ndlp)
2160 {
2161         PRLI *npr;
2162         lpfc_vpd_t *vpd;
2163         IOCB_t *icmd;
2164         IOCB_t *oldcmd;
2165         struct lpfc_iocbq *elsiocb;
2166         struct lpfc_sli_ring *pring;
2167         struct lpfc_sli *psli;
2168         uint8_t *pcmd;
2169         uint16_t cmdsize;
2170         int rc;
2171
2172         psli = &phba->sli;
2173         pring = &psli->ring[LPFC_ELS_RING];     /* ELS ring */
2174
2175         cmdsize = sizeof (uint32_t) + sizeof (PRLI);
2176         elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry, ndlp,
2177                 ndlp->nlp_DID, (ELS_CMD_ACC | (ELS_CMD_PRLI & ~ELS_RSP_MASK)));
2178         if (!elsiocb)
2179                 return 1;
2180
2181         /* Xmit PRLI ACC response tag <ulpIoTag> */
2182         lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
2183                         "%d:0131 Xmit PRLI ACC response tag x%x "
2184                         "Data: x%x x%x x%x x%x x%x\n",
2185                         phba->brd_no,
2186                         elsiocb->iocb.ulpIoTag,
2187                         elsiocb->iocb.ulpContext, ndlp->nlp_DID,
2188                         ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi);
2189
2190         icmd = &elsiocb->iocb;
2191         oldcmd = &oldiocb->iocb;
2192         icmd->ulpContext = oldcmd->ulpContext;  /* Xri */
2193         pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2194
2195         *((uint32_t *) (pcmd)) = (ELS_CMD_ACC | (ELS_CMD_PRLI & ~ELS_RSP_MASK));
2196         pcmd += sizeof (uint32_t);
2197
2198         /* For PRLI, remainder of payload is PRLI parameter page */
2199         memset(pcmd, 0, sizeof (PRLI));
2200
2201         npr = (PRLI *) pcmd;
2202         vpd = &phba->vpd;
2203         /*
2204          * If our firmware version is 3.20 or later,
2205          * set the following bits for FC-TAPE support.
2206          */
2207         if (vpd->rev.feaLevelHigh >= 0x02) {
2208                 npr->ConfmComplAllowed = 1;
2209                 npr->Retry = 1;
2210                 npr->TaskRetryIdReq = 1;
2211         }
2212
2213         npr->acceptRspCode = PRLI_REQ_EXECUTED;
2214         npr->estabImagePair = 1;
2215         npr->readXferRdyDis = 1;
2216         npr->ConfmComplAllowed = 1;
2217
2218         npr->prliType = PRLI_FCP_TYPE;
2219         npr->initiatorFunc = 1;
2220
2221         phba->fc_stat.elsXmitACC++;
2222         elsiocb->iocb_cmpl = lpfc_cmpl_els_acc;
2223
2224         spin_lock_irq(phba->host->host_lock);
2225         rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
2226         spin_unlock_irq(phba->host->host_lock);
2227         if (rc == IOCB_ERROR) {
2228                 lpfc_els_free_iocb(phba, elsiocb);
2229                 return 1;
2230         }
2231         return 0;
2232 }
2233
2234 static int
2235 lpfc_els_rsp_rnid_acc(struct lpfc_hba * phba,
2236                       uint8_t format,
2237                       struct lpfc_iocbq * oldiocb, struct lpfc_nodelist * ndlp)
2238 {
2239         RNID *rn;
2240         IOCB_t *icmd;
2241         IOCB_t *oldcmd;
2242         struct lpfc_iocbq *elsiocb;
2243         struct lpfc_sli_ring *pring;
2244         struct lpfc_sli *psli;
2245         uint8_t *pcmd;
2246         uint16_t cmdsize;
2247         int rc;
2248
2249         psli = &phba->sli;
2250         pring = &psli->ring[LPFC_ELS_RING];
2251
2252         cmdsize = sizeof (uint32_t) + sizeof (uint32_t)
2253                 + (2 * sizeof (struct lpfc_name));
2254         if (format)
2255                 cmdsize += sizeof (RNID_TOP_DISC);
2256
2257         elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry,
2258                                         ndlp, ndlp->nlp_DID, ELS_CMD_ACC);
2259         if (!elsiocb)
2260                 return 1;
2261
2262         /* Xmit RNID ACC response tag <ulpIoTag> */
2263         lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
2264                         "%d:0132 Xmit RNID ACC response tag x%x "
2265                         "Data: x%x\n",
2266                         phba->brd_no,
2267                         elsiocb->iocb.ulpIoTag,
2268                         elsiocb->iocb.ulpContext);
2269
2270         icmd = &elsiocb->iocb;
2271         oldcmd = &oldiocb->iocb;
2272         icmd->ulpContext = oldcmd->ulpContext;  /* Xri */
2273         pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2274
2275         *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
2276         pcmd += sizeof (uint32_t);
2277
2278         memset(pcmd, 0, sizeof (RNID));
2279         rn = (RNID *) (pcmd);
2280         rn->Format = format;
2281         rn->CommonLen = (2 * sizeof (struct lpfc_name));
2282         memcpy(&rn->portName, &phba->fc_portname, sizeof (struct lpfc_name));
2283         memcpy(&rn->nodeName, &phba->fc_nodename, sizeof (struct lpfc_name));
2284         switch (format) {
2285         case 0:
2286                 rn->SpecificLen = 0;
2287                 break;
2288         case RNID_TOPOLOGY_DISC:
2289                 rn->SpecificLen = sizeof (RNID_TOP_DISC);
2290                 memcpy(&rn->un.topologyDisc.portName,
2291                        &phba->fc_portname, sizeof (struct lpfc_name));
2292                 rn->un.topologyDisc.unitType = RNID_HBA;
2293                 rn->un.topologyDisc.physPort = 0;
2294                 rn->un.topologyDisc.attachedNodes = 0;
2295                 break;
2296         default:
2297                 rn->CommonLen = 0;
2298                 rn->SpecificLen = 0;
2299                 break;
2300         }
2301
2302         phba->fc_stat.elsXmitACC++;
2303         elsiocb->iocb_cmpl = lpfc_cmpl_els_acc;
2304         elsiocb->context1 = NULL;  /* Don't need ndlp for cmpl,
2305                                     * it could be freed */
2306
2307         spin_lock_irq(phba->host->host_lock);
2308         rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
2309         spin_unlock_irq(phba->host->host_lock);
2310         if (rc == IOCB_ERROR) {
2311                 lpfc_els_free_iocb(phba, elsiocb);
2312                 return 1;
2313         }
2314         return 0;
2315 }
2316
2317 int
2318 lpfc_els_disc_adisc(struct lpfc_hba * phba)
2319 {
2320         int sentadisc;
2321         struct lpfc_nodelist *ndlp, *next_ndlp;
2322
2323         sentadisc = 0;
2324         /* go thru NPR list and issue any remaining ELS ADISCs */
2325         list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_npr_list,
2326                         nlp_listp) {
2327                 if (ndlp->nlp_flag & NLP_NPR_2B_DISC) {
2328                         if (ndlp->nlp_flag & NLP_NPR_ADISC) {
2329                                 ndlp->nlp_flag &= ~NLP_NPR_ADISC;
2330                                 ndlp->nlp_prev_state = ndlp->nlp_state;
2331                                 ndlp->nlp_state = NLP_STE_ADISC_ISSUE;
2332                                 lpfc_nlp_list(phba, ndlp,
2333                                         NLP_ADISC_LIST);
2334                                 lpfc_issue_els_adisc(phba, ndlp, 0);
2335                                 sentadisc++;
2336                                 phba->num_disc_nodes++;
2337                                 if (phba->num_disc_nodes >=
2338                                     phba->cfg_discovery_threads) {
2339                                         spin_lock_irq(phba->host->host_lock);
2340                                         phba->fc_flag |= FC_NLP_MORE;
2341                                         spin_unlock_irq(phba->host->host_lock);
2342                                         break;
2343                                 }
2344                         }
2345                 }
2346         }
2347         if (sentadisc == 0) {
2348                 spin_lock_irq(phba->host->host_lock);
2349                 phba->fc_flag &= ~FC_NLP_MORE;
2350                 spin_unlock_irq(phba->host->host_lock);
2351         }
2352         return sentadisc;
2353 }
2354
2355 int
2356 lpfc_els_disc_plogi(struct lpfc_hba * phba)
2357 {
2358         int sentplogi;
2359         struct lpfc_nodelist *ndlp, *next_ndlp;
2360
2361         sentplogi = 0;
2362         /* go thru NPR list and issue any remaining ELS PLOGIs */
2363         list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_npr_list,
2364                                 nlp_listp) {
2365                 if ((ndlp->nlp_flag & NLP_NPR_2B_DISC) &&
2366                    (!(ndlp->nlp_flag & NLP_DELAY_TMO))) {
2367                         if (!(ndlp->nlp_flag & NLP_NPR_ADISC)) {
2368                                 ndlp->nlp_prev_state = ndlp->nlp_state;
2369                                 ndlp->nlp_state = NLP_STE_PLOGI_ISSUE;
2370                                 lpfc_nlp_list(phba, ndlp, NLP_PLOGI_LIST);
2371                                 lpfc_issue_els_plogi(phba, ndlp->nlp_DID, 0);
2372                                 sentplogi++;
2373                                 phba->num_disc_nodes++;
2374                                 if (phba->num_disc_nodes >=
2375                                     phba->cfg_discovery_threads) {
2376                                         spin_lock_irq(phba->host->host_lock);
2377                                         phba->fc_flag |= FC_NLP_MORE;
2378                                         spin_unlock_irq(phba->host->host_lock);
2379                                         break;
2380                                 }
2381                         }
2382                 }
2383         }
2384         if (sentplogi == 0) {
2385                 spin_lock_irq(phba->host->host_lock);
2386                 phba->fc_flag &= ~FC_NLP_MORE;
2387                 spin_unlock_irq(phba->host->host_lock);
2388         }
2389         return sentplogi;
2390 }
2391
2392 int
2393 lpfc_els_flush_rscn(struct lpfc_hba * phba)
2394 {
2395         struct lpfc_dmabuf *mp;
2396         int i;
2397
2398         for (i = 0; i < phba->fc_rscn_id_cnt; i++) {
2399                 mp = phba->fc_rscn_id_list[i];
2400                 lpfc_mbuf_free(phba, mp->virt, mp->phys);
2401                 kfree(mp);
2402                 phba->fc_rscn_id_list[i] = NULL;
2403         }
2404         phba->fc_rscn_id_cnt = 0;
2405         spin_lock_irq(phba->host->host_lock);
2406         phba->fc_flag &= ~(FC_RSCN_MODE | FC_RSCN_DISCOVERY);
2407         spin_unlock_irq(phba->host->host_lock);
2408         lpfc_can_disctmo(phba);
2409         return 0;
2410 }
2411
2412 int
2413 lpfc_rscn_payload_check(struct lpfc_hba * phba, uint32_t did)
2414 {
2415         D_ID ns_did;
2416         D_ID rscn_did;
2417         struct lpfc_dmabuf *mp;
2418         uint32_t *lp;
2419         uint32_t payload_len, cmd, i, match;
2420
2421         ns_did.un.word = did;
2422         match = 0;
2423
2424         /* Never match fabric nodes for RSCNs */
2425         if ((did & Fabric_DID_MASK) == Fabric_DID_MASK)
2426                 return(0);
2427
2428         /* If we are doing a FULL RSCN rediscovery, match everything */
2429         if (phba->fc_flag & FC_RSCN_DISCOVERY) {
2430                 return did;
2431         }
2432
2433         for (i = 0; i < phba->fc_rscn_id_cnt; i++) {
2434                 mp = phba->fc_rscn_id_list[i];
2435                 lp = (uint32_t *) mp->virt;
2436                 cmd = *lp++;
2437                 payload_len = be32_to_cpu(cmd) & 0xffff; /* payload length */
2438                 payload_len -= sizeof (uint32_t);       /* take off word 0 */
2439                 while (payload_len) {
2440                         rscn_did.un.word = *lp++;
2441                         rscn_did.un.word = be32_to_cpu(rscn_did.un.word);
2442                         payload_len -= sizeof (uint32_t);
2443                         switch (rscn_did.un.b.resv) {
2444                         case 0: /* Single N_Port ID effected */
2445                                 if (ns_did.un.word == rscn_did.un.word) {
2446                                         match = did;
2447                                 }
2448                                 break;
2449                         case 1: /* Whole N_Port Area effected */
2450                                 if ((ns_did.un.b.domain == rscn_did.un.b.domain)
2451                                     && (ns_did.un.b.area == rscn_did.un.b.area))
2452                                         {
2453                                                 match = did;
2454                                         }
2455                                 break;
2456                         case 2: /* Whole N_Port Domain effected */
2457                                 if (ns_did.un.b.domain == rscn_did.un.b.domain)
2458                                         {
2459                                                 match = did;
2460                                         }
2461                                 break;
2462                         case 3: /* Whole Fabric effected */
2463                                 match = did;
2464                                 break;
2465                         default:
2466                                 /* Unknown Identifier in RSCN list */
2467                                 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY,
2468                                                 "%d:0217 Unknown Identifier in "
2469                                                 "RSCN payload Data: x%x\n",
2470                                                 phba->brd_no, rscn_did.un.word);
2471                                 break;
2472                         }
2473                         if (match) {
2474                                 break;
2475                         }
2476                 }
2477         }
2478         return match;
2479 }
2480
2481 static int
2482 lpfc_rscn_recovery_check(struct lpfc_hba * phba)
2483 {
2484         struct lpfc_nodelist *ndlp = NULL, *next_ndlp;
2485         struct list_head *listp;
2486         struct list_head *node_list[7];
2487         int i;
2488
2489         /* Look at all nodes effected by pending RSCNs and move
2490          * them to NPR list.
2491          */
2492         node_list[0] = &phba->fc_npr_list;  /* MUST do this list first */
2493         node_list[1] = &phba->fc_nlpmap_list;
2494         node_list[2] = &phba->fc_nlpunmap_list;
2495         node_list[3] = &phba->fc_prli_list;
2496         node_list[4] = &phba->fc_reglogin_list;
2497         node_list[5] = &phba->fc_adisc_list;
2498         node_list[6] = &phba->fc_plogi_list;
2499         for (i = 0; i < 7; i++) {
2500                 listp = node_list[i];
2501                 if (list_empty(listp))
2502                         continue;
2503
2504                 list_for_each_entry_safe(ndlp, next_ndlp, listp, nlp_listp) {
2505                         if (!(lpfc_rscn_payload_check(phba, ndlp->nlp_DID)))
2506                                 continue;
2507
2508                         lpfc_disc_state_machine(phba, ndlp, NULL,
2509                                         NLP_EVT_DEVICE_RECOVERY);
2510
2511                         /* Make sure NLP_DELAY_TMO is NOT running
2512                          * after a device recovery event.
2513                          */
2514                         if (ndlp->nlp_flag & NLP_DELAY_TMO)
2515                                 lpfc_cancel_retry_delay_tmo(phba, ndlp);
2516                 }
2517         }
2518         return 0;
2519 }
2520
2521 static int
2522 lpfc_els_rcv_rscn(struct lpfc_hba * phba,
2523                   struct lpfc_iocbq * cmdiocb,
2524                   struct lpfc_nodelist * ndlp, uint8_t newnode)
2525 {
2526         struct lpfc_dmabuf *pcmd;
2527         uint32_t *lp;
2528         IOCB_t *icmd;
2529         uint32_t payload_len, cmd;
2530         int i;
2531
2532         icmd = &cmdiocb->iocb;
2533         pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
2534         lp = (uint32_t *) pcmd->virt;
2535
2536         cmd = *lp++;
2537         payload_len = be32_to_cpu(cmd) & 0xffff;        /* payload length */
2538         payload_len -= sizeof (uint32_t);       /* take off word 0 */
2539         cmd &= ELS_CMD_MASK;
2540
2541         /* RSCN received */
2542         lpfc_printf_log(phba,
2543                         KERN_INFO,
2544                         LOG_DISCOVERY,
2545                         "%d:0214 RSCN received Data: x%x x%x x%x x%x\n",
2546                         phba->brd_no,
2547                         phba->fc_flag, payload_len, *lp, phba->fc_rscn_id_cnt);
2548
2549         for (i = 0; i < payload_len/sizeof(uint32_t); i++)
2550                 fc_host_post_event(phba->host, fc_get_event_number(),
2551                         FCH_EVT_RSCN, lp[i]);
2552
2553         /* If we are about to begin discovery, just ACC the RSCN.
2554          * Discovery processing will satisfy it.
2555          */
2556         if (phba->hba_state <= LPFC_NS_QRY) {
2557                 lpfc_els_rsp_acc(phba, ELS_CMD_ACC, cmdiocb, ndlp, NULL,
2558                                                                 newnode);
2559                 return 0;
2560         }
2561
2562         /* If we are already processing an RSCN, save the received
2563          * RSCN payload buffer, cmdiocb->context2 to process later.
2564          */
2565         if (phba->fc_flag & (FC_RSCN_MODE | FC_NDISC_ACTIVE)) {
2566                 if ((phba->fc_rscn_id_cnt < FC_MAX_HOLD_RSCN) &&
2567                     !(phba->fc_flag & FC_RSCN_DISCOVERY)) {
2568                         spin_lock_irq(phba->host->host_lock);
2569                         phba->fc_flag |= FC_RSCN_MODE;
2570                         spin_unlock_irq(phba->host->host_lock);
2571                         phba->fc_rscn_id_list[phba->fc_rscn_id_cnt++] = pcmd;
2572
2573                         /* If we zero, cmdiocb->context2, the calling
2574                          * routine will not try to free it.
2575                          */
2576                         cmdiocb->context2 = NULL;
2577
2578                         /* Deferred RSCN */
2579                         lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
2580                                         "%d:0235 Deferred RSCN "
2581                                         "Data: x%x x%x x%x\n",
2582                                         phba->brd_no, phba->fc_rscn_id_cnt,
2583                                         phba->fc_flag, phba->hba_state);
2584                 } else {
2585                         spin_lock_irq(phba->host->host_lock);
2586                         phba->fc_flag |= FC_RSCN_DISCOVERY;
2587                         spin_unlock_irq(phba->host->host_lock);
2588                         /* ReDiscovery RSCN */
2589                         lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
2590                                         "%d:0234 ReDiscovery RSCN "
2591                                         "Data: x%x x%x x%x\n",
2592                                         phba->brd_no, phba->fc_rscn_id_cnt,
2593                                         phba->fc_flag, phba->hba_state);
2594                 }
2595                 /* Send back ACC */
2596                 lpfc_els_rsp_acc(phba, ELS_CMD_ACC, cmdiocb, ndlp, NULL,
2597                                                                 newnode);
2598
2599                 /* send RECOVERY event for ALL nodes that match RSCN payload */
2600                 lpfc_rscn_recovery_check(phba);
2601                 return 0;
2602         }
2603
2604         phba->fc_flag |= FC_RSCN_MODE;
2605         phba->fc_rscn_id_list[phba->fc_rscn_id_cnt++] = pcmd;
2606         /*
2607          * If we zero, cmdiocb->context2, the calling routine will
2608          * not try to free it.
2609          */
2610         cmdiocb->context2 = NULL;
2611
2612         lpfc_set_disctmo(phba);
2613
2614         /* Send back ACC */
2615         lpfc_els_rsp_acc(phba, ELS_CMD_ACC, cmdiocb, ndlp, NULL, newnode);
2616
2617         /* send RECOVERY event for ALL nodes that match RSCN payload */
2618         lpfc_rscn_recovery_check(phba);
2619
2620         return lpfc_els_handle_rscn(phba);
2621 }
2622
2623 int
2624 lpfc_els_handle_rscn(struct lpfc_hba * phba)
2625 {
2626         struct lpfc_nodelist *ndlp;
2627
2628         /* Start timer for RSCN processing */
2629         lpfc_set_disctmo(phba);
2630
2631         /* RSCN processed */
2632         lpfc_printf_log(phba,
2633                         KERN_INFO,
2634                         LOG_DISCOVERY,
2635                         "%d:0215 RSCN processed Data: x%x x%x x%x x%x\n",
2636                         phba->brd_no,
2637                         phba->fc_flag, 0, phba->fc_rscn_id_cnt,
2638                         phba->hba_state);
2639
2640         /* To process RSCN, first compare RSCN data with NameServer */
2641         phba->fc_ns_retry = 0;
2642         ndlp = lpfc_findnode_did(phba, NLP_SEARCH_UNMAPPED, NameServer_DID);
2643         if (ndlp) {
2644                 /* Good ndlp, issue CT Request to NameServer */
2645                 if (lpfc_ns_cmd(phba, ndlp, SLI_CTNS_GID_FT) == 0) {
2646                         /* Wait for NameServer query cmpl before we can
2647                            continue */
2648                         return 1;
2649                 }
2650         } else {
2651                 /* If login to NameServer does not exist, issue one */
2652                 /* Good status, issue PLOGI to NameServer */
2653                 ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, NameServer_DID);
2654                 if (ndlp) {
2655                         /* Wait for NameServer login cmpl before we can
2656                            continue */
2657                         return 1;
2658                 }
2659                 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
2660                 if (!ndlp) {
2661                         lpfc_els_flush_rscn(phba);
2662                         return 0;
2663                 } else {
2664                         lpfc_nlp_init(phba, ndlp, NameServer_DID);
2665                         ndlp->nlp_type |= NLP_FABRIC;
2666                         ndlp->nlp_prev_state = ndlp->nlp_state;
2667                         ndlp->nlp_state = NLP_STE_PLOGI_ISSUE;
2668                         lpfc_nlp_list(phba, ndlp, NLP_PLOGI_LIST);
2669                         lpfc_issue_els_plogi(phba, NameServer_DID, 0);
2670                         /* Wait for NameServer login cmpl before we can
2671                            continue */
2672                         return 1;
2673                 }
2674         }
2675
2676         lpfc_els_flush_rscn(phba);
2677         return 0;
2678 }
2679
2680 static int
2681 lpfc_els_rcv_flogi(struct lpfc_hba * phba,
2682                    struct lpfc_iocbq * cmdiocb,
2683                    struct lpfc_nodelist * ndlp, uint8_t newnode)
2684 {
2685         struct lpfc_dmabuf *pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
2686         uint32_t *lp = (uint32_t *) pcmd->virt;
2687         IOCB_t *icmd = &cmdiocb->iocb;
2688         struct serv_parm *sp;
2689         LPFC_MBOXQ_t *mbox;
2690         struct ls_rjt stat;
2691         uint32_t cmd, did;
2692         int rc;
2693
2694         cmd = *lp++;
2695         sp = (struct serv_parm *) lp;
2696
2697         /* FLOGI received */
2698
2699         lpfc_set_disctmo(phba);
2700
2701         if (phba->fc_topology == TOPOLOGY_LOOP) {
2702                 /* We should never receive a FLOGI in loop mode, ignore it */
2703                 did = icmd->un.elsreq64.remoteID;
2704
2705                 /* An FLOGI ELS command <elsCmd> was received from DID <did> in
2706                    Loop Mode */
2707                 lpfc_printf_log(phba, KERN_ERR, LOG_ELS,
2708                                 "%d:0113 An FLOGI ELS command x%x was received "
2709                                 "from DID x%x in Loop Mode\n",
2710                                 phba->brd_no, cmd, did);
2711                 return 1;
2712         }
2713
2714         did = Fabric_DID;
2715
2716         if ((lpfc_check_sparm(phba, ndlp, sp, CLASS3))) {
2717                 /* For a FLOGI we accept, then if our portname is greater
2718                  * then the remote portname we initiate Nport login.
2719                  */
2720
2721                 rc = memcmp(&phba->fc_portname, &sp->portName,
2722                             sizeof (struct lpfc_name));
2723
2724                 if (!rc) {
2725                         if ((mbox = mempool_alloc(phba->mbox_mem_pool,
2726                                                   GFP_KERNEL)) == 0) {
2727                                 return 1;
2728                         }
2729                         lpfc_linkdown(phba);
2730                         lpfc_init_link(phba, mbox,
2731                                        phba->cfg_topology,
2732                                        phba->cfg_link_speed);
2733                         mbox->mb.un.varInitLnk.lipsr_AL_PA = 0;
2734                         mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
2735                         rc = lpfc_sli_issue_mbox
2736                                 (phba, mbox, (MBX_NOWAIT | MBX_STOP_IOCB));
2737                         if (rc == MBX_NOT_FINISHED) {
2738                                 mempool_free( mbox, phba->mbox_mem_pool);
2739                         }
2740                         return 1;
2741                 } else if (rc > 0) {    /* greater than */
2742                         spin_lock_irq(phba->host->host_lock);
2743                         phba->fc_flag |= FC_PT2PT_PLOGI;
2744                         spin_unlock_irq(phba->host->host_lock);
2745                 }
2746                 phba->fc_flag |= FC_PT2PT;
2747                 phba->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP);
2748         } else {
2749                 /* Reject this request because invalid parameters */
2750                 stat.un.b.lsRjtRsvd0 = 0;
2751                 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
2752                 stat.un.b.lsRjtRsnCodeExp = LSEXP_SPARM_OPTIONS;
2753                 stat.un.b.vendorUnique = 0;
2754                 lpfc_els_rsp_reject(phba, stat.un.lsRjtError, cmdiocb, ndlp);
2755                 return 1;
2756         }
2757
2758         /* Send back ACC */
2759         lpfc_els_rsp_acc(phba, ELS_CMD_PLOGI, cmdiocb, ndlp, NULL, newnode);
2760
2761         return 0;
2762 }
2763
2764 static int
2765 lpfc_els_rcv_rnid(struct lpfc_hba * phba,
2766                   struct lpfc_iocbq * cmdiocb, struct lpfc_nodelist * ndlp)
2767 {
2768         struct lpfc_dmabuf *pcmd;
2769         uint32_t *lp;
2770         IOCB_t *icmd;
2771         RNID *rn;
2772         struct ls_rjt stat;
2773         uint32_t cmd, did;
2774
2775         icmd = &cmdiocb->iocb;
2776         did = icmd->un.elsreq64.remoteID;
2777         pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
2778         lp = (uint32_t *) pcmd->virt;
2779
2780         cmd = *lp++;
2781         rn = (RNID *) lp;
2782
2783         /* RNID received */
2784
2785         switch (rn->Format) {
2786         case 0:
2787         case RNID_TOPOLOGY_DISC:
2788                 /* Send back ACC */
2789                 lpfc_els_rsp_rnid_acc(phba, rn->Format, cmdiocb, ndlp);
2790                 break;
2791         default:
2792                 /* Reject this request because format not supported */
2793                 stat.un.b.lsRjtRsvd0 = 0;
2794                 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
2795                 stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
2796                 stat.un.b.vendorUnique = 0;
2797                 lpfc_els_rsp_reject(phba, stat.un.lsRjtError, cmdiocb, ndlp);
2798         }
2799         return 0;
2800 }
2801
2802 static int
2803 lpfc_els_rcv_lirr(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
2804                  struct lpfc_nodelist * ndlp)
2805 {
2806         struct ls_rjt stat;
2807
2808         /* For now, unconditionally reject this command */
2809         stat.un.b.lsRjtRsvd0 = 0;
2810         stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
2811         stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
2812         stat.un.b.vendorUnique = 0;
2813         lpfc_els_rsp_reject(phba, stat.un.lsRjtError, cmdiocb, ndlp);
2814         return 0;
2815 }
2816
2817 static void
2818 lpfc_els_rsp_rps_acc(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb)
2819 {
2820         struct lpfc_sli *psli;
2821         struct lpfc_sli_ring *pring;
2822         MAILBOX_t *mb;
2823         IOCB_t *icmd;
2824         RPS_RSP *rps_rsp;
2825         uint8_t *pcmd;
2826         struct lpfc_iocbq *elsiocb;
2827         struct lpfc_nodelist *ndlp;
2828         uint16_t xri, status;
2829         uint32_t cmdsize;
2830
2831         psli = &phba->sli;
2832         pring = &psli->ring[LPFC_ELS_RING];
2833         mb = &pmb->mb;
2834
2835         ndlp = (struct lpfc_nodelist *) pmb->context2;
2836         xri = (uint16_t) ((unsigned long)(pmb->context1));
2837         pmb->context1 = NULL;
2838         pmb->context2 = NULL;
2839
2840         if (mb->mbxStatus) {
2841                 mempool_free( pmb, phba->mbox_mem_pool);
2842                 return;
2843         }
2844
2845         cmdsize = sizeof(RPS_RSP) + sizeof(uint32_t);
2846         mempool_free( pmb, phba->mbox_mem_pool);
2847         elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, lpfc_max_els_tries, ndlp,
2848                                                 ndlp->nlp_DID, ELS_CMD_ACC);
2849         if (!elsiocb)
2850                 return;
2851
2852         icmd = &elsiocb->iocb;
2853         icmd->ulpContext = xri;
2854
2855         pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2856         *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
2857         pcmd += sizeof (uint32_t); /* Skip past command */
2858         rps_rsp = (RPS_RSP *)pcmd;
2859
2860         if (phba->fc_topology != TOPOLOGY_LOOP)
2861                 status = 0x10;
2862         else
2863                 status = 0x8;
2864         if (phba->fc_flag & FC_FABRIC)
2865                 status |= 0x4;
2866
2867         rps_rsp->rsvd1 = 0;
2868         rps_rsp->portStatus = be16_to_cpu(status);
2869         rps_rsp->linkFailureCnt = be32_to_cpu(mb->un.varRdLnk.linkFailureCnt);
2870         rps_rsp->lossSyncCnt = be32_to_cpu(mb->un.varRdLnk.lossSyncCnt);
2871         rps_rsp->lossSignalCnt = be32_to_cpu(mb->un.varRdLnk.lossSignalCnt);
2872         rps_rsp->primSeqErrCnt = be32_to_cpu(mb->un.varRdLnk.primSeqErrCnt);
2873         rps_rsp->invalidXmitWord = be32_to_cpu(mb->un.varRdLnk.invalidXmitWord);
2874         rps_rsp->crcCnt = be32_to_cpu(mb->un.varRdLnk.crcCnt);
2875
2876         /* Xmit ELS RPS ACC response tag <ulpIoTag> */
2877         lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
2878                         "%d:0118 Xmit ELS RPS ACC response tag x%x "
2879                         "Data: x%x x%x x%x x%x x%x\n",
2880                         phba->brd_no,
2881                         elsiocb->iocb.ulpIoTag,
2882                         elsiocb->iocb.ulpContext, ndlp->nlp_DID,
2883                         ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi);
2884
2885         elsiocb->iocb_cmpl = lpfc_cmpl_els_acc;
2886         phba->fc_stat.elsXmitACC++;
2887         if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
2888                 lpfc_els_free_iocb(phba, elsiocb);
2889         }
2890         return;
2891 }
2892
2893 static int
2894 lpfc_els_rcv_rps(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
2895                  struct lpfc_nodelist * ndlp)
2896 {
2897         uint32_t *lp;
2898         uint8_t flag;
2899         LPFC_MBOXQ_t *mbox;
2900         struct lpfc_dmabuf *pcmd;
2901         RPS *rps;
2902         struct ls_rjt stat;
2903
2904         if ((ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) &&
2905             (ndlp->nlp_state != NLP_STE_MAPPED_NODE)) {
2906                 stat.un.b.lsRjtRsvd0 = 0;
2907                 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
2908                 stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
2909                 stat.un.b.vendorUnique = 0;
2910                 lpfc_els_rsp_reject(phba, stat.un.lsRjtError, cmdiocb, ndlp);
2911         }
2912
2913         pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
2914         lp = (uint32_t *) pcmd->virt;
2915         flag = (be32_to_cpu(*lp++) & 0xf);
2916         rps = (RPS *) lp;
2917
2918         if ((flag == 0) ||
2919             ((flag == 1) && (be32_to_cpu(rps->un.portNum) == 0)) ||
2920             ((flag == 2) && (memcmp(&rps->un.portName, &phba->fc_portname,
2921                            sizeof (struct lpfc_name)) == 0))) {
2922                 if ((mbox = mempool_alloc(phba->mbox_mem_pool, GFP_ATOMIC))) {
2923                         lpfc_read_lnk_stat(phba, mbox);
2924                         mbox->context1 =
2925                             (void *)((unsigned long)cmdiocb->iocb.ulpContext);
2926                         mbox->context2 = ndlp;
2927                         mbox->mbox_cmpl = lpfc_els_rsp_rps_acc;
2928                         if (lpfc_sli_issue_mbox (phba, mbox,
2929                             (MBX_NOWAIT | MBX_STOP_IOCB)) != MBX_NOT_FINISHED) {
2930                                 /* Mbox completion will send ELS Response */
2931                                 return 0;
2932                         }
2933                         mempool_free(mbox, phba->mbox_mem_pool);
2934                 }
2935         }
2936         stat.un.b.lsRjtRsvd0 = 0;
2937         stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
2938         stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
2939         stat.un.b.vendorUnique = 0;
2940         lpfc_els_rsp_reject(phba, stat.un.lsRjtError, cmdiocb, ndlp);
2941         return 0;
2942 }
2943
2944 static int
2945 lpfc_els_rsp_rpl_acc(struct lpfc_hba * phba, uint16_t cmdsize,
2946                  struct lpfc_iocbq * oldiocb, struct lpfc_nodelist * ndlp)
2947 {
2948         IOCB_t *icmd;
2949         IOCB_t *oldcmd;
2950         RPL_RSP rpl_rsp;
2951         struct lpfc_iocbq *elsiocb;
2952         struct lpfc_sli_ring *pring;
2953         struct lpfc_sli *psli;
2954         uint8_t *pcmd;
2955
2956         psli = &phba->sli;
2957         pring = &psli->ring[LPFC_ELS_RING];     /* ELS ring */
2958
2959         elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry,
2960                                         ndlp, ndlp->nlp_DID, ELS_CMD_ACC);
2961         if (!elsiocb)
2962                 return 1;
2963
2964         icmd = &elsiocb->iocb;
2965         oldcmd = &oldiocb->iocb;
2966         icmd->ulpContext = oldcmd->ulpContext;  /* Xri */
2967
2968         pcmd = (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2969         *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
2970         pcmd += sizeof (uint16_t);
2971         *((uint16_t *)(pcmd)) = be16_to_cpu(cmdsize);
2972         pcmd += sizeof(uint16_t);
2973
2974         /* Setup the RPL ACC payload */
2975         rpl_rsp.listLen = be32_to_cpu(1);
2976         rpl_rsp.index = 0;
2977         rpl_rsp.port_num_blk.portNum = 0;
2978         rpl_rsp.port_num_blk.portID = be32_to_cpu(phba->fc_myDID);
2979         memcpy(&rpl_rsp.port_num_blk.portName, &phba->fc_portname,
2980             sizeof(struct lpfc_name));
2981
2982         memcpy(pcmd, &rpl_rsp, cmdsize - sizeof(uint32_t));
2983
2984
2985         /* Xmit ELS RPL ACC response tag <ulpIoTag> */
2986         lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
2987                         "%d:0120 Xmit ELS RPL ACC response tag x%x "
2988                         "Data: x%x x%x x%x x%x x%x\n",
2989                         phba->brd_no,
2990                         elsiocb->iocb.ulpIoTag,
2991                         elsiocb->iocb.ulpContext, ndlp->nlp_DID,
2992                         ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi);
2993
2994         elsiocb->iocb_cmpl = lpfc_cmpl_els_acc;
2995
2996         phba->fc_stat.elsXmitACC++;
2997         if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
2998                 lpfc_els_free_iocb(phba, elsiocb);
2999                 return 1;
3000         }
3001         return 0;
3002 }
3003
3004 static int
3005 lpfc_els_rcv_rpl(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
3006                  struct lpfc_nodelist * ndlp)
3007 {
3008         struct lpfc_dmabuf *pcmd;
3009         uint32_t *lp;
3010         uint32_t maxsize;
3011         uint16_t cmdsize;
3012         RPL *rpl;
3013         struct ls_rjt stat;
3014
3015         if ((ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) &&
3016             (ndlp->nlp_state != NLP_STE_MAPPED_NODE)) {
3017                 stat.un.b.lsRjtRsvd0 = 0;
3018                 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
3019                 stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
3020                 stat.un.b.vendorUnique = 0;
3021                 lpfc_els_rsp_reject(phba, stat.un.lsRjtError, cmdiocb, ndlp);
3022         }
3023
3024         pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
3025         lp = (uint32_t *) pcmd->virt;
3026         rpl = (RPL *) (lp + 1);
3027
3028         maxsize = be32_to_cpu(rpl->maxsize);
3029
3030         /* We support only one port */
3031         if ((rpl->index == 0) &&
3032             ((maxsize == 0) ||
3033              ((maxsize * sizeof(uint32_t)) >= sizeof(RPL_RSP)))) {
3034                 cmdsize = sizeof(uint32_t) + sizeof(RPL_RSP);
3035         } else {
3036                 cmdsize = sizeof(uint32_t) + maxsize * sizeof(uint32_t);
3037         }
3038         lpfc_els_rsp_rpl_acc(phba, cmdsize, cmdiocb, ndlp);
3039
3040         return 0;
3041 }
3042
3043 static int
3044 lpfc_els_rcv_farp(struct lpfc_hba * phba,
3045                   struct lpfc_iocbq * cmdiocb, struct lpfc_nodelist * ndlp)
3046 {
3047         struct lpfc_dmabuf *pcmd;
3048         uint32_t *lp;
3049         IOCB_t *icmd;
3050         FARP *fp;
3051         uint32_t cmd, cnt, did;
3052
3053         icmd = &cmdiocb->iocb;
3054         did = icmd->un.elsreq64.remoteID;
3055         pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
3056         lp = (uint32_t *) pcmd->virt;
3057
3058         cmd = *lp++;
3059         fp = (FARP *) lp;
3060
3061         /* FARP-REQ received from DID <did> */
3062         lpfc_printf_log(phba,
3063                          KERN_INFO,
3064                          LOG_ELS,
3065                          "%d:0601 FARP-REQ received from DID x%x\n",
3066                          phba->brd_no, did);
3067
3068         /* We will only support match on WWPN or WWNN */
3069         if (fp->Mflags & ~(FARP_MATCH_NODE | FARP_MATCH_PORT)) {
3070                 return 0;
3071         }
3072
3073         cnt = 0;
3074         /* If this FARP command is searching for my portname */
3075         if (fp->Mflags & FARP_MATCH_PORT) {
3076                 if (memcmp(&fp->RportName, &phba->fc_portname,
3077                            sizeof (struct lpfc_name)) == 0)
3078                         cnt = 1;
3079         }
3080
3081         /* If this FARP command is searching for my nodename */
3082         if (fp->Mflags & FARP_MATCH_NODE) {
3083                 if (memcmp(&fp->RnodeName, &phba->fc_nodename,
3084                            sizeof (struct lpfc_name)) == 0)
3085                         cnt = 1;
3086         }
3087
3088         if (cnt) {
3089                 if ((ndlp->nlp_state == NLP_STE_UNMAPPED_NODE) ||
3090                    (ndlp->nlp_state == NLP_STE_MAPPED_NODE)) {
3091                         /* Log back into the node before sending the FARP. */
3092                         if (fp->Rflags & FARP_REQUEST_PLOGI) {
3093                                 ndlp->nlp_prev_state = ndlp->nlp_state;
3094                                 ndlp->nlp_state = NLP_STE_PLOGI_ISSUE;
3095                                 lpfc_nlp_list(phba, ndlp, NLP_PLOGI_LIST);
3096                                 lpfc_issue_els_plogi(phba, ndlp->nlp_DID, 0);
3097                         }
3098
3099                         /* Send a FARP response to that node */
3100                         if (fp->Rflags & FARP_REQUEST_FARPR) {
3101                                 lpfc_issue_els_farpr(phba, did, 0);
3102                         }
3103                 }
3104         }
3105         return 0;
3106 }
3107
3108 static int
3109 lpfc_els_rcv_farpr(struct lpfc_hba * phba,
3110                    struct lpfc_iocbq * cmdiocb, struct lpfc_nodelist * ndlp)
3111 {
3112         struct lpfc_dmabuf *pcmd;
3113         uint32_t *lp;
3114         IOCB_t *icmd;
3115         uint32_t cmd, did;
3116
3117         icmd = &cmdiocb->iocb;
3118         did = icmd->un.elsreq64.remoteID;
3119         pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
3120         lp = (uint32_t *) pcmd->virt;
3121
3122         cmd = *lp++;
3123         /* FARP-RSP received from DID <did> */
3124         lpfc_printf_log(phba,
3125                          KERN_INFO,
3126                          LOG_ELS,
3127                          "%d:0600 FARP-RSP received from DID x%x\n",
3128                          phba->brd_no, did);
3129
3130         /* ACCEPT the Farp resp request */
3131         lpfc_els_rsp_acc(phba, ELS_CMD_ACC, cmdiocb, ndlp, NULL, 0);
3132
3133         return 0;
3134 }
3135
3136 static int
3137 lpfc_els_rcv_fan(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
3138                  struct lpfc_nodelist * fan_ndlp)
3139 {
3140         struct lpfc_dmabuf *pcmd;
3141         uint32_t *lp;
3142         IOCB_t *icmd;
3143         uint32_t cmd, did;
3144         FAN *fp;
3145         struct lpfc_nodelist *ndlp, *next_ndlp;
3146
3147         /* FAN received */
3148         lpfc_printf_log(phba, KERN_INFO, LOG_ELS, "%d:0265 FAN received\n",
3149                                                                 phba->brd_no);
3150
3151         icmd = &cmdiocb->iocb;
3152         did = icmd->un.elsreq64.remoteID;
3153         pcmd = (struct lpfc_dmabuf *)cmdiocb->context2;
3154         lp = (uint32_t *)pcmd->virt;
3155
3156         cmd = *lp++;
3157         fp = (FAN *)lp;
3158
3159         /* FAN received; Fan does not have a reply sequence */
3160
3161         if (phba->hba_state == LPFC_LOCAL_CFG_LINK) {
3162                 if ((memcmp(&phba->fc_fabparam.nodeName, &fp->FnodeName,
3163                         sizeof(struct lpfc_name)) != 0) ||
3164                     (memcmp(&phba->fc_fabparam.portName, &fp->FportName,
3165                         sizeof(struct lpfc_name)) != 0)) {
3166                         /*
3167                          * This node has switched fabrics.  FLOGI is required
3168                          * Clean up the old rpi's
3169                          */
3170
3171                         list_for_each_entry_safe(ndlp, next_ndlp,
3172                                 &phba->fc_npr_list, nlp_listp) {
3173
3174                                 if (ndlp->nlp_type & NLP_FABRIC) {
3175                                         /*
3176                                          * Clean up old Fabric, Nameserver and
3177                                          * other NLP_FABRIC logins
3178                                          */
3179                                         lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
3180                                 } else if (!(ndlp->nlp_flag & NLP_NPR_ADISC)) {
3181                                         /* Fail outstanding I/O now since this
3182                                          * device is marked for PLOGI
3183                                          */
3184                                         lpfc_unreg_rpi(phba, ndlp);
3185                                 }
3186                         }
3187
3188                         phba->hba_state = LPFC_FLOGI;
3189                         lpfc_set_disctmo(phba);
3190                         lpfc_initial_flogi(phba);
3191                         return 0;
3192                 }
3193                 /* Discovery not needed,
3194                  * move the nodes to their original state.
3195                  */
3196                 list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_npr_list,
3197                         nlp_listp) {
3198
3199                         switch (ndlp->nlp_prev_state) {
3200                         case NLP_STE_UNMAPPED_NODE:
3201                                 ndlp->nlp_prev_state = NLP_STE_NPR_NODE;
3202                                 ndlp->nlp_state = NLP_STE_UNMAPPED_NODE;
3203                                 lpfc_nlp_list(phba, ndlp, NLP_UNMAPPED_LIST);
3204                                 break;
3205
3206                         case NLP_STE_MAPPED_NODE:
3207                                 ndlp->nlp_prev_state = NLP_STE_NPR_NODE;
3208                                 ndlp->nlp_state = NLP_STE_MAPPED_NODE;
3209                                 lpfc_nlp_list(phba, ndlp, NLP_MAPPED_LIST);
3210                                 break;
3211
3212                         default:
3213                                 break;
3214                         }
3215                 }
3216
3217                 /* Start discovery - this should just do CLEAR_LA */
3218                 lpfc_disc_start(phba);
3219         }
3220         return 0;
3221 }
3222
3223 void
3224 lpfc_els_timeout(unsigned long ptr)
3225 {
3226         struct lpfc_hba *phba;
3227         unsigned long iflag;
3228
3229         phba = (struct lpfc_hba *)ptr;
3230         if (phba == 0)
3231                 return;
3232         spin_lock_irqsave(phba->host->host_lock, iflag);
3233         if (!(phba->work_hba_events & WORKER_ELS_TMO)) {
3234                 phba->work_hba_events |= WORKER_ELS_TMO;
3235                 if (phba->work_wait)
3236                         wake_up(phba->work_wait);
3237         }
3238         spin_unlock_irqrestore(phba->host->host_lock, iflag);
3239         return;
3240 }
3241
3242 void
3243 lpfc_els_timeout_handler(struct lpfc_hba *phba)
3244 {
3245         struct lpfc_sli_ring *pring;
3246         struct lpfc_iocbq *tmp_iocb, *piocb;
3247         IOCB_t *cmd = NULL;
3248         struct lpfc_dmabuf *pcmd;
3249         struct list_head *dlp;
3250         uint32_t *elscmd;
3251         uint32_t els_command;
3252         uint32_t timeout;
3253         uint32_t remote_ID;
3254
3255         if (phba == 0)
3256                 return;
3257         spin_lock_irq(phba->host->host_lock);
3258         /* If the timer is already canceled do nothing */
3259         if (!(phba->work_hba_events & WORKER_ELS_TMO)) {
3260                 spin_unlock_irq(phba->host->host_lock);
3261                 return;
3262         }
3263         timeout = (uint32_t)(phba->fc_ratov << 1);
3264
3265         pring = &phba->sli.ring[LPFC_ELS_RING];
3266         dlp = &pring->txcmplq;
3267
3268         list_for_each_entry_safe(piocb, tmp_iocb, &pring->txcmplq, list) {
3269                 cmd = &piocb->iocb;
3270
3271                 if (piocb->iocb_flag & LPFC_IO_LIBDFC) {
3272                         continue;
3273                 }
3274                 pcmd = (struct lpfc_dmabuf *) piocb->context2;
3275                 elscmd = (uint32_t *) (pcmd->virt);
3276                 els_command = *elscmd;
3277
3278                 if ((els_command == ELS_CMD_FARP)
3279                     || (els_command == ELS_CMD_FARPR)) {
3280                         continue;
3281                 }
3282
3283                 if (piocb->drvrTimeout > 0) {
3284                         if (piocb->drvrTimeout >= timeout) {
3285                                 piocb->drvrTimeout -= timeout;
3286                         } else {
3287                                 piocb->drvrTimeout = 0;
3288                         }
3289                         continue;
3290                 }
3291
3292                 list_del(&piocb->list);
3293                 pring->txcmplq_cnt--;
3294
3295                 if (cmd->ulpCommand == CMD_GEN_REQUEST64_CR) {
3296                         struct lpfc_nodelist *ndlp;
3297                         spin_unlock_irq(phba->host->host_lock);
3298                         ndlp = lpfc_findnode_rpi(phba, cmd->ulpContext);
3299                         spin_lock_irq(phba->host->host_lock);
3300                         remote_ID = ndlp->nlp_DID;
3301                         if (cmd->un.elsreq64.bdl.ulpIoTag32) {
3302                                 lpfc_sli_issue_abort_iotag32(phba,
3303                                         pring, piocb);
3304                         }
3305                 } else {
3306                         remote_ID = cmd->un.elsreq64.remoteID;
3307                 }
3308
3309                 lpfc_printf_log(phba,
3310                                 KERN_ERR,
3311                                 LOG_ELS,
3312                                 "%d:0127 ELS timeout Data: x%x x%x x%x x%x\n",
3313                                 phba->brd_no, els_command,
3314                                 remote_ID, cmd->ulpCommand, cmd->ulpIoTag);
3315
3316                 /*
3317                  * The iocb has timed out; abort it.
3318                  */
3319                 if (piocb->iocb_cmpl) {
3320                         cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
3321                         cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
3322                         spin_unlock_irq(phba->host->host_lock);
3323                         (piocb->iocb_cmpl) (phba, piocb, piocb);
3324                         spin_lock_irq(phba->host->host_lock);
3325                 } else
3326                         lpfc_sli_release_iocbq(phba, piocb);
3327         }
3328         if (phba->sli.ring[LPFC_ELS_RING].txcmplq_cnt)
3329                 mod_timer(&phba->els_tmofunc, jiffies + HZ * timeout);
3330
3331         spin_unlock_irq(phba->host->host_lock);
3332 }
3333
3334 void
3335 lpfc_els_flush_cmd(struct lpfc_hba * phba)
3336 {
3337         struct lpfc_sli_ring *pring;
3338         struct lpfc_iocbq *tmp_iocb, *piocb;
3339         IOCB_t *cmd = NULL;
3340         struct lpfc_dmabuf *pcmd;
3341         uint32_t *elscmd;
3342         uint32_t els_command;
3343
3344         pring = &phba->sli.ring[LPFC_ELS_RING];
3345         spin_lock_irq(phba->host->host_lock);
3346         list_for_each_entry_safe(piocb, tmp_iocb, &pring->txq, list) {
3347                 cmd = &piocb->iocb;
3348
3349                 if (piocb->iocb_flag & LPFC_IO_LIBDFC) {
3350                         continue;
3351                 }
3352
3353                 /* Do not flush out the QUE_RING and ABORT/CLOSE iocbs */
3354                 if ((cmd->ulpCommand == CMD_QUE_RING_BUF_CN) ||
3355                     (cmd->ulpCommand == CMD_QUE_RING_BUF64_CN) ||
3356                     (cmd->ulpCommand == CMD_CLOSE_XRI_CN) ||
3357                     (cmd->ulpCommand == CMD_ABORT_XRI_CN)) {
3358                         continue;
3359                 }
3360
3361                 pcmd = (struct lpfc_dmabuf *) piocb->context2;
3362                 elscmd = (uint32_t *) (pcmd->virt);
3363                 els_command = *elscmd;
3364
3365                 list_del(&piocb->list);
3366                 pring->txcmplq_cnt--;
3367
3368                 cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
3369                 cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
3370
3371                 if (piocb->iocb_cmpl) {
3372                         spin_unlock_irq(phba->host->host_lock);
3373                         (piocb->iocb_cmpl) (phba, piocb, piocb);
3374                         spin_lock_irq(phba->host->host_lock);
3375                 } else
3376                         lpfc_sli_release_iocbq(phba, piocb);
3377         }
3378
3379         list_for_each_entry_safe(piocb, tmp_iocb, &pring->txcmplq, list) {
3380                 cmd = &piocb->iocb;
3381
3382                 if (piocb->iocb_flag & LPFC_IO_LIBDFC) {
3383                         continue;
3384                 }
3385                 pcmd = (struct lpfc_dmabuf *) piocb->context2;
3386                 elscmd = (uint32_t *) (pcmd->virt);
3387                 els_command = *elscmd;
3388
3389                 list_del(&piocb->list);
3390                 pring->txcmplq_cnt--;
3391
3392                 cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
3393                 cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
3394
3395                 if (piocb->iocb_cmpl) {
3396                         spin_unlock_irq(phba->host->host_lock);
3397                         (piocb->iocb_cmpl) (phba, piocb, piocb);
3398                         spin_lock_irq(phba->host->host_lock);
3399                 } else
3400                         lpfc_sli_release_iocbq(phba, piocb);
3401         }
3402         spin_unlock_irq(phba->host->host_lock);
3403         return;
3404 }
3405
3406 void
3407 lpfc_els_unsol_event(struct lpfc_hba * phba,
3408                      struct lpfc_sli_ring * pring, struct lpfc_iocbq * elsiocb)
3409 {
3410         struct lpfc_sli *psli;
3411         struct lpfc_nodelist *ndlp;
3412         struct lpfc_dmabuf *mp;
3413         uint32_t *lp;
3414         IOCB_t *icmd;
3415         struct ls_rjt stat;
3416         uint32_t cmd;
3417         uint32_t did;
3418         uint32_t newnode;
3419         uint32_t drop_cmd = 0;  /* by default do NOT drop received cmd */
3420         uint32_t rjt_err = 0;
3421
3422         psli = &phba->sli;
3423         icmd = &elsiocb->iocb;
3424
3425         if ((icmd->ulpStatus == IOSTAT_LOCAL_REJECT) &&
3426                 ((icmd->un.ulpWord[4] & 0xff) == IOERR_RCV_BUFFER_WAITING)) {
3427                 /* Not enough posted buffers; Try posting more buffers */
3428                 phba->fc_stat.NoRcvBuf++;
3429                 lpfc_post_buffer(phba, pring, 0, 1);
3430                 return;
3431         }
3432
3433         /* If there are no BDEs associated with this IOCB,
3434          * there is nothing to do.
3435          */
3436         if (icmd->ulpBdeCount == 0)
3437                 return;
3438
3439         /* type of ELS cmd is first 32bit word in packet */
3440         mp = lpfc_sli_ringpostbuf_get(phba, pring, getPaddr(icmd->un.
3441                                                             cont64[0].
3442                                                             addrHigh,
3443                                                             icmd->un.
3444                                                             cont64[0].addrLow));
3445         if (mp == 0) {
3446                 drop_cmd = 1;
3447                 goto dropit;
3448         }
3449
3450         newnode = 0;
3451         lp = (uint32_t *) mp->virt;
3452         cmd = *lp++;
3453         lpfc_post_buffer(phba, &psli->ring[LPFC_ELS_RING], 1, 1);
3454
3455         if (icmd->ulpStatus) {
3456                 lpfc_mbuf_free(phba, mp->virt, mp->phys);
3457                 kfree(mp);
3458                 drop_cmd = 1;
3459                 goto dropit;
3460         }
3461
3462         /* Check to see if link went down during discovery */
3463         if (lpfc_els_chk_latt(phba)) {
3464                 lpfc_mbuf_free(phba, mp->virt, mp->phys);
3465                 kfree(mp);
3466                 drop_cmd = 1;
3467                 goto dropit;
3468         }
3469
3470         did = icmd->un.rcvels.remoteID;
3471         ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, did);
3472         if (!ndlp) {
3473                 /* Cannot find existing Fabric ndlp, so allocate a new one */
3474                 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
3475                 if (!ndlp) {
3476                         lpfc_mbuf_free(phba, mp->virt, mp->phys);
3477                         kfree(mp);
3478                         drop_cmd = 1;
3479                         goto dropit;
3480                 }
3481
3482                 lpfc_nlp_init(phba, ndlp, did);
3483                 newnode = 1;
3484                 if ((did & Fabric_DID_MASK) == Fabric_DID_MASK) {
3485                         ndlp->nlp_type |= NLP_FABRIC;
3486                 }
3487                 ndlp->nlp_state = NLP_STE_UNUSED_NODE;
3488                 lpfc_nlp_list(phba, ndlp, NLP_UNUSED_LIST);
3489         }
3490
3491         phba->fc_stat.elsRcvFrame++;
3492         elsiocb->context1 = ndlp;
3493         elsiocb->context2 = mp;
3494
3495         if ((cmd & ELS_CMD_MASK) == ELS_CMD_RSCN) {
3496                 cmd &= ELS_CMD_MASK;
3497         }
3498         /* ELS command <elsCmd> received from NPORT <did> */
3499         lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
3500                         "%d:0112 ELS command x%x received from NPORT x%x "
3501                         "Data: x%x\n", phba->brd_no, cmd, did, phba->hba_state);
3502
3503         switch (cmd) {
3504         case ELS_CMD_PLOGI:
3505                 phba->fc_stat.elsRcvPLOGI++;
3506                 if (phba->hba_state < LPFC_DISC_AUTH) {
3507                         rjt_err = 1;
3508                         break;
3509                 }
3510                 ndlp = lpfc_plogi_confirm_nport(phba, mp, ndlp);
3511                 lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_PLOGI);
3512                 break;
3513         case ELS_CMD_FLOGI:
3514                 phba->fc_stat.elsRcvFLOGI++;
3515                 lpfc_els_rcv_flogi(phba, elsiocb, ndlp, newnode);
3516                 if (newnode) {
3517                         lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
3518                 }
3519                 break;
3520         case ELS_CMD_LOGO:
3521                 phba->fc_stat.elsRcvLOGO++;
3522                 if (phba->hba_state < LPFC_DISC_AUTH) {
3523                         rjt_err = 1;
3524                         break;
3525                 }
3526                 lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_LOGO);
3527                 break;
3528         case ELS_CMD_PRLO:
3529                 phba->fc_stat.elsRcvPRLO++;
3530                 if (phba->hba_state < LPFC_DISC_AUTH) {
3531                         rjt_err = 1;
3532                         break;
3533                 }
3534                 lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_PRLO);
3535                 break;
3536         case ELS_CMD_RSCN:
3537                 phba->fc_stat.elsRcvRSCN++;
3538                 lpfc_els_rcv_rscn(phba, elsiocb, ndlp, newnode);
3539                 if (newnode) {
3540                         lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
3541                 }
3542                 break;
3543         case ELS_CMD_ADISC:
3544                 phba->fc_stat.elsRcvADISC++;
3545                 if (phba->hba_state < LPFC_DISC_AUTH) {
3546                         rjt_err = 1;
3547                         break;
3548                 }
3549                 lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_ADISC);
3550                 break;
3551         case ELS_CMD_PDISC:
3552                 phba->fc_stat.elsRcvPDISC++;
3553                 if (phba->hba_state < LPFC_DISC_AUTH) {
3554                         rjt_err = 1;
3555                         break;
3556                 }
3557                 lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_PDISC);
3558                 break;
3559         case ELS_CMD_FARPR:
3560                 phba->fc_stat.elsRcvFARPR++;
3561                 lpfc_els_rcv_farpr(phba, elsiocb, ndlp);
3562                 break;
3563         case ELS_CMD_FARP:
3564                 phba->fc_stat.elsRcvFARP++;
3565                 lpfc_els_rcv_farp(phba, elsiocb, ndlp);
3566                 break;
3567         case ELS_CMD_FAN:
3568                 phba->fc_stat.elsRcvFAN++;
3569                 lpfc_els_rcv_fan(phba, elsiocb, ndlp);
3570                 break;
3571         case ELS_CMD_PRLI:
3572                 phba->fc_stat.elsRcvPRLI++;
3573                 if (phba->hba_state < LPFC_DISC_AUTH) {
3574                         rjt_err = 1;
3575                         break;
3576                 }
3577                 lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_PRLI);
3578                 break;
3579         case ELS_CMD_LIRR:
3580                 phba->fc_stat.elsRcvLIRR++;
3581                 lpfc_els_rcv_lirr(phba, elsiocb, ndlp);
3582                 if (newnode) {
3583                         lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
3584                 }
3585                 break;
3586         case ELS_CMD_RPS:
3587                 phba->fc_stat.elsRcvRPS++;
3588                 lpfc_els_rcv_rps(phba, elsiocb, ndlp);
3589                 if (newnode) {
3590                         lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
3591                 }
3592                 break;
3593         case ELS_CMD_RPL:
3594                 phba->fc_stat.elsRcvRPL++;
3595                 lpfc_els_rcv_rpl(phba, elsiocb, ndlp);
3596                 if (newnode) {
3597                         lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
3598                 }
3599                 break;
3600         case ELS_CMD_RNID:
3601                 phba->fc_stat.elsRcvRNID++;
3602                 lpfc_els_rcv_rnid(phba, elsiocb, ndlp);
3603                 if (newnode) {
3604                         lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
3605                 }
3606                 break;
3607         default:
3608                 /* Unsupported ELS command, reject */
3609                 rjt_err = 1;
3610
3611                 /* Unknown ELS command <elsCmd> received from NPORT <did> */
3612                 lpfc_printf_log(phba, KERN_ERR, LOG_ELS,
3613                                 "%d:0115 Unknown ELS command x%x received from "
3614                                 "NPORT x%x\n", phba->brd_no, cmd, did);
3615                 if (newnode) {
3616                         lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
3617                 }
3618                 break;
3619         }
3620
3621         /* check if need to LS_RJT received ELS cmd */
3622         if (rjt_err) {
3623                 stat.un.b.lsRjtRsvd0 = 0;
3624                 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
3625                 stat.un.b.lsRjtRsnCodeExp = LSEXP_NOTHING_MORE;
3626                 stat.un.b.vendorUnique = 0;
3627                 lpfc_els_rsp_reject(phba, stat.un.lsRjtError, elsiocb, ndlp);
3628         }
3629
3630         if (elsiocb->context2) {
3631                 lpfc_mbuf_free(phba, mp->virt, mp->phys);
3632                 kfree(mp);
3633         }
3634 dropit:
3635         /* check if need to drop received ELS cmd */
3636         if (drop_cmd == 1) {
3637                 lpfc_printf_log(phba, KERN_ERR, LOG_ELS,
3638                                 "%d:0111 Dropping received ELS cmd "
3639                                 "Data: x%x x%x x%x\n", phba->brd_no,
3640                                 icmd->ulpStatus, icmd->un.ulpWord[4],
3641                                 icmd->ulpTimeout);
3642                 phba->fc_stat.elsRcvDrop++;
3643         }
3644         return;
3645 }