drivers/scsi/lpfc/lpfc_els.c

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