SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/scsi/lpfc/lpfc_els.c

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