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

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