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

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