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