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