3619 lines
94 KiB
C
3619 lines
94 KiB
C
/*******************************************************************
|
|
* This file is part of the Emulex Linux Device Driver for *
|
|
* Fibre Channel Host Bus Adapters. *
|
|
* Copyright (C) 2004-2006 Emulex. All rights reserved. *
|
|
* EMULEX and SLI are trademarks of Emulex. *
|
|
* www.emulex.com *
|
|
* Portions Copyright (C) 2004-2005 Christoph Hellwig *
|
|
* *
|
|
* This program is free software; you can redistribute it and/or *
|
|
* modify it under the terms of version 2 of the GNU General *
|
|
* Public License as published by the Free Software Foundation. *
|
|
* This program is distributed in the hope that it will be useful. *
|
|
* ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND *
|
|
* WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, *
|
|
* FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE *
|
|
* DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
|
|
* TO BE LEGALLY INVALID. See the GNU General Public License for *
|
|
* more details, a copy of which can be found in the file COPYING *
|
|
* included with this package. *
|
|
*******************************************************************/
|
|
|
|
#include <linux/blkdev.h>
|
|
#include <linux/pci.h>
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <scsi/scsi.h>
|
|
#include <scsi/scsi_device.h>
|
|
#include <scsi/scsi_host.h>
|
|
#include <scsi/scsi_transport_fc.h>
|
|
|
|
#include "lpfc_hw.h"
|
|
#include "lpfc_sli.h"
|
|
#include "lpfc_disc.h"
|
|
#include "lpfc_scsi.h"
|
|
#include "lpfc.h"
|
|
#include "lpfc_logmsg.h"
|
|
#include "lpfc_crtn.h"
|
|
|
|
static int lpfc_els_retry(struct lpfc_hba *, struct lpfc_iocbq *,
|
|
struct lpfc_iocbq *);
|
|
static int lpfc_max_els_tries = 3;
|
|
|
|
static int
|
|
lpfc_els_chk_latt(struct lpfc_hba * phba)
|
|
{
|
|
struct lpfc_sli *psli;
|
|
LPFC_MBOXQ_t *mbox;
|
|
uint32_t ha_copy;
|
|
int rc;
|
|
|
|
psli = &phba->sli;
|
|
|
|
if ((phba->hba_state >= LPFC_HBA_READY) ||
|
|
(phba->hba_state == LPFC_LINK_DOWN))
|
|
return 0;
|
|
|
|
/* Read the HBA Host Attention Register */
|
|
spin_lock_irq(phba->host->host_lock);
|
|
ha_copy = readl(phba->HAregaddr);
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
|
|
if (!(ha_copy & HA_LATT))
|
|
return 0;
|
|
|
|
/* Pending Link Event during Discovery */
|
|
lpfc_printf_log(phba, KERN_WARNING, LOG_DISCOVERY,
|
|
"%d:0237 Pending Link Event during "
|
|
"Discovery: State x%x\n",
|
|
phba->brd_no, phba->hba_state);
|
|
|
|
/* CLEAR_LA should re-enable link attention events and
|
|
* we should then imediately take a LATT event. The
|
|
* LATT processing should call lpfc_linkdown() which
|
|
* will cleanup any left over in-progress discovery
|
|
* events.
|
|
*/
|
|
spin_lock_irq(phba->host->host_lock);
|
|
phba->fc_flag |= FC_ABORT_DISCOVERY;
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
|
|
if (phba->hba_state != LPFC_CLEAR_LA) {
|
|
if ((mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL))) {
|
|
phba->hba_state = LPFC_CLEAR_LA;
|
|
lpfc_clear_la(phba, mbox);
|
|
mbox->mbox_cmpl = lpfc_mbx_cmpl_clear_la;
|
|
rc = lpfc_sli_issue_mbox (phba, mbox,
|
|
(MBX_NOWAIT | MBX_STOP_IOCB));
|
|
if (rc == MBX_NOT_FINISHED) {
|
|
mempool_free(mbox, phba->mbox_mem_pool);
|
|
phba->hba_state = LPFC_HBA_ERROR;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
static struct lpfc_iocbq *
|
|
lpfc_prep_els_iocb(struct lpfc_hba * phba, uint8_t expectRsp,
|
|
uint16_t cmdSize, uint8_t retry, struct lpfc_nodelist * ndlp,
|
|
uint32_t did, uint32_t elscmd)
|
|
{
|
|
struct lpfc_sli_ring *pring;
|
|
struct lpfc_iocbq *elsiocb;
|
|
struct lpfc_dmabuf *pcmd, *prsp, *pbuflist;
|
|
struct ulp_bde64 *bpl;
|
|
IOCB_t *icmd;
|
|
|
|
pring = &phba->sli.ring[LPFC_ELS_RING];
|
|
|
|
if (phba->hba_state < LPFC_LINK_UP)
|
|
return NULL;
|
|
|
|
/* Allocate buffer for command iocb */
|
|
spin_lock_irq(phba->host->host_lock);
|
|
elsiocb = lpfc_sli_get_iocbq(phba);
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
|
|
if (elsiocb == NULL)
|
|
return NULL;
|
|
icmd = &elsiocb->iocb;
|
|
|
|
/* fill in BDEs for command */
|
|
/* Allocate buffer for command payload */
|
|
if (((pcmd = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL)) == 0) ||
|
|
((pcmd->virt = lpfc_mbuf_alloc(phba,
|
|
MEM_PRI, &(pcmd->phys))) == 0)) {
|
|
kfree(pcmd);
|
|
|
|
spin_lock_irq(phba->host->host_lock);
|
|
lpfc_sli_release_iocbq(phba, elsiocb);
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
return NULL;
|
|
}
|
|
|
|
INIT_LIST_HEAD(&pcmd->list);
|
|
|
|
/* Allocate buffer for response payload */
|
|
if (expectRsp) {
|
|
prsp = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
|
|
if (prsp)
|
|
prsp->virt = lpfc_mbuf_alloc(phba, MEM_PRI,
|
|
&prsp->phys);
|
|
if (prsp == 0 || prsp->virt == 0) {
|
|
kfree(prsp);
|
|
lpfc_mbuf_free(phba, pcmd->virt, pcmd->phys);
|
|
kfree(pcmd);
|
|
spin_lock_irq(phba->host->host_lock);
|
|
lpfc_sli_release_iocbq(phba, elsiocb);
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
return NULL;
|
|
}
|
|
INIT_LIST_HEAD(&prsp->list);
|
|
} else {
|
|
prsp = NULL;
|
|
}
|
|
|
|
/* Allocate buffer for Buffer ptr list */
|
|
pbuflist = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
|
|
if (pbuflist)
|
|
pbuflist->virt = lpfc_mbuf_alloc(phba, MEM_PRI,
|
|
&pbuflist->phys);
|
|
if (pbuflist == 0 || pbuflist->virt == 0) {
|
|
spin_lock_irq(phba->host->host_lock);
|
|
lpfc_sli_release_iocbq(phba, elsiocb);
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
lpfc_mbuf_free(phba, pcmd->virt, pcmd->phys);
|
|
lpfc_mbuf_free(phba, prsp->virt, prsp->phys);
|
|
kfree(pcmd);
|
|
kfree(prsp);
|
|
kfree(pbuflist);
|
|
return NULL;
|
|
}
|
|
|
|
INIT_LIST_HEAD(&pbuflist->list);
|
|
|
|
icmd->un.elsreq64.bdl.addrHigh = putPaddrHigh(pbuflist->phys);
|
|
icmd->un.elsreq64.bdl.addrLow = putPaddrLow(pbuflist->phys);
|
|
icmd->un.elsreq64.bdl.bdeFlags = BUFF_TYPE_BDL;
|
|
if (expectRsp) {
|
|
icmd->un.elsreq64.bdl.bdeSize = (2 * sizeof (struct ulp_bde64));
|
|
icmd->un.elsreq64.remoteID = did; /* DID */
|
|
icmd->ulpCommand = CMD_ELS_REQUEST64_CR;
|
|
} else {
|
|
icmd->un.elsreq64.bdl.bdeSize = sizeof (struct ulp_bde64);
|
|
icmd->ulpCommand = CMD_XMIT_ELS_RSP64_CX;
|
|
}
|
|
|
|
icmd->ulpBdeCount = 1;
|
|
icmd->ulpLe = 1;
|
|
icmd->ulpClass = CLASS3;
|
|
|
|
bpl = (struct ulp_bde64 *) pbuflist->virt;
|
|
bpl->addrLow = le32_to_cpu(putPaddrLow(pcmd->phys));
|
|
bpl->addrHigh = le32_to_cpu(putPaddrHigh(pcmd->phys));
|
|
bpl->tus.f.bdeSize = cmdSize;
|
|
bpl->tus.f.bdeFlags = 0;
|
|
bpl->tus.w = le32_to_cpu(bpl->tus.w);
|
|
|
|
if (expectRsp) {
|
|
bpl++;
|
|
bpl->addrLow = le32_to_cpu(putPaddrLow(prsp->phys));
|
|
bpl->addrHigh = le32_to_cpu(putPaddrHigh(prsp->phys));
|
|
bpl->tus.f.bdeSize = FCELSSIZE;
|
|
bpl->tus.f.bdeFlags = BUFF_USE_RCV;
|
|
bpl->tus.w = le32_to_cpu(bpl->tus.w);
|
|
}
|
|
|
|
/* Save for completion so we can release these resources */
|
|
elsiocb->context1 = (uint8_t *) ndlp;
|
|
elsiocb->context2 = (uint8_t *) pcmd;
|
|
elsiocb->context3 = (uint8_t *) pbuflist;
|
|
elsiocb->retry = retry;
|
|
elsiocb->drvrTimeout = (phba->fc_ratov << 1) + LPFC_DRVR_TIMEOUT;
|
|
|
|
if (prsp) {
|
|
list_add(&prsp->list, &pcmd->list);
|
|
}
|
|
|
|
if (expectRsp) {
|
|
/* Xmit ELS command <elsCmd> to remote NPORT <did> */
|
|
lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
|
|
"%d:0116 Xmit ELS command x%x to remote "
|
|
"NPORT x%x Data: x%x x%x\n",
|
|
phba->brd_no, elscmd,
|
|
did, icmd->ulpIoTag, phba->hba_state);
|
|
} else {
|
|
/* Xmit ELS response <elsCmd> to remote NPORT <did> */
|
|
lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
|
|
"%d:0117 Xmit ELS response x%x to remote "
|
|
"NPORT x%x Data: x%x x%x\n",
|
|
phba->brd_no, elscmd,
|
|
ndlp->nlp_DID, icmd->ulpIoTag, cmdSize);
|
|
}
|
|
|
|
return elsiocb;
|
|
}
|
|
|
|
|
|
static int
|
|
lpfc_cmpl_els_flogi_fabric(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
|
|
struct serv_parm *sp, IOCB_t *irsp)
|
|
{
|
|
LPFC_MBOXQ_t *mbox;
|
|
int rc;
|
|
|
|
spin_lock_irq(phba->host->host_lock);
|
|
phba->fc_flag |= FC_FABRIC;
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
|
|
phba->fc_edtov = be32_to_cpu(sp->cmn.e_d_tov);
|
|
if (sp->cmn.edtovResolution) /* E_D_TOV ticks are in nanoseconds */
|
|
phba->fc_edtov = (phba->fc_edtov + 999999) / 1000000;
|
|
|
|
phba->fc_ratov = (be32_to_cpu(sp->cmn.w2.r_a_tov) + 999) / 1000;
|
|
|
|
if (phba->fc_topology == TOPOLOGY_LOOP) {
|
|
spin_lock_irq(phba->host->host_lock);
|
|
phba->fc_flag |= FC_PUBLIC_LOOP;
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
} else {
|
|
/*
|
|
* If we are a N-port connected to a Fabric, fixup sparam's so
|
|
* logins to devices on remote loops work.
|
|
*/
|
|
phba->fc_sparam.cmn.altBbCredit = 1;
|
|
}
|
|
|
|
phba->fc_myDID = irsp->un.ulpWord[4] & Mask_DID;
|
|
memcpy(&ndlp->nlp_portname, &sp->portName, sizeof(struct lpfc_name));
|
|
memcpy(&ndlp->nlp_nodename, &sp->nodeName, sizeof (struct lpfc_name));
|
|
ndlp->nlp_class_sup = 0;
|
|
if (sp->cls1.classValid)
|
|
ndlp->nlp_class_sup |= FC_COS_CLASS1;
|
|
if (sp->cls2.classValid)
|
|
ndlp->nlp_class_sup |= FC_COS_CLASS2;
|
|
if (sp->cls3.classValid)
|
|
ndlp->nlp_class_sup |= FC_COS_CLASS3;
|
|
if (sp->cls4.classValid)
|
|
ndlp->nlp_class_sup |= FC_COS_CLASS4;
|
|
ndlp->nlp_maxframe = ((sp->cmn.bbRcvSizeMsb & 0x0F) << 8) |
|
|
sp->cmn.bbRcvSizeLsb;
|
|
memcpy(&phba->fc_fabparam, sp, sizeof(struct serv_parm));
|
|
|
|
mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
|
|
if (!mbox)
|
|
goto fail;
|
|
|
|
phba->hba_state = LPFC_FABRIC_CFG_LINK;
|
|
lpfc_config_link(phba, mbox);
|
|
mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
|
|
|
|
rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT | MBX_STOP_IOCB);
|
|
if (rc == MBX_NOT_FINISHED)
|
|
goto fail_free_mbox;
|
|
|
|
mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
|
|
if (!mbox)
|
|
goto fail;
|
|
|
|
if (lpfc_reg_login(phba, Fabric_DID, (uint8_t *) sp, mbox, 0))
|
|
goto fail_free_mbox;
|
|
|
|
mbox->mbox_cmpl = lpfc_mbx_cmpl_fabric_reg_login;
|
|
mbox->context2 = ndlp;
|
|
|
|
rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT | MBX_STOP_IOCB);
|
|
if (rc == MBX_NOT_FINISHED)
|
|
goto fail_free_mbox;
|
|
|
|
return 0;
|
|
|
|
fail_free_mbox:
|
|
mempool_free(mbox, phba->mbox_mem_pool);
|
|
fail:
|
|
return -ENXIO;
|
|
}
|
|
|
|
/*
|
|
* We FLOGIed into an NPort, initiate pt2pt protocol
|
|
*/
|
|
static int
|
|
lpfc_cmpl_els_flogi_nport(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
|
|
struct serv_parm *sp)
|
|
{
|
|
LPFC_MBOXQ_t *mbox;
|
|
int rc;
|
|
|
|
spin_lock_irq(phba->host->host_lock);
|
|
phba->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP);
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
|
|
phba->fc_edtov = FF_DEF_EDTOV;
|
|
phba->fc_ratov = FF_DEF_RATOV;
|
|
rc = memcmp(&phba->fc_portname, &sp->portName,
|
|
sizeof(struct lpfc_name));
|
|
if (rc >= 0) {
|
|
/* This side will initiate the PLOGI */
|
|
spin_lock_irq(phba->host->host_lock);
|
|
phba->fc_flag |= FC_PT2PT_PLOGI;
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
|
|
/*
|
|
* N_Port ID cannot be 0, set our to LocalID the other
|
|
* side will be RemoteID.
|
|
*/
|
|
|
|
/* not equal */
|
|
if (rc)
|
|
phba->fc_myDID = PT2PT_LocalID;
|
|
|
|
mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
|
|
if (!mbox)
|
|
goto fail;
|
|
|
|
lpfc_config_link(phba, mbox);
|
|
|
|
mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
|
|
rc = lpfc_sli_issue_mbox(phba, mbox,
|
|
MBX_NOWAIT | MBX_STOP_IOCB);
|
|
if (rc == MBX_NOT_FINISHED) {
|
|
mempool_free(mbox, phba->mbox_mem_pool);
|
|
goto fail;
|
|
}
|
|
mempool_free(ndlp, phba->nlp_mem_pool);
|
|
|
|
ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, PT2PT_RemoteID);
|
|
if (!ndlp) {
|
|
/*
|
|
* Cannot find existing Fabric ndlp, so allocate a
|
|
* new one
|
|
*/
|
|
ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
|
|
if (!ndlp)
|
|
goto fail;
|
|
|
|
lpfc_nlp_init(phba, ndlp, PT2PT_RemoteID);
|
|
}
|
|
|
|
memcpy(&ndlp->nlp_portname, &sp->portName,
|
|
sizeof(struct lpfc_name));
|
|
memcpy(&ndlp->nlp_nodename, &sp->nodeName,
|
|
sizeof(struct lpfc_name));
|
|
ndlp->nlp_state = NLP_STE_NPR_NODE;
|
|
lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST);
|
|
ndlp->nlp_flag |= NLP_NPR_2B_DISC;
|
|
} else {
|
|
/* This side will wait for the PLOGI */
|
|
mempool_free( ndlp, phba->nlp_mem_pool);
|
|
}
|
|
|
|
spin_lock_irq(phba->host->host_lock);
|
|
phba->fc_flag |= FC_PT2PT;
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
|
|
/* Start discovery - this should just do CLEAR_LA */
|
|
lpfc_disc_start(phba);
|
|
return 0;
|
|
fail:
|
|
return -ENXIO;
|
|
}
|
|
|
|
static void
|
|
lpfc_cmpl_els_flogi(struct lpfc_hba * phba,
|
|
struct lpfc_iocbq * cmdiocb, struct lpfc_iocbq * rspiocb)
|
|
{
|
|
IOCB_t *irsp = &rspiocb->iocb;
|
|
struct lpfc_nodelist *ndlp = cmdiocb->context1;
|
|
struct lpfc_dmabuf *pcmd = cmdiocb->context2, *prsp;
|
|
struct serv_parm *sp;
|
|
int rc;
|
|
|
|
/* Check to see if link went down during discovery */
|
|
if (lpfc_els_chk_latt(phba)) {
|
|
lpfc_nlp_remove(phba, ndlp);
|
|
goto out;
|
|
}
|
|
|
|
if (irsp->ulpStatus) {
|
|
/* Check for retry */
|
|
if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
|
|
/* ELS command is being retried */
|
|
goto out;
|
|
}
|
|
/* FLOGI failed, so there is no fabric */
|
|
spin_lock_irq(phba->host->host_lock);
|
|
phba->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP);
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
|
|
/* If private loop, then allow max outstandting els to be
|
|
* LPFC_MAX_DISC_THREADS (32). Scanning in the case of no
|
|
* alpa map would take too long otherwise.
|
|
*/
|
|
if (phba->alpa_map[0] == 0) {
|
|
phba->cfg_discovery_threads =
|
|
LPFC_MAX_DISC_THREADS;
|
|
}
|
|
|
|
/* FLOGI failure */
|
|
lpfc_printf_log(phba,
|
|
KERN_INFO,
|
|
LOG_ELS,
|
|
"%d:0100 FLOGI failure Data: x%x x%x x%x\n",
|
|
phba->brd_no,
|
|
irsp->ulpStatus, irsp->un.ulpWord[4],
|
|
irsp->ulpTimeout);
|
|
goto flogifail;
|
|
}
|
|
|
|
/*
|
|
* The FLogI succeeded. Sync the data for the CPU before
|
|
* accessing it.
|
|
*/
|
|
prsp = list_get_first(&pcmd->list, struct lpfc_dmabuf, list);
|
|
|
|
sp = prsp->virt + sizeof(uint32_t);
|
|
|
|
/* FLOGI completes successfully */
|
|
lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
|
|
"%d:0101 FLOGI completes sucessfully "
|
|
"Data: x%x x%x x%x x%x\n",
|
|
phba->brd_no,
|
|
irsp->un.ulpWord[4], sp->cmn.e_d_tov,
|
|
sp->cmn.w2.r_a_tov, sp->cmn.edtovResolution);
|
|
|
|
if (phba->hba_state == LPFC_FLOGI) {
|
|
/*
|
|
* If Common Service Parameters indicate Nport
|
|
* we are point to point, if Fport we are Fabric.
|
|
*/
|
|
if (sp->cmn.fPort)
|
|
rc = lpfc_cmpl_els_flogi_fabric(phba, ndlp, sp, irsp);
|
|
else
|
|
rc = lpfc_cmpl_els_flogi_nport(phba, ndlp, sp);
|
|
|
|
if (!rc)
|
|
goto out;
|
|
}
|
|
|
|
flogifail:
|
|
lpfc_nlp_remove(phba, ndlp);
|
|
|
|
if (irsp->ulpStatus != IOSTAT_LOCAL_REJECT ||
|
|
(irsp->un.ulpWord[4] != IOERR_SLI_ABORTED &&
|
|
irsp->un.ulpWord[4] != IOERR_SLI_DOWN)) {
|
|
/* FLOGI failed, so just use loop map to make discovery list */
|
|
lpfc_disc_list_loopmap(phba);
|
|
|
|
/* Start discovery */
|
|
lpfc_disc_start(phba);
|
|
}
|
|
|
|
out:
|
|
lpfc_els_free_iocb(phba, cmdiocb);
|
|
}
|
|
|
|
static int
|
|
lpfc_issue_els_flogi(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp,
|
|
uint8_t retry)
|
|
{
|
|
struct serv_parm *sp;
|
|
IOCB_t *icmd;
|
|
struct lpfc_iocbq *elsiocb;
|
|
struct lpfc_sli_ring *pring;
|
|
uint8_t *pcmd;
|
|
uint16_t cmdsize;
|
|
uint32_t tmo;
|
|
int rc;
|
|
|
|
pring = &phba->sli.ring[LPFC_ELS_RING];
|
|
|
|
cmdsize = (sizeof (uint32_t) + sizeof (struct serv_parm));
|
|
elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, ndlp,
|
|
ndlp->nlp_DID, ELS_CMD_FLOGI);
|
|
if (!elsiocb)
|
|
return 1;
|
|
|
|
icmd = &elsiocb->iocb;
|
|
pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
|
|
|
|
/* For FLOGI request, remainder of payload is service parameters */
|
|
*((uint32_t *) (pcmd)) = ELS_CMD_FLOGI;
|
|
pcmd += sizeof (uint32_t);
|
|
memcpy(pcmd, &phba->fc_sparam, sizeof (struct serv_parm));
|
|
sp = (struct serv_parm *) pcmd;
|
|
|
|
/* Setup CSPs accordingly for Fabric */
|
|
sp->cmn.e_d_tov = 0;
|
|
sp->cmn.w2.r_a_tov = 0;
|
|
sp->cls1.classValid = 0;
|
|
sp->cls2.seqDelivery = 1;
|
|
sp->cls3.seqDelivery = 1;
|
|
if (sp->cmn.fcphLow < FC_PH3)
|
|
sp->cmn.fcphLow = FC_PH3;
|
|
if (sp->cmn.fcphHigh < FC_PH3)
|
|
sp->cmn.fcphHigh = FC_PH3;
|
|
|
|
tmo = phba->fc_ratov;
|
|
phba->fc_ratov = LPFC_DISC_FLOGI_TMO;
|
|
lpfc_set_disctmo(phba);
|
|
phba->fc_ratov = tmo;
|
|
|
|
phba->fc_stat.elsXmitFLOGI++;
|
|
elsiocb->iocb_cmpl = lpfc_cmpl_els_flogi;
|
|
spin_lock_irq(phba->host->host_lock);
|
|
rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
if (rc == IOCB_ERROR) {
|
|
lpfc_els_free_iocb(phba, elsiocb);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
lpfc_els_abort_flogi(struct lpfc_hba * phba)
|
|
{
|
|
struct lpfc_sli_ring *pring;
|
|
struct lpfc_iocbq *iocb, *next_iocb;
|
|
struct lpfc_nodelist *ndlp;
|
|
IOCB_t *icmd;
|
|
|
|
/* Abort outstanding I/O on NPort <nlp_DID> */
|
|
lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
|
|
"%d:0201 Abort outstanding I/O on NPort x%x\n",
|
|
phba->brd_no, Fabric_DID);
|
|
|
|
pring = &phba->sli.ring[LPFC_ELS_RING];
|
|
|
|
/*
|
|
* Check the txcmplq for an iocb that matches the nport the driver is
|
|
* searching for.
|
|
*/
|
|
spin_lock_irq(phba->host->host_lock);
|
|
list_for_each_entry_safe(iocb, next_iocb, &pring->txcmplq, list) {
|
|
icmd = &iocb->iocb;
|
|
if (icmd->ulpCommand == CMD_ELS_REQUEST64_CR) {
|
|
ndlp = (struct lpfc_nodelist *)(iocb->context1);
|
|
if (ndlp && (ndlp->nlp_DID == Fabric_DID)) {
|
|
list_del(&iocb->list);
|
|
pring->txcmplq_cnt--;
|
|
|
|
if ((icmd->un.elsreq64.bdl.ulpIoTag32)) {
|
|
lpfc_sli_issue_abort_iotag32
|
|
(phba, pring, iocb);
|
|
}
|
|
if (iocb->iocb_cmpl) {
|
|
icmd->ulpStatus = IOSTAT_LOCAL_REJECT;
|
|
icmd->un.ulpWord[4] =
|
|
IOERR_SLI_ABORTED;
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
(iocb->iocb_cmpl) (phba, iocb, iocb);
|
|
spin_lock_irq(phba->host->host_lock);
|
|
} else
|
|
lpfc_sli_release_iocbq(phba, iocb);
|
|
}
|
|
}
|
|
}
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
lpfc_initial_flogi(struct lpfc_hba * phba)
|
|
{
|
|
struct lpfc_nodelist *ndlp;
|
|
|
|
/* First look for the Fabric ndlp */
|
|
ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, Fabric_DID);
|
|
if (!ndlp) {
|
|
/* Cannot find existing Fabric ndlp, so allocate a new one */
|
|
ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
|
|
if (!ndlp)
|
|
return 0;
|
|
lpfc_nlp_init(phba, ndlp, Fabric_DID);
|
|
} else {
|
|
lpfc_nlp_list(phba, ndlp, NLP_JUST_DQ);
|
|
}
|
|
if (lpfc_issue_els_flogi(phba, ndlp, 0)) {
|
|
mempool_free( ndlp, phba->nlp_mem_pool);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static void
|
|
lpfc_more_plogi(struct lpfc_hba * phba)
|
|
{
|
|
int sentplogi;
|
|
|
|
if (phba->num_disc_nodes)
|
|
phba->num_disc_nodes--;
|
|
|
|
/* Continue discovery with <num_disc_nodes> PLOGIs to go */
|
|
lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
|
|
"%d:0232 Continue discovery with %d PLOGIs to go "
|
|
"Data: x%x x%x x%x\n",
|
|
phba->brd_no, phba->num_disc_nodes, phba->fc_plogi_cnt,
|
|
phba->fc_flag, phba->hba_state);
|
|
|
|
/* Check to see if there are more PLOGIs to be sent */
|
|
if (phba->fc_flag & FC_NLP_MORE) {
|
|
/* go thru NPR list and issue any remaining ELS PLOGIs */
|
|
sentplogi = lpfc_els_disc_plogi(phba);
|
|
}
|
|
return;
|
|
}
|
|
|
|
static struct lpfc_nodelist *
|
|
lpfc_plogi_confirm_nport(struct lpfc_hba * phba, struct lpfc_dmabuf *prsp,
|
|
struct lpfc_nodelist *ndlp)
|
|
{
|
|
struct lpfc_nodelist *new_ndlp;
|
|
uint32_t *lp;
|
|
struct serv_parm *sp;
|
|
uint8_t name[sizeof (struct lpfc_name)];
|
|
uint32_t rc;
|
|
|
|
lp = (uint32_t *) prsp->virt;
|
|
sp = (struct serv_parm *) ((uint8_t *) lp + sizeof (uint32_t));
|
|
memset(name, 0, sizeof (struct lpfc_name));
|
|
|
|
/* Now we to find out if the NPort we are logging into, matches the WWPN
|
|
* we have for that ndlp. If not, we have some work to do.
|
|
*/
|
|
new_ndlp = lpfc_findnode_wwpn(phba, NLP_SEARCH_ALL, &sp->portName);
|
|
|
|
if (new_ndlp == ndlp)
|
|
return ndlp;
|
|
|
|
if (!new_ndlp) {
|
|
rc =
|
|
memcmp(&ndlp->nlp_portname, name, sizeof(struct lpfc_name));
|
|
if (!rc)
|
|
return ndlp;
|
|
new_ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_ATOMIC);
|
|
if (!new_ndlp)
|
|
return ndlp;
|
|
|
|
lpfc_nlp_init(phba, new_ndlp, ndlp->nlp_DID);
|
|
}
|
|
|
|
lpfc_unreg_rpi(phba, new_ndlp);
|
|
new_ndlp->nlp_DID = ndlp->nlp_DID;
|
|
new_ndlp->nlp_prev_state = ndlp->nlp_prev_state;
|
|
new_ndlp->nlp_state = ndlp->nlp_state;
|
|
lpfc_nlp_list(phba, new_ndlp, ndlp->nlp_flag & NLP_LIST_MASK);
|
|
|
|
/* Move this back to NPR list */
|
|
if (memcmp(&ndlp->nlp_portname, name, sizeof(struct lpfc_name)) == 0) {
|
|
lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
|
|
}
|
|
else {
|
|
lpfc_unreg_rpi(phba, ndlp);
|
|
ndlp->nlp_DID = 0; /* Two ndlps cannot have the same did */
|
|
ndlp->nlp_state = NLP_STE_NPR_NODE;
|
|
lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST);
|
|
}
|
|
return new_ndlp;
|
|
}
|
|
|
|
static void
|
|
lpfc_cmpl_els_plogi(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
|
|
struct lpfc_iocbq * rspiocb)
|
|
{
|
|
IOCB_t *irsp;
|
|
struct lpfc_nodelist *ndlp;
|
|
struct lpfc_dmabuf *prsp;
|
|
int disc, rc, did, type;
|
|
|
|
|
|
/* we pass cmdiocb to state machine which needs rspiocb as well */
|
|
cmdiocb->context_un.rsp_iocb = rspiocb;
|
|
|
|
irsp = &rspiocb->iocb;
|
|
ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL,
|
|
irsp->un.elsreq64.remoteID);
|
|
if (!ndlp)
|
|
goto out;
|
|
|
|
/* Since ndlp can be freed in the disc state machine, note if this node
|
|
* is being used during discovery.
|
|
*/
|
|
disc = (ndlp->nlp_flag & NLP_NPR_2B_DISC);
|
|
spin_lock_irq(phba->host->host_lock);
|
|
ndlp->nlp_flag &= ~NLP_NPR_2B_DISC;
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
rc = 0;
|
|
|
|
/* PLOGI completes to NPort <nlp_DID> */
|
|
lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
|
|
"%d:0102 PLOGI completes to NPort x%x "
|
|
"Data: x%x x%x x%x x%x x%x\n",
|
|
phba->brd_no, ndlp->nlp_DID, irsp->ulpStatus,
|
|
irsp->un.ulpWord[4], irsp->ulpTimeout, disc,
|
|
phba->num_disc_nodes);
|
|
|
|
/* Check to see if link went down during discovery */
|
|
if (lpfc_els_chk_latt(phba)) {
|
|
spin_lock_irq(phba->host->host_lock);
|
|
ndlp->nlp_flag |= NLP_NPR_2B_DISC;
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
goto out;
|
|
}
|
|
|
|
/* ndlp could be freed in DSM, save these values now */
|
|
type = ndlp->nlp_type;
|
|
did = ndlp->nlp_DID;
|
|
|
|
if (irsp->ulpStatus) {
|
|
/* Check for retry */
|
|
if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
|
|
/* ELS command is being retried */
|
|
if (disc) {
|
|
spin_lock_irq(phba->host->host_lock);
|
|
ndlp->nlp_flag |= NLP_NPR_2B_DISC;
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
}
|
|
goto out;
|
|
}
|
|
|
|
/* PLOGI failed */
|
|
/* Do not call DSM for lpfc_els_abort'ed ELS cmds */
|
|
if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
|
|
((irsp->un.ulpWord[4] == IOERR_SLI_ABORTED) ||
|
|
(irsp->un.ulpWord[4] == IOERR_LINK_DOWN) ||
|
|
(irsp->un.ulpWord[4] == IOERR_SLI_DOWN))) {
|
|
rc = NLP_STE_FREED_NODE;
|
|
} else {
|
|
rc = lpfc_disc_state_machine(phba, ndlp, cmdiocb,
|
|
NLP_EVT_CMPL_PLOGI);
|
|
}
|
|
} else {
|
|
/* Good status, call state machine */
|
|
prsp = list_entry(((struct lpfc_dmabuf *)
|
|
cmdiocb->context2)->list.next,
|
|
struct lpfc_dmabuf, list);
|
|
ndlp = lpfc_plogi_confirm_nport(phba, prsp, ndlp);
|
|
rc = lpfc_disc_state_machine(phba, ndlp, cmdiocb,
|
|
NLP_EVT_CMPL_PLOGI);
|
|
}
|
|
|
|
if (disc && phba->num_disc_nodes) {
|
|
/* Check to see if there are more PLOGIs to be sent */
|
|
lpfc_more_plogi(phba);
|
|
|
|
if (phba->num_disc_nodes == 0) {
|
|
spin_lock_irq(phba->host->host_lock);
|
|
phba->fc_flag &= ~FC_NDISC_ACTIVE;
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
|
|
lpfc_can_disctmo(phba);
|
|
if (phba->fc_flag & FC_RSCN_MODE) {
|
|
/*
|
|
* Check to see if more RSCNs came in while
|
|
* we were processing this one.
|
|
*/
|
|
if ((phba->fc_rscn_id_cnt == 0) &&
|
|
(!(phba->fc_flag & FC_RSCN_DISCOVERY))) {
|
|
spin_lock_irq(phba->host->host_lock);
|
|
phba->fc_flag &= ~FC_RSCN_MODE;
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
} else {
|
|
lpfc_els_handle_rscn(phba);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
out:
|
|
lpfc_els_free_iocb(phba, cmdiocb);
|
|
return;
|
|
}
|
|
|
|
int
|
|
lpfc_issue_els_plogi(struct lpfc_hba * phba, uint32_t did, uint8_t retry)
|
|
{
|
|
struct serv_parm *sp;
|
|
IOCB_t *icmd;
|
|
struct lpfc_iocbq *elsiocb;
|
|
struct lpfc_sli_ring *pring;
|
|
struct lpfc_sli *psli;
|
|
uint8_t *pcmd;
|
|
uint16_t cmdsize;
|
|
|
|
psli = &phba->sli;
|
|
pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
|
|
|
|
cmdsize = (sizeof (uint32_t) + sizeof (struct serv_parm));
|
|
elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, NULL, did,
|
|
ELS_CMD_PLOGI);
|
|
if (!elsiocb)
|
|
return 1;
|
|
|
|
icmd = &elsiocb->iocb;
|
|
pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
|
|
|
|
/* For PLOGI request, remainder of payload is service parameters */
|
|
*((uint32_t *) (pcmd)) = ELS_CMD_PLOGI;
|
|
pcmd += sizeof (uint32_t);
|
|
memcpy(pcmd, &phba->fc_sparam, sizeof (struct serv_parm));
|
|
sp = (struct serv_parm *) pcmd;
|
|
|
|
if (sp->cmn.fcphLow < FC_PH_4_3)
|
|
sp->cmn.fcphLow = FC_PH_4_3;
|
|
|
|
if (sp->cmn.fcphHigh < FC_PH3)
|
|
sp->cmn.fcphHigh = FC_PH3;
|
|
|
|
phba->fc_stat.elsXmitPLOGI++;
|
|
elsiocb->iocb_cmpl = lpfc_cmpl_els_plogi;
|
|
spin_lock_irq(phba->host->host_lock);
|
|
if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
lpfc_els_free_iocb(phba, elsiocb);
|
|
return 1;
|
|
}
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
lpfc_cmpl_els_prli(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
|
|
struct lpfc_iocbq * rspiocb)
|
|
{
|
|
IOCB_t *irsp;
|
|
struct lpfc_sli *psli;
|
|
struct lpfc_nodelist *ndlp;
|
|
|
|
psli = &phba->sli;
|
|
/* we pass cmdiocb to state machine which needs rspiocb as well */
|
|
cmdiocb->context_un.rsp_iocb = rspiocb;
|
|
|
|
irsp = &(rspiocb->iocb);
|
|
ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
|
|
spin_lock_irq(phba->host->host_lock);
|
|
ndlp->nlp_flag &= ~NLP_PRLI_SND;
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
|
|
/* PRLI completes to NPort <nlp_DID> */
|
|
lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
|
|
"%d:0103 PRLI completes to NPort x%x "
|
|
"Data: x%x x%x x%x x%x\n",
|
|
phba->brd_no, ndlp->nlp_DID, irsp->ulpStatus,
|
|
irsp->un.ulpWord[4], irsp->ulpTimeout,
|
|
phba->num_disc_nodes);
|
|
|
|
phba->fc_prli_sent--;
|
|
/* Check to see if link went down during discovery */
|
|
if (lpfc_els_chk_latt(phba))
|
|
goto out;
|
|
|
|
if (irsp->ulpStatus) {
|
|
/* Check for retry */
|
|
if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
|
|
/* ELS command is being retried */
|
|
goto out;
|
|
}
|
|
/* PRLI failed */
|
|
/* Do not call DSM for lpfc_els_abort'ed ELS cmds */
|
|
if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
|
|
((irsp->un.ulpWord[4] == IOERR_SLI_ABORTED) ||
|
|
(irsp->un.ulpWord[4] == IOERR_LINK_DOWN) ||
|
|
(irsp->un.ulpWord[4] == IOERR_SLI_DOWN))) {
|
|
goto out;
|
|
} else {
|
|
lpfc_disc_state_machine(phba, ndlp, cmdiocb,
|
|
NLP_EVT_CMPL_PRLI);
|
|
}
|
|
} else {
|
|
/* Good status, call state machine */
|
|
lpfc_disc_state_machine(phba, ndlp, cmdiocb, NLP_EVT_CMPL_PRLI);
|
|
}
|
|
|
|
out:
|
|
lpfc_els_free_iocb(phba, cmdiocb);
|
|
return;
|
|
}
|
|
|
|
int
|
|
lpfc_issue_els_prli(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp,
|
|
uint8_t retry)
|
|
{
|
|
PRLI *npr;
|
|
IOCB_t *icmd;
|
|
struct lpfc_iocbq *elsiocb;
|
|
struct lpfc_sli_ring *pring;
|
|
struct lpfc_sli *psli;
|
|
uint8_t *pcmd;
|
|
uint16_t cmdsize;
|
|
|
|
psli = &phba->sli;
|
|
pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
|
|
|
|
cmdsize = (sizeof (uint32_t) + sizeof (PRLI));
|
|
elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, ndlp,
|
|
ndlp->nlp_DID, ELS_CMD_PRLI);
|
|
if (!elsiocb)
|
|
return 1;
|
|
|
|
icmd = &elsiocb->iocb;
|
|
pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
|
|
|
|
/* For PRLI request, remainder of payload is service parameters */
|
|
memset(pcmd, 0, (sizeof (PRLI) + sizeof (uint32_t)));
|
|
*((uint32_t *) (pcmd)) = ELS_CMD_PRLI;
|
|
pcmd += sizeof (uint32_t);
|
|
|
|
/* For PRLI, remainder of payload is PRLI parameter page */
|
|
npr = (PRLI *) pcmd;
|
|
/*
|
|
* If our firmware version is 3.20 or later,
|
|
* set the following bits for FC-TAPE support.
|
|
*/
|
|
if (phba->vpd.rev.feaLevelHigh >= 0x02) {
|
|
npr->ConfmComplAllowed = 1;
|
|
npr->Retry = 1;
|
|
npr->TaskRetryIdReq = 1;
|
|
}
|
|
npr->estabImagePair = 1;
|
|
npr->readXferRdyDis = 1;
|
|
|
|
/* For FCP support */
|
|
npr->prliType = PRLI_FCP_TYPE;
|
|
npr->initiatorFunc = 1;
|
|
|
|
phba->fc_stat.elsXmitPRLI++;
|
|
elsiocb->iocb_cmpl = lpfc_cmpl_els_prli;
|
|
spin_lock_irq(phba->host->host_lock);
|
|
ndlp->nlp_flag |= NLP_PRLI_SND;
|
|
if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
|
|
ndlp->nlp_flag &= ~NLP_PRLI_SND;
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
lpfc_els_free_iocb(phba, elsiocb);
|
|
return 1;
|
|
}
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
phba->fc_prli_sent++;
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
lpfc_more_adisc(struct lpfc_hba * phba)
|
|
{
|
|
int sentadisc;
|
|
|
|
if (phba->num_disc_nodes)
|
|
phba->num_disc_nodes--;
|
|
|
|
/* Continue discovery with <num_disc_nodes> ADISCs to go */
|
|
lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
|
|
"%d:0210 Continue discovery with %d ADISCs to go "
|
|
"Data: x%x x%x x%x\n",
|
|
phba->brd_no, phba->num_disc_nodes, phba->fc_adisc_cnt,
|
|
phba->fc_flag, phba->hba_state);
|
|
|
|
/* Check to see if there are more ADISCs to be sent */
|
|
if (phba->fc_flag & FC_NLP_MORE) {
|
|
lpfc_set_disctmo(phba);
|
|
|
|
/* go thru NPR list and issue any remaining ELS ADISCs */
|
|
sentadisc = lpfc_els_disc_adisc(phba);
|
|
}
|
|
return;
|
|
}
|
|
|
|
static void
|
|
lpfc_rscn_disc(struct lpfc_hba * phba)
|
|
{
|
|
/* RSCN discovery */
|
|
/* go thru NPR list and issue ELS PLOGIs */
|
|
if (phba->fc_npr_cnt) {
|
|
if (lpfc_els_disc_plogi(phba))
|
|
return;
|
|
}
|
|
if (phba->fc_flag & FC_RSCN_MODE) {
|
|
/* Check to see if more RSCNs came in while we were
|
|
* processing this one.
|
|
*/
|
|
if ((phba->fc_rscn_id_cnt == 0) &&
|
|
(!(phba->fc_flag & FC_RSCN_DISCOVERY))) {
|
|
spin_lock_irq(phba->host->host_lock);
|
|
phba->fc_flag &= ~FC_RSCN_MODE;
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
} else {
|
|
lpfc_els_handle_rscn(phba);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
lpfc_cmpl_els_adisc(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
|
|
struct lpfc_iocbq * rspiocb)
|
|
{
|
|
IOCB_t *irsp;
|
|
struct lpfc_sli *psli;
|
|
struct lpfc_nodelist *ndlp;
|
|
LPFC_MBOXQ_t *mbox;
|
|
int disc, rc;
|
|
|
|
psli = &phba->sli;
|
|
|
|
/* we pass cmdiocb to state machine which needs rspiocb as well */
|
|
cmdiocb->context_un.rsp_iocb = rspiocb;
|
|
|
|
irsp = &(rspiocb->iocb);
|
|
ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
|
|
|
|
/* Since ndlp can be freed in the disc state machine, note if this node
|
|
* is being used during discovery.
|
|
*/
|
|
disc = (ndlp->nlp_flag & NLP_NPR_2B_DISC);
|
|
spin_lock_irq(phba->host->host_lock);
|
|
ndlp->nlp_flag &= ~(NLP_ADISC_SND | NLP_NPR_2B_DISC);
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
|
|
/* ADISC completes to NPort <nlp_DID> */
|
|
lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
|
|
"%d:0104 ADISC completes to NPort x%x "
|
|
"Data: x%x x%x x%x x%x x%x\n",
|
|
phba->brd_no, ndlp->nlp_DID, irsp->ulpStatus,
|
|
irsp->un.ulpWord[4], irsp->ulpTimeout, disc,
|
|
phba->num_disc_nodes);
|
|
|
|
/* Check to see if link went down during discovery */
|
|
if (lpfc_els_chk_latt(phba)) {
|
|
spin_lock_irq(phba->host->host_lock);
|
|
ndlp->nlp_flag |= NLP_NPR_2B_DISC;
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
goto out;
|
|
}
|
|
|
|
if (irsp->ulpStatus) {
|
|
/* Check for retry */
|
|
if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
|
|
/* ELS command is being retried */
|
|
if (disc) {
|
|
spin_lock_irq(phba->host->host_lock);
|
|
ndlp->nlp_flag |= NLP_NPR_2B_DISC;
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
lpfc_set_disctmo(phba);
|
|
}
|
|
goto out;
|
|
}
|
|
/* ADISC failed */
|
|
/* Do not call DSM for lpfc_els_abort'ed ELS cmds */
|
|
if ((irsp->ulpStatus != IOSTAT_LOCAL_REJECT) ||
|
|
((irsp->un.ulpWord[4] != IOERR_SLI_ABORTED) &&
|
|
(irsp->un.ulpWord[4] != IOERR_LINK_DOWN) &&
|
|
(irsp->un.ulpWord[4] != IOERR_SLI_DOWN))) {
|
|
lpfc_disc_state_machine(phba, ndlp, cmdiocb,
|
|
NLP_EVT_CMPL_ADISC);
|
|
}
|
|
} else {
|
|
/* Good status, call state machine */
|
|
lpfc_disc_state_machine(phba, ndlp, cmdiocb,
|
|
NLP_EVT_CMPL_ADISC);
|
|
}
|
|
|
|
if (disc && phba->num_disc_nodes) {
|
|
/* Check to see if there are more ADISCs to be sent */
|
|
lpfc_more_adisc(phba);
|
|
|
|
/* Check to see if we are done with ADISC authentication */
|
|
if (phba->num_disc_nodes == 0) {
|
|
lpfc_can_disctmo(phba);
|
|
/* If we get here, there is nothing left to wait for */
|
|
if ((phba->hba_state < LPFC_HBA_READY) &&
|
|
(phba->hba_state != LPFC_CLEAR_LA)) {
|
|
/* Link up discovery */
|
|
if ((mbox = mempool_alloc(phba->mbox_mem_pool,
|
|
GFP_KERNEL))) {
|
|
phba->hba_state = LPFC_CLEAR_LA;
|
|
lpfc_clear_la(phba, mbox);
|
|
mbox->mbox_cmpl =
|
|
lpfc_mbx_cmpl_clear_la;
|
|
rc = lpfc_sli_issue_mbox
|
|
(phba, mbox,
|
|
(MBX_NOWAIT | MBX_STOP_IOCB));
|
|
if (rc == MBX_NOT_FINISHED) {
|
|
mempool_free(mbox,
|
|
phba->mbox_mem_pool);
|
|
lpfc_disc_flush_list(phba);
|
|
psli->ring[(psli->ip_ring)].
|
|
flag &=
|
|
~LPFC_STOP_IOCB_EVENT;
|
|
psli->ring[(psli->fcp_ring)].
|
|
flag &=
|
|
~LPFC_STOP_IOCB_EVENT;
|
|
psli->ring[(psli->next_ring)].
|
|
flag &=
|
|
~LPFC_STOP_IOCB_EVENT;
|
|
phba->hba_state =
|
|
LPFC_HBA_READY;
|
|
}
|
|
}
|
|
} else {
|
|
lpfc_rscn_disc(phba);
|
|
}
|
|
}
|
|
}
|
|
out:
|
|
lpfc_els_free_iocb(phba, cmdiocb);
|
|
return;
|
|
}
|
|
|
|
int
|
|
lpfc_issue_els_adisc(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp,
|
|
uint8_t retry)
|
|
{
|
|
ADISC *ap;
|
|
IOCB_t *icmd;
|
|
struct lpfc_iocbq *elsiocb;
|
|
struct lpfc_sli_ring *pring;
|
|
struct lpfc_sli *psli;
|
|
uint8_t *pcmd;
|
|
uint16_t cmdsize;
|
|
|
|
psli = &phba->sli;
|
|
pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
|
|
|
|
cmdsize = (sizeof (uint32_t) + sizeof (ADISC));
|
|
elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, ndlp,
|
|
ndlp->nlp_DID, ELS_CMD_ADISC);
|
|
if (!elsiocb)
|
|
return 1;
|
|
|
|
icmd = &elsiocb->iocb;
|
|
pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
|
|
|
|
/* For ADISC request, remainder of payload is service parameters */
|
|
*((uint32_t *) (pcmd)) = ELS_CMD_ADISC;
|
|
pcmd += sizeof (uint32_t);
|
|
|
|
/* Fill in ADISC payload */
|
|
ap = (ADISC *) pcmd;
|
|
ap->hardAL_PA = phba->fc_pref_ALPA;
|
|
memcpy(&ap->portName, &phba->fc_portname, sizeof (struct lpfc_name));
|
|
memcpy(&ap->nodeName, &phba->fc_nodename, sizeof (struct lpfc_name));
|
|
ap->DID = be32_to_cpu(phba->fc_myDID);
|
|
|
|
phba->fc_stat.elsXmitADISC++;
|
|
elsiocb->iocb_cmpl = lpfc_cmpl_els_adisc;
|
|
spin_lock_irq(phba->host->host_lock);
|
|
ndlp->nlp_flag |= NLP_ADISC_SND;
|
|
if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
|
|
ndlp->nlp_flag &= ~NLP_ADISC_SND;
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
lpfc_els_free_iocb(phba, elsiocb);
|
|
return 1;
|
|
}
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
lpfc_cmpl_els_logo(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
|
|
struct lpfc_iocbq * rspiocb)
|
|
{
|
|
IOCB_t *irsp;
|
|
struct lpfc_sli *psli;
|
|
struct lpfc_nodelist *ndlp;
|
|
|
|
psli = &phba->sli;
|
|
/* we pass cmdiocb to state machine which needs rspiocb as well */
|
|
cmdiocb->context_un.rsp_iocb = rspiocb;
|
|
|
|
irsp = &(rspiocb->iocb);
|
|
ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
|
|
spin_lock_irq(phba->host->host_lock);
|
|
ndlp->nlp_flag &= ~NLP_LOGO_SND;
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
|
|
/* LOGO completes to NPort <nlp_DID> */
|
|
lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
|
|
"%d:0105 LOGO completes to NPort x%x "
|
|
"Data: x%x x%x x%x x%x\n",
|
|
phba->brd_no, ndlp->nlp_DID, irsp->ulpStatus,
|
|
irsp->un.ulpWord[4], irsp->ulpTimeout,
|
|
phba->num_disc_nodes);
|
|
|
|
/* Check to see if link went down during discovery */
|
|
if (lpfc_els_chk_latt(phba))
|
|
goto out;
|
|
|
|
if (irsp->ulpStatus) {
|
|
/* Check for retry */
|
|
if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
|
|
/* ELS command is being retried */
|
|
goto out;
|
|
}
|
|
/* LOGO failed */
|
|
/* Do not call DSM for lpfc_els_abort'ed ELS cmds */
|
|
if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
|
|
((irsp->un.ulpWord[4] == IOERR_SLI_ABORTED) ||
|
|
(irsp->un.ulpWord[4] == IOERR_LINK_DOWN) ||
|
|
(irsp->un.ulpWord[4] == IOERR_SLI_DOWN))) {
|
|
goto out;
|
|
} else {
|
|
lpfc_disc_state_machine(phba, ndlp, cmdiocb,
|
|
NLP_EVT_CMPL_LOGO);
|
|
}
|
|
} else {
|
|
/* Good status, call state machine.
|
|
* This will unregister the rpi if needed.
|
|
*/
|
|
lpfc_disc_state_machine(phba, ndlp, cmdiocb, NLP_EVT_CMPL_LOGO);
|
|
}
|
|
|
|
out:
|
|
lpfc_els_free_iocb(phba, cmdiocb);
|
|
return;
|
|
}
|
|
|
|
int
|
|
lpfc_issue_els_logo(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp,
|
|
uint8_t retry)
|
|
{
|
|
IOCB_t *icmd;
|
|
struct lpfc_iocbq *elsiocb;
|
|
struct lpfc_sli_ring *pring;
|
|
struct lpfc_sli *psli;
|
|
uint8_t *pcmd;
|
|
uint16_t cmdsize;
|
|
|
|
psli = &phba->sli;
|
|
pring = &psli->ring[LPFC_ELS_RING];
|
|
|
|
cmdsize = (2 * sizeof (uint32_t)) + sizeof (struct lpfc_name);
|
|
elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, ndlp,
|
|
ndlp->nlp_DID, ELS_CMD_LOGO);
|
|
if (!elsiocb)
|
|
return 1;
|
|
|
|
icmd = &elsiocb->iocb;
|
|
pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
|
|
*((uint32_t *) (pcmd)) = ELS_CMD_LOGO;
|
|
pcmd += sizeof (uint32_t);
|
|
|
|
/* Fill in LOGO payload */
|
|
*((uint32_t *) (pcmd)) = be32_to_cpu(phba->fc_myDID);
|
|
pcmd += sizeof (uint32_t);
|
|
memcpy(pcmd, &phba->fc_portname, sizeof (struct lpfc_name));
|
|
|
|
phba->fc_stat.elsXmitLOGO++;
|
|
elsiocb->iocb_cmpl = lpfc_cmpl_els_logo;
|
|
spin_lock_irq(phba->host->host_lock);
|
|
ndlp->nlp_flag |= NLP_LOGO_SND;
|
|
if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
|
|
ndlp->nlp_flag &= ~NLP_LOGO_SND;
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
lpfc_els_free_iocb(phba, elsiocb);
|
|
return 1;
|
|
}
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
lpfc_cmpl_els_cmd(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
|
|
struct lpfc_iocbq * rspiocb)
|
|
{
|
|
IOCB_t *irsp;
|
|
|
|
irsp = &rspiocb->iocb;
|
|
|
|
/* ELS cmd tag <ulpIoTag> completes */
|
|
lpfc_printf_log(phba,
|
|
KERN_INFO,
|
|
LOG_ELS,
|
|
"%d:0106 ELS cmd tag x%x completes Data: x%x x%x x%x\n",
|
|
phba->brd_no,
|
|
irsp->ulpIoTag, irsp->ulpStatus,
|
|
irsp->un.ulpWord[4], irsp->ulpTimeout);
|
|
|
|
/* Check to see if link went down during discovery */
|
|
lpfc_els_chk_latt(phba);
|
|
lpfc_els_free_iocb(phba, cmdiocb);
|
|
return;
|
|
}
|
|
|
|
int
|
|
lpfc_issue_els_scr(struct lpfc_hba * phba, uint32_t nportid, uint8_t retry)
|
|
{
|
|
IOCB_t *icmd;
|
|
struct lpfc_iocbq *elsiocb;
|
|
struct lpfc_sli_ring *pring;
|
|
struct lpfc_sli *psli;
|
|
uint8_t *pcmd;
|
|
uint16_t cmdsize;
|
|
struct lpfc_nodelist *ndlp;
|
|
|
|
psli = &phba->sli;
|
|
pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
|
|
cmdsize = (sizeof (uint32_t) + sizeof (SCR));
|
|
ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
|
|
if (!ndlp)
|
|
return 1;
|
|
|
|
lpfc_nlp_init(phba, ndlp, nportid);
|
|
|
|
elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, ndlp,
|
|
ndlp->nlp_DID, ELS_CMD_SCR);
|
|
if (!elsiocb) {
|
|
mempool_free( ndlp, phba->nlp_mem_pool);
|
|
return 1;
|
|
}
|
|
|
|
icmd = &elsiocb->iocb;
|
|
pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
|
|
|
|
*((uint32_t *) (pcmd)) = ELS_CMD_SCR;
|
|
pcmd += sizeof (uint32_t);
|
|
|
|
/* For SCR, remainder of payload is SCR parameter page */
|
|
memset(pcmd, 0, sizeof (SCR));
|
|
((SCR *) pcmd)->Function = SCR_FUNC_FULL;
|
|
|
|
phba->fc_stat.elsXmitSCR++;
|
|
elsiocb->iocb_cmpl = lpfc_cmpl_els_cmd;
|
|
spin_lock_irq(phba->host->host_lock);
|
|
if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
mempool_free( ndlp, phba->nlp_mem_pool);
|
|
lpfc_els_free_iocb(phba, elsiocb);
|
|
return 1;
|
|
}
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
mempool_free( ndlp, phba->nlp_mem_pool);
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
lpfc_issue_els_farpr(struct lpfc_hba * phba, uint32_t nportid, uint8_t retry)
|
|
{
|
|
IOCB_t *icmd;
|
|
struct lpfc_iocbq *elsiocb;
|
|
struct lpfc_sli_ring *pring;
|
|
struct lpfc_sli *psli;
|
|
FARP *fp;
|
|
uint8_t *pcmd;
|
|
uint32_t *lp;
|
|
uint16_t cmdsize;
|
|
struct lpfc_nodelist *ondlp;
|
|
struct lpfc_nodelist *ndlp;
|
|
|
|
psli = &phba->sli;
|
|
pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
|
|
cmdsize = (sizeof (uint32_t) + sizeof (FARP));
|
|
ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
|
|
if (!ndlp)
|
|
return 1;
|
|
lpfc_nlp_init(phba, ndlp, nportid);
|
|
|
|
elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, ndlp,
|
|
ndlp->nlp_DID, ELS_CMD_RNID);
|
|
if (!elsiocb) {
|
|
mempool_free( ndlp, phba->nlp_mem_pool);
|
|
return 1;
|
|
}
|
|
|
|
icmd = &elsiocb->iocb;
|
|
pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
|
|
|
|
*((uint32_t *) (pcmd)) = ELS_CMD_FARPR;
|
|
pcmd += sizeof (uint32_t);
|
|
|
|
/* Fill in FARPR payload */
|
|
fp = (FARP *) (pcmd);
|
|
memset(fp, 0, sizeof (FARP));
|
|
lp = (uint32_t *) pcmd;
|
|
*lp++ = be32_to_cpu(nportid);
|
|
*lp++ = be32_to_cpu(phba->fc_myDID);
|
|
fp->Rflags = 0;
|
|
fp->Mflags = (FARP_MATCH_PORT | FARP_MATCH_NODE);
|
|
|
|
memcpy(&fp->RportName, &phba->fc_portname, sizeof (struct lpfc_name));
|
|
memcpy(&fp->RnodeName, &phba->fc_nodename, sizeof (struct lpfc_name));
|
|
if ((ondlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, nportid))) {
|
|
memcpy(&fp->OportName, &ondlp->nlp_portname,
|
|
sizeof (struct lpfc_name));
|
|
memcpy(&fp->OnodeName, &ondlp->nlp_nodename,
|
|
sizeof (struct lpfc_name));
|
|
}
|
|
|
|
phba->fc_stat.elsXmitFARPR++;
|
|
elsiocb->iocb_cmpl = lpfc_cmpl_els_cmd;
|
|
spin_lock_irq(phba->host->host_lock);
|
|
if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
mempool_free( ndlp, phba->nlp_mem_pool);
|
|
lpfc_els_free_iocb(phba, elsiocb);
|
|
return 1;
|
|
}
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
mempool_free( ndlp, phba->nlp_mem_pool);
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
lpfc_cancel_retry_delay_tmo(struct lpfc_hba *phba, struct lpfc_nodelist * nlp)
|
|
{
|
|
nlp->nlp_flag &= ~NLP_DELAY_TMO;
|
|
del_timer_sync(&nlp->nlp_delayfunc);
|
|
nlp->nlp_last_elscmd = 0;
|
|
|
|
if (!list_empty(&nlp->els_retry_evt.evt_listp))
|
|
list_del_init(&nlp->els_retry_evt.evt_listp);
|
|
|
|
if (nlp->nlp_flag & NLP_NPR_2B_DISC) {
|
|
nlp->nlp_flag &= ~NLP_NPR_2B_DISC;
|
|
if (phba->num_disc_nodes) {
|
|
/* Check to see if there are more
|
|
* PLOGIs to be sent
|
|
*/
|
|
lpfc_more_plogi(phba);
|
|
|
|
if (phba->num_disc_nodes == 0) {
|
|
phba->fc_flag &= ~FC_NDISC_ACTIVE;
|
|
lpfc_can_disctmo(phba);
|
|
if (phba->fc_flag & FC_RSCN_MODE) {
|
|
/*
|
|
* Check to see if more RSCNs
|
|
* came in while we were
|
|
* processing this one.
|
|
*/
|
|
if((phba->fc_rscn_id_cnt==0) &&
|
|
!(phba->fc_flag & FC_RSCN_DISCOVERY)) {
|
|
phba->fc_flag &= ~FC_RSCN_MODE;
|
|
}
|
|
else {
|
|
lpfc_els_handle_rscn(phba);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
void
|
|
lpfc_els_retry_delay(unsigned long ptr)
|
|
{
|
|
struct lpfc_nodelist *ndlp;
|
|
struct lpfc_hba *phba;
|
|
unsigned long iflag;
|
|
struct lpfc_work_evt *evtp;
|
|
|
|
ndlp = (struct lpfc_nodelist *)ptr;
|
|
phba = ndlp->nlp_phba;
|
|
evtp = &ndlp->els_retry_evt;
|
|
|
|
spin_lock_irqsave(phba->host->host_lock, iflag);
|
|
if (!list_empty(&evtp->evt_listp)) {
|
|
spin_unlock_irqrestore(phba->host->host_lock, iflag);
|
|
return;
|
|
}
|
|
|
|
evtp->evt_arg1 = ndlp;
|
|
evtp->evt = LPFC_EVT_ELS_RETRY;
|
|
list_add_tail(&evtp->evt_listp, &phba->work_list);
|
|
if (phba->work_wait)
|
|
wake_up(phba->work_wait);
|
|
|
|
spin_unlock_irqrestore(phba->host->host_lock, iflag);
|
|
return;
|
|
}
|
|
|
|
void
|
|
lpfc_els_retry_delay_handler(struct lpfc_nodelist *ndlp)
|
|
{
|
|
struct lpfc_hba *phba;
|
|
uint32_t cmd;
|
|
uint32_t did;
|
|
uint8_t retry;
|
|
|
|
phba = ndlp->nlp_phba;
|
|
spin_lock_irq(phba->host->host_lock);
|
|
did = ndlp->nlp_DID;
|
|
cmd = ndlp->nlp_last_elscmd;
|
|
ndlp->nlp_last_elscmd = 0;
|
|
|
|
if (!(ndlp->nlp_flag & NLP_DELAY_TMO)) {
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
return;
|
|
}
|
|
|
|
ndlp->nlp_flag &= ~NLP_DELAY_TMO;
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
/*
|
|
* If a discovery event readded nlp_delayfunc after timer
|
|
* firing and before processing the timer, cancel the
|
|
* nlp_delayfunc.
|
|
*/
|
|
del_timer_sync(&ndlp->nlp_delayfunc);
|
|
retry = ndlp->nlp_retry;
|
|
|
|
switch (cmd) {
|
|
case ELS_CMD_FLOGI:
|
|
lpfc_issue_els_flogi(phba, ndlp, retry);
|
|
break;
|
|
case ELS_CMD_PLOGI:
|
|
if(!lpfc_issue_els_plogi(phba, ndlp->nlp_DID, retry)) {
|
|
ndlp->nlp_prev_state = ndlp->nlp_state;
|
|
ndlp->nlp_state = NLP_STE_PLOGI_ISSUE;
|
|
lpfc_nlp_list(phba, ndlp, NLP_PLOGI_LIST);
|
|
}
|
|
break;
|
|
case ELS_CMD_ADISC:
|
|
if (!lpfc_issue_els_adisc(phba, ndlp, retry)) {
|
|
ndlp->nlp_prev_state = ndlp->nlp_state;
|
|
ndlp->nlp_state = NLP_STE_ADISC_ISSUE;
|
|
lpfc_nlp_list(phba, ndlp, NLP_ADISC_LIST);
|
|
}
|
|
break;
|
|
case ELS_CMD_PRLI:
|
|
if (!lpfc_issue_els_prli(phba, ndlp, retry)) {
|
|
ndlp->nlp_prev_state = ndlp->nlp_state;
|
|
ndlp->nlp_state = NLP_STE_PRLI_ISSUE;
|
|
lpfc_nlp_list(phba, ndlp, NLP_PRLI_LIST);
|
|
}
|
|
break;
|
|
case ELS_CMD_LOGO:
|
|
if (!lpfc_issue_els_logo(phba, ndlp, retry)) {
|
|
ndlp->nlp_prev_state = ndlp->nlp_state;
|
|
ndlp->nlp_state = NLP_STE_NPR_NODE;
|
|
lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST);
|
|
}
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
|
|
static int
|
|
lpfc_els_retry(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
|
|
struct lpfc_iocbq * rspiocb)
|
|
{
|
|
IOCB_t *irsp;
|
|
struct lpfc_dmabuf *pcmd;
|
|
struct lpfc_nodelist *ndlp;
|
|
uint32_t *elscmd;
|
|
struct ls_rjt stat;
|
|
int retry, maxretry;
|
|
int delay;
|
|
uint32_t cmd;
|
|
uint32_t did;
|
|
|
|
retry = 0;
|
|
delay = 0;
|
|
maxretry = lpfc_max_els_tries;
|
|
irsp = &rspiocb->iocb;
|
|
ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
|
|
pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
|
|
cmd = 0;
|
|
|
|
/* Note: context2 may be 0 for internal driver abort
|
|
* of delays ELS command.
|
|
*/
|
|
|
|
if (pcmd && pcmd->virt) {
|
|
elscmd = (uint32_t *) (pcmd->virt);
|
|
cmd = *elscmd++;
|
|
}
|
|
|
|
if(ndlp)
|
|
did = ndlp->nlp_DID;
|
|
else {
|
|
/* We should only hit this case for retrying PLOGI */
|
|
did = irsp->un.elsreq64.remoteID;
|
|
ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, did);
|
|
if (!ndlp && (cmd != ELS_CMD_PLOGI))
|
|
return 1;
|
|
}
|
|
|
|
switch (irsp->ulpStatus) {
|
|
case IOSTAT_FCP_RSP_ERROR:
|
|
case IOSTAT_REMOTE_STOP:
|
|
break;
|
|
|
|
case IOSTAT_LOCAL_REJECT:
|
|
switch ((irsp->un.ulpWord[4] & 0xff)) {
|
|
case IOERR_LOOP_OPEN_FAILURE:
|
|
if (cmd == ELS_CMD_PLOGI) {
|
|
if (cmdiocb->retry == 0) {
|
|
delay = 1;
|
|
}
|
|
}
|
|
retry = 1;
|
|
break;
|
|
|
|
case IOERR_SEQUENCE_TIMEOUT:
|
|
retry = 1;
|
|
break;
|
|
|
|
case IOERR_NO_RESOURCES:
|
|
if (cmd == ELS_CMD_PLOGI) {
|
|
delay = 1;
|
|
}
|
|
retry = 1;
|
|
break;
|
|
|
|
case IOERR_INVALID_RPI:
|
|
retry = 1;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case IOSTAT_NPORT_RJT:
|
|
case IOSTAT_FABRIC_RJT:
|
|
if (irsp->un.ulpWord[4] & RJT_UNAVAIL_TEMP) {
|
|
retry = 1;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case IOSTAT_NPORT_BSY:
|
|
case IOSTAT_FABRIC_BSY:
|
|
retry = 1;
|
|
break;
|
|
|
|
case IOSTAT_LS_RJT:
|
|
stat.un.lsRjtError = be32_to_cpu(irsp->un.ulpWord[4]);
|
|
/* Added for Vendor specifc support
|
|
* Just keep retrying for these Rsn / Exp codes
|
|
*/
|
|
switch (stat.un.b.lsRjtRsnCode) {
|
|
case LSRJT_UNABLE_TPC:
|
|
if (stat.un.b.lsRjtRsnCodeExp ==
|
|
LSEXP_CMD_IN_PROGRESS) {
|
|
if (cmd == ELS_CMD_PLOGI) {
|
|
delay = 1;
|
|
maxretry = 48;
|
|
}
|
|
retry = 1;
|
|
break;
|
|
}
|
|
if (cmd == ELS_CMD_PLOGI) {
|
|
delay = 1;
|
|
maxretry = lpfc_max_els_tries + 1;
|
|
retry = 1;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case LSRJT_LOGICAL_BSY:
|
|
if (cmd == ELS_CMD_PLOGI) {
|
|
delay = 1;
|
|
maxretry = 48;
|
|
}
|
|
retry = 1;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case IOSTAT_INTERMED_RSP:
|
|
case IOSTAT_BA_RJT:
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (did == FDMI_DID)
|
|
retry = 1;
|
|
|
|
if ((++cmdiocb->retry) >= maxretry) {
|
|
phba->fc_stat.elsRetryExceeded++;
|
|
retry = 0;
|
|
}
|
|
|
|
if (retry) {
|
|
|
|
/* Retry ELS command <elsCmd> to remote NPORT <did> */
|
|
lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
|
|
"%d:0107 Retry ELS command x%x to remote "
|
|
"NPORT x%x Data: x%x x%x\n",
|
|
phba->brd_no,
|
|
cmd, did, cmdiocb->retry, delay);
|
|
|
|
if ((cmd == ELS_CMD_PLOGI) || (cmd == ELS_CMD_ADISC)) {
|
|
/* If discovery / RSCN timer is running, reset it */
|
|
if (timer_pending(&phba->fc_disctmo) ||
|
|
(phba->fc_flag & FC_RSCN_MODE)) {
|
|
lpfc_set_disctmo(phba);
|
|
}
|
|
}
|
|
|
|
phba->fc_stat.elsXmitRetry++;
|
|
if (ndlp && delay) {
|
|
phba->fc_stat.elsDelayRetry++;
|
|
ndlp->nlp_retry = cmdiocb->retry;
|
|
|
|
mod_timer(&ndlp->nlp_delayfunc, jiffies + HZ);
|
|
ndlp->nlp_flag |= NLP_DELAY_TMO;
|
|
|
|
ndlp->nlp_prev_state = ndlp->nlp_state;
|
|
ndlp->nlp_state = NLP_STE_NPR_NODE;
|
|
lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST);
|
|
ndlp->nlp_last_elscmd = cmd;
|
|
|
|
return 1;
|
|
}
|
|
switch (cmd) {
|
|
case ELS_CMD_FLOGI:
|
|
lpfc_issue_els_flogi(phba, ndlp, cmdiocb->retry);
|
|
return 1;
|
|
case ELS_CMD_PLOGI:
|
|
if (ndlp) {
|
|
ndlp->nlp_prev_state = ndlp->nlp_state;
|
|
ndlp->nlp_state = NLP_STE_PLOGI_ISSUE;
|
|
lpfc_nlp_list(phba, ndlp, NLP_PLOGI_LIST);
|
|
}
|
|
lpfc_issue_els_plogi(phba, did, cmdiocb->retry);
|
|
return 1;
|
|
case ELS_CMD_ADISC:
|
|
ndlp->nlp_prev_state = ndlp->nlp_state;
|
|
ndlp->nlp_state = NLP_STE_ADISC_ISSUE;
|
|
lpfc_nlp_list(phba, ndlp, NLP_ADISC_LIST);
|
|
lpfc_issue_els_adisc(phba, ndlp, cmdiocb->retry);
|
|
return 1;
|
|
case ELS_CMD_PRLI:
|
|
ndlp->nlp_prev_state = ndlp->nlp_state;
|
|
ndlp->nlp_state = NLP_STE_PRLI_ISSUE;
|
|
lpfc_nlp_list(phba, ndlp, NLP_PRLI_LIST);
|
|
lpfc_issue_els_prli(phba, ndlp, cmdiocb->retry);
|
|
return 1;
|
|
case ELS_CMD_LOGO:
|
|
ndlp->nlp_prev_state = ndlp->nlp_state;
|
|
ndlp->nlp_state = NLP_STE_NPR_NODE;
|
|
lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST);
|
|
lpfc_issue_els_logo(phba, ndlp, cmdiocb->retry);
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
/* No retry ELS command <elsCmd> to remote NPORT <did> */
|
|
lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
|
|
"%d:0108 No retry ELS command x%x to remote NPORT x%x "
|
|
"Data: x%x\n",
|
|
phba->brd_no,
|
|
cmd, did, cmdiocb->retry);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
lpfc_els_free_iocb(struct lpfc_hba * phba, struct lpfc_iocbq * elsiocb)
|
|
{
|
|
struct lpfc_dmabuf *buf_ptr, *buf_ptr1;
|
|
|
|
/* context2 = cmd, context2->next = rsp, context3 = bpl */
|
|
if (elsiocb->context2) {
|
|
buf_ptr1 = (struct lpfc_dmabuf *) elsiocb->context2;
|
|
/* Free the response before processing the command. */
|
|
if (!list_empty(&buf_ptr1->list)) {
|
|
list_remove_head(&buf_ptr1->list, buf_ptr,
|
|
struct lpfc_dmabuf,
|
|
list);
|
|
lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
|
|
kfree(buf_ptr);
|
|
}
|
|
lpfc_mbuf_free(phba, buf_ptr1->virt, buf_ptr1->phys);
|
|
kfree(buf_ptr1);
|
|
}
|
|
|
|
if (elsiocb->context3) {
|
|
buf_ptr = (struct lpfc_dmabuf *) elsiocb->context3;
|
|
lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
|
|
kfree(buf_ptr);
|
|
}
|
|
spin_lock_irq(phba->host->host_lock);
|
|
lpfc_sli_release_iocbq(phba, elsiocb);
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
lpfc_cmpl_els_logo_acc(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
|
|
struct lpfc_iocbq * rspiocb)
|
|
{
|
|
struct lpfc_nodelist *ndlp;
|
|
|
|
ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
|
|
|
|
/* ACC to LOGO completes to NPort <nlp_DID> */
|
|
lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
|
|
"%d:0109 ACC to LOGO completes to NPort x%x "
|
|
"Data: x%x x%x x%x\n",
|
|
phba->brd_no, ndlp->nlp_DID, ndlp->nlp_flag,
|
|
ndlp->nlp_state, ndlp->nlp_rpi);
|
|
|
|
switch (ndlp->nlp_state) {
|
|
case NLP_STE_UNUSED_NODE: /* node is just allocated */
|
|
lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
|
|
break;
|
|
case NLP_STE_NPR_NODE: /* NPort Recovery mode */
|
|
lpfc_unreg_rpi(phba, ndlp);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
lpfc_els_free_iocb(phba, cmdiocb);
|
|
return;
|
|
}
|
|
|
|
static void
|
|
lpfc_cmpl_els_acc(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
|
|
struct lpfc_iocbq * rspiocb)
|
|
{
|
|
IOCB_t *irsp;
|
|
struct lpfc_nodelist *ndlp;
|
|
LPFC_MBOXQ_t *mbox = NULL;
|
|
|
|
irsp = &rspiocb->iocb;
|
|
|
|
ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
|
|
if (cmdiocb->context_un.mbox)
|
|
mbox = cmdiocb->context_un.mbox;
|
|
|
|
|
|
/* Check to see if link went down during discovery */
|
|
if ((lpfc_els_chk_latt(phba)) || !ndlp) {
|
|
if (mbox) {
|
|
mempool_free( mbox, phba->mbox_mem_pool);
|
|
}
|
|
goto out;
|
|
}
|
|
|
|
/* ELS response tag <ulpIoTag> completes */
|
|
lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
|
|
"%d:0110 ELS response tag x%x completes "
|
|
"Data: x%x x%x x%x x%x x%x x%x x%x\n",
|
|
phba->brd_no,
|
|
cmdiocb->iocb.ulpIoTag, rspiocb->iocb.ulpStatus,
|
|
rspiocb->iocb.un.ulpWord[4], rspiocb->iocb.ulpTimeout,
|
|
ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_state,
|
|
ndlp->nlp_rpi);
|
|
|
|
if (mbox) {
|
|
if ((rspiocb->iocb.ulpStatus == 0)
|
|
&& (ndlp->nlp_flag & NLP_ACC_REGLOGIN)) {
|
|
lpfc_unreg_rpi(phba, ndlp);
|
|
mbox->mbox_cmpl = lpfc_mbx_cmpl_reg_login;
|
|
mbox->context2 = ndlp;
|
|
ndlp->nlp_prev_state = ndlp->nlp_state;
|
|
ndlp->nlp_state = NLP_STE_REG_LOGIN_ISSUE;
|
|
lpfc_nlp_list(phba, ndlp, NLP_REGLOGIN_LIST);
|
|
if (lpfc_sli_issue_mbox(phba, mbox,
|
|
(MBX_NOWAIT | MBX_STOP_IOCB))
|
|
!= MBX_NOT_FINISHED) {
|
|
goto out;
|
|
}
|
|
/* NOTE: we should have messages for unsuccessful
|
|
reglogin */
|
|
mempool_free( mbox, phba->mbox_mem_pool);
|
|
} else {
|
|
mempool_free( mbox, phba->mbox_mem_pool);
|
|
/* Do not call NO_LIST for lpfc_els_abort'ed ELS cmds */
|
|
if (!((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
|
|
((irsp->un.ulpWord[4] == IOERR_SLI_ABORTED) ||
|
|
(irsp->un.ulpWord[4] == IOERR_LINK_DOWN) ||
|
|
(irsp->un.ulpWord[4] == IOERR_SLI_DOWN)))) {
|
|
if (ndlp->nlp_flag & NLP_ACC_REGLOGIN) {
|
|
lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
|
|
ndlp = NULL;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
out:
|
|
if (ndlp) {
|
|
spin_lock_irq(phba->host->host_lock);
|
|
ndlp->nlp_flag &= ~NLP_ACC_REGLOGIN;
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
}
|
|
lpfc_els_free_iocb(phba, cmdiocb);
|
|
return;
|
|
}
|
|
|
|
int
|
|
lpfc_els_rsp_acc(struct lpfc_hba * phba, uint32_t flag,
|
|
struct lpfc_iocbq * oldiocb, struct lpfc_nodelist * ndlp,
|
|
LPFC_MBOXQ_t * mbox, uint8_t newnode)
|
|
{
|
|
IOCB_t *icmd;
|
|
IOCB_t *oldcmd;
|
|
struct lpfc_iocbq *elsiocb;
|
|
struct lpfc_sli_ring *pring;
|
|
struct lpfc_sli *psli;
|
|
uint8_t *pcmd;
|
|
uint16_t cmdsize;
|
|
int rc;
|
|
ELS_PKT *els_pkt_ptr;
|
|
|
|
psli = &phba->sli;
|
|
pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
|
|
oldcmd = &oldiocb->iocb;
|
|
|
|
switch (flag) {
|
|
case ELS_CMD_ACC:
|
|
cmdsize = sizeof (uint32_t);
|
|
elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry,
|
|
ndlp, ndlp->nlp_DID, ELS_CMD_ACC);
|
|
if (!elsiocb) {
|
|
ndlp->nlp_flag &= ~NLP_LOGO_ACC;
|
|
return 1;
|
|
}
|
|
icmd = &elsiocb->iocb;
|
|
icmd->ulpContext = oldcmd->ulpContext; /* Xri */
|
|
pcmd = (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
|
|
*((uint32_t *) (pcmd)) = ELS_CMD_ACC;
|
|
pcmd += sizeof (uint32_t);
|
|
break;
|
|
case ELS_CMD_PLOGI:
|
|
cmdsize = (sizeof (struct serv_parm) + sizeof (uint32_t));
|
|
elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry,
|
|
ndlp, ndlp->nlp_DID, ELS_CMD_ACC);
|
|
if (!elsiocb)
|
|
return 1;
|
|
|
|
icmd = &elsiocb->iocb;
|
|
icmd->ulpContext = oldcmd->ulpContext; /* Xri */
|
|
pcmd = (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
|
|
|
|
if (mbox)
|
|
elsiocb->context_un.mbox = mbox;
|
|
|
|
*((uint32_t *) (pcmd)) = ELS_CMD_ACC;
|
|
pcmd += sizeof (uint32_t);
|
|
memcpy(pcmd, &phba->fc_sparam, sizeof (struct serv_parm));
|
|
break;
|
|
case ELS_CMD_PRLO:
|
|
cmdsize = sizeof (uint32_t) + sizeof (PRLO);
|
|
elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry,
|
|
ndlp, ndlp->nlp_DID, ELS_CMD_PRLO);
|
|
if (!elsiocb)
|
|
return 1;
|
|
|
|
icmd = &elsiocb->iocb;
|
|
icmd->ulpContext = oldcmd->ulpContext; /* Xri */
|
|
pcmd = (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
|
|
|
|
memcpy(pcmd, ((struct lpfc_dmabuf *) oldiocb->context2)->virt,
|
|
sizeof (uint32_t) + sizeof (PRLO));
|
|
*((uint32_t *) (pcmd)) = ELS_CMD_PRLO_ACC;
|
|
els_pkt_ptr = (ELS_PKT *) pcmd;
|
|
els_pkt_ptr->un.prlo.acceptRspCode = PRLO_REQ_EXECUTED;
|
|
break;
|
|
default:
|
|
return 1;
|
|
}
|
|
|
|
if (newnode)
|
|
elsiocb->context1 = NULL;
|
|
|
|
/* Xmit ELS ACC response tag <ulpIoTag> */
|
|
lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
|
|
"%d:0128 Xmit ELS ACC response tag x%x "
|
|
"Data: x%x x%x x%x x%x x%x\n",
|
|
phba->brd_no,
|
|
elsiocb->iocb.ulpIoTag,
|
|
elsiocb->iocb.ulpContext, ndlp->nlp_DID,
|
|
ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi);
|
|
|
|
if (ndlp->nlp_flag & NLP_LOGO_ACC) {
|
|
spin_lock_irq(phba->host->host_lock);
|
|
ndlp->nlp_flag &= ~NLP_LOGO_ACC;
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
elsiocb->iocb_cmpl = lpfc_cmpl_els_logo_acc;
|
|
} else {
|
|
elsiocb->iocb_cmpl = lpfc_cmpl_els_acc;
|
|
}
|
|
|
|
phba->fc_stat.elsXmitACC++;
|
|
spin_lock_irq(phba->host->host_lock);
|
|
rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
if (rc == IOCB_ERROR) {
|
|
lpfc_els_free_iocb(phba, elsiocb);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
lpfc_els_rsp_reject(struct lpfc_hba * phba, uint32_t rejectError,
|
|
struct lpfc_iocbq * oldiocb, struct lpfc_nodelist * ndlp)
|
|
{
|
|
IOCB_t *icmd;
|
|
IOCB_t *oldcmd;
|
|
struct lpfc_iocbq *elsiocb;
|
|
struct lpfc_sli_ring *pring;
|
|
struct lpfc_sli *psli;
|
|
uint8_t *pcmd;
|
|
uint16_t cmdsize;
|
|
int rc;
|
|
|
|
psli = &phba->sli;
|
|
pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
|
|
|
|
cmdsize = 2 * sizeof (uint32_t);
|
|
elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry,
|
|
ndlp, ndlp->nlp_DID, ELS_CMD_LS_RJT);
|
|
if (!elsiocb)
|
|
return 1;
|
|
|
|
icmd = &elsiocb->iocb;
|
|
oldcmd = &oldiocb->iocb;
|
|
icmd->ulpContext = oldcmd->ulpContext; /* Xri */
|
|
pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
|
|
|
|
*((uint32_t *) (pcmd)) = ELS_CMD_LS_RJT;
|
|
pcmd += sizeof (uint32_t);
|
|
*((uint32_t *) (pcmd)) = rejectError;
|
|
|
|
/* Xmit ELS RJT <err> response tag <ulpIoTag> */
|
|
lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
|
|
"%d:0129 Xmit ELS RJT x%x response tag x%x "
|
|
"Data: x%x x%x x%x x%x x%x\n",
|
|
phba->brd_no,
|
|
rejectError, elsiocb->iocb.ulpIoTag,
|
|
elsiocb->iocb.ulpContext, ndlp->nlp_DID,
|
|
ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi);
|
|
|
|
phba->fc_stat.elsXmitLSRJT++;
|
|
elsiocb->iocb_cmpl = lpfc_cmpl_els_acc;
|
|
spin_lock_irq(phba->host->host_lock);
|
|
rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
if (rc == IOCB_ERROR) {
|
|
lpfc_els_free_iocb(phba, elsiocb);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
lpfc_els_rsp_adisc_acc(struct lpfc_hba * phba,
|
|
struct lpfc_iocbq * oldiocb, struct lpfc_nodelist * ndlp)
|
|
{
|
|
ADISC *ap;
|
|
IOCB_t *icmd;
|
|
IOCB_t *oldcmd;
|
|
struct lpfc_iocbq *elsiocb;
|
|
struct lpfc_sli_ring *pring;
|
|
struct lpfc_sli *psli;
|
|
uint8_t *pcmd;
|
|
uint16_t cmdsize;
|
|
int rc;
|
|
|
|
psli = &phba->sli;
|
|
pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
|
|
|
|
cmdsize = sizeof (uint32_t) + sizeof (ADISC);
|
|
elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry,
|
|
ndlp, ndlp->nlp_DID, ELS_CMD_ACC);
|
|
if (!elsiocb)
|
|
return 1;
|
|
|
|
/* Xmit ADISC ACC response tag <ulpIoTag> */
|
|
lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
|
|
"%d:0130 Xmit ADISC ACC response tag x%x "
|
|
"Data: x%x x%x x%x x%x x%x\n",
|
|
phba->brd_no,
|
|
elsiocb->iocb.ulpIoTag,
|
|
elsiocb->iocb.ulpContext, ndlp->nlp_DID,
|
|
ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi);
|
|
|
|
icmd = &elsiocb->iocb;
|
|
oldcmd = &oldiocb->iocb;
|
|
icmd->ulpContext = oldcmd->ulpContext; /* Xri */
|
|
pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
|
|
|
|
*((uint32_t *) (pcmd)) = ELS_CMD_ACC;
|
|
pcmd += sizeof (uint32_t);
|
|
|
|
ap = (ADISC *) (pcmd);
|
|
ap->hardAL_PA = phba->fc_pref_ALPA;
|
|
memcpy(&ap->portName, &phba->fc_portname, sizeof (struct lpfc_name));
|
|
memcpy(&ap->nodeName, &phba->fc_nodename, sizeof (struct lpfc_name));
|
|
ap->DID = be32_to_cpu(phba->fc_myDID);
|
|
|
|
phba->fc_stat.elsXmitACC++;
|
|
elsiocb->iocb_cmpl = lpfc_cmpl_els_acc;
|
|
spin_lock_irq(phba->host->host_lock);
|
|
rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
if (rc == IOCB_ERROR) {
|
|
lpfc_els_free_iocb(phba, elsiocb);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
lpfc_els_rsp_prli_acc(struct lpfc_hba * phba,
|
|
struct lpfc_iocbq * oldiocb, struct lpfc_nodelist * ndlp)
|
|
{
|
|
PRLI *npr;
|
|
lpfc_vpd_t *vpd;
|
|
IOCB_t *icmd;
|
|
IOCB_t *oldcmd;
|
|
struct lpfc_iocbq *elsiocb;
|
|
struct lpfc_sli_ring *pring;
|
|
struct lpfc_sli *psli;
|
|
uint8_t *pcmd;
|
|
uint16_t cmdsize;
|
|
int rc;
|
|
|
|
psli = &phba->sli;
|
|
pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
|
|
|
|
cmdsize = sizeof (uint32_t) + sizeof (PRLI);
|
|
elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry, ndlp,
|
|
ndlp->nlp_DID, (ELS_CMD_ACC | (ELS_CMD_PRLI & ~ELS_RSP_MASK)));
|
|
if (!elsiocb)
|
|
return 1;
|
|
|
|
/* Xmit PRLI ACC response tag <ulpIoTag> */
|
|
lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
|
|
"%d:0131 Xmit PRLI ACC response tag x%x "
|
|
"Data: x%x x%x x%x x%x x%x\n",
|
|
phba->brd_no,
|
|
elsiocb->iocb.ulpIoTag,
|
|
elsiocb->iocb.ulpContext, ndlp->nlp_DID,
|
|
ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi);
|
|
|
|
icmd = &elsiocb->iocb;
|
|
oldcmd = &oldiocb->iocb;
|
|
icmd->ulpContext = oldcmd->ulpContext; /* Xri */
|
|
pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
|
|
|
|
*((uint32_t *) (pcmd)) = (ELS_CMD_ACC | (ELS_CMD_PRLI & ~ELS_RSP_MASK));
|
|
pcmd += sizeof (uint32_t);
|
|
|
|
/* For PRLI, remainder of payload is PRLI parameter page */
|
|
memset(pcmd, 0, sizeof (PRLI));
|
|
|
|
npr = (PRLI *) pcmd;
|
|
vpd = &phba->vpd;
|
|
/*
|
|
* If our firmware version is 3.20 or later,
|
|
* set the following bits for FC-TAPE support.
|
|
*/
|
|
if (vpd->rev.feaLevelHigh >= 0x02) {
|
|
npr->ConfmComplAllowed = 1;
|
|
npr->Retry = 1;
|
|
npr->TaskRetryIdReq = 1;
|
|
}
|
|
|
|
npr->acceptRspCode = PRLI_REQ_EXECUTED;
|
|
npr->estabImagePair = 1;
|
|
npr->readXferRdyDis = 1;
|
|
npr->ConfmComplAllowed = 1;
|
|
|
|
npr->prliType = PRLI_FCP_TYPE;
|
|
npr->initiatorFunc = 1;
|
|
|
|
phba->fc_stat.elsXmitACC++;
|
|
elsiocb->iocb_cmpl = lpfc_cmpl_els_acc;
|
|
|
|
spin_lock_irq(phba->host->host_lock);
|
|
rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
if (rc == IOCB_ERROR) {
|
|
lpfc_els_free_iocb(phba, elsiocb);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
lpfc_els_rsp_rnid_acc(struct lpfc_hba * phba,
|
|
uint8_t format,
|
|
struct lpfc_iocbq * oldiocb, struct lpfc_nodelist * ndlp)
|
|
{
|
|
RNID *rn;
|
|
IOCB_t *icmd;
|
|
IOCB_t *oldcmd;
|
|
struct lpfc_iocbq *elsiocb;
|
|
struct lpfc_sli_ring *pring;
|
|
struct lpfc_sli *psli;
|
|
uint8_t *pcmd;
|
|
uint16_t cmdsize;
|
|
int rc;
|
|
|
|
psli = &phba->sli;
|
|
pring = &psli->ring[LPFC_ELS_RING];
|
|
|
|
cmdsize = sizeof (uint32_t) + sizeof (uint32_t)
|
|
+ (2 * sizeof (struct lpfc_name));
|
|
if (format)
|
|
cmdsize += sizeof (RNID_TOP_DISC);
|
|
|
|
elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry,
|
|
ndlp, ndlp->nlp_DID, ELS_CMD_ACC);
|
|
if (!elsiocb)
|
|
return 1;
|
|
|
|
/* Xmit RNID ACC response tag <ulpIoTag> */
|
|
lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
|
|
"%d:0132 Xmit RNID ACC response tag x%x "
|
|
"Data: x%x\n",
|
|
phba->brd_no,
|
|
elsiocb->iocb.ulpIoTag,
|
|
elsiocb->iocb.ulpContext);
|
|
|
|
icmd = &elsiocb->iocb;
|
|
oldcmd = &oldiocb->iocb;
|
|
icmd->ulpContext = oldcmd->ulpContext; /* Xri */
|
|
pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
|
|
|
|
*((uint32_t *) (pcmd)) = ELS_CMD_ACC;
|
|
pcmd += sizeof (uint32_t);
|
|
|
|
memset(pcmd, 0, sizeof (RNID));
|
|
rn = (RNID *) (pcmd);
|
|
rn->Format = format;
|
|
rn->CommonLen = (2 * sizeof (struct lpfc_name));
|
|
memcpy(&rn->portName, &phba->fc_portname, sizeof (struct lpfc_name));
|
|
memcpy(&rn->nodeName, &phba->fc_nodename, sizeof (struct lpfc_name));
|
|
switch (format) {
|
|
case 0:
|
|
rn->SpecificLen = 0;
|
|
break;
|
|
case RNID_TOPOLOGY_DISC:
|
|
rn->SpecificLen = sizeof (RNID_TOP_DISC);
|
|
memcpy(&rn->un.topologyDisc.portName,
|
|
&phba->fc_portname, sizeof (struct lpfc_name));
|
|
rn->un.topologyDisc.unitType = RNID_HBA;
|
|
rn->un.topologyDisc.physPort = 0;
|
|
rn->un.topologyDisc.attachedNodes = 0;
|
|
break;
|
|
default:
|
|
rn->CommonLen = 0;
|
|
rn->SpecificLen = 0;
|
|
break;
|
|
}
|
|
|
|
phba->fc_stat.elsXmitACC++;
|
|
elsiocb->iocb_cmpl = lpfc_cmpl_els_acc;
|
|
elsiocb->context1 = NULL; /* Don't need ndlp for cmpl,
|
|
* it could be freed */
|
|
|
|
spin_lock_irq(phba->host->host_lock);
|
|
rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
if (rc == IOCB_ERROR) {
|
|
lpfc_els_free_iocb(phba, elsiocb);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
lpfc_els_disc_adisc(struct lpfc_hba * phba)
|
|
{
|
|
int sentadisc;
|
|
struct lpfc_nodelist *ndlp, *next_ndlp;
|
|
|
|
sentadisc = 0;
|
|
/* go thru NPR list and issue any remaining ELS ADISCs */
|
|
list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_npr_list,
|
|
nlp_listp) {
|
|
if (ndlp->nlp_flag & NLP_NPR_2B_DISC) {
|
|
if (ndlp->nlp_flag & NLP_NPR_ADISC) {
|
|
ndlp->nlp_flag &= ~NLP_NPR_ADISC;
|
|
ndlp->nlp_prev_state = ndlp->nlp_state;
|
|
ndlp->nlp_state = NLP_STE_ADISC_ISSUE;
|
|
lpfc_nlp_list(phba, ndlp,
|
|
NLP_ADISC_LIST);
|
|
lpfc_issue_els_adisc(phba, ndlp, 0);
|
|
sentadisc++;
|
|
phba->num_disc_nodes++;
|
|
if (phba->num_disc_nodes >=
|
|
phba->cfg_discovery_threads) {
|
|
spin_lock_irq(phba->host->host_lock);
|
|
phba->fc_flag |= FC_NLP_MORE;
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (sentadisc == 0) {
|
|
spin_lock_irq(phba->host->host_lock);
|
|
phba->fc_flag &= ~FC_NLP_MORE;
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
}
|
|
return sentadisc;
|
|
}
|
|
|
|
int
|
|
lpfc_els_disc_plogi(struct lpfc_hba * phba)
|
|
{
|
|
int sentplogi;
|
|
struct lpfc_nodelist *ndlp, *next_ndlp;
|
|
|
|
sentplogi = 0;
|
|
/* go thru NPR list and issue any remaining ELS PLOGIs */
|
|
list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_npr_list,
|
|
nlp_listp) {
|
|
if ((ndlp->nlp_flag & NLP_NPR_2B_DISC) &&
|
|
(!(ndlp->nlp_flag & NLP_DELAY_TMO))) {
|
|
if (!(ndlp->nlp_flag & NLP_NPR_ADISC)) {
|
|
ndlp->nlp_prev_state = ndlp->nlp_state;
|
|
ndlp->nlp_state = NLP_STE_PLOGI_ISSUE;
|
|
lpfc_nlp_list(phba, ndlp, NLP_PLOGI_LIST);
|
|
lpfc_issue_els_plogi(phba, ndlp->nlp_DID, 0);
|
|
sentplogi++;
|
|
phba->num_disc_nodes++;
|
|
if (phba->num_disc_nodes >=
|
|
phba->cfg_discovery_threads) {
|
|
spin_lock_irq(phba->host->host_lock);
|
|
phba->fc_flag |= FC_NLP_MORE;
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (sentplogi == 0) {
|
|
spin_lock_irq(phba->host->host_lock);
|
|
phba->fc_flag &= ~FC_NLP_MORE;
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
}
|
|
return sentplogi;
|
|
}
|
|
|
|
int
|
|
lpfc_els_flush_rscn(struct lpfc_hba * phba)
|
|
{
|
|
struct lpfc_dmabuf *mp;
|
|
int i;
|
|
|
|
for (i = 0; i < phba->fc_rscn_id_cnt; i++) {
|
|
mp = phba->fc_rscn_id_list[i];
|
|
lpfc_mbuf_free(phba, mp->virt, mp->phys);
|
|
kfree(mp);
|
|
phba->fc_rscn_id_list[i] = NULL;
|
|
}
|
|
phba->fc_rscn_id_cnt = 0;
|
|
spin_lock_irq(phba->host->host_lock);
|
|
phba->fc_flag &= ~(FC_RSCN_MODE | FC_RSCN_DISCOVERY);
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
lpfc_can_disctmo(phba);
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
lpfc_rscn_payload_check(struct lpfc_hba * phba, uint32_t did)
|
|
{
|
|
D_ID ns_did;
|
|
D_ID rscn_did;
|
|
struct lpfc_dmabuf *mp;
|
|
uint32_t *lp;
|
|
uint32_t payload_len, cmd, i, match;
|
|
|
|
ns_did.un.word = did;
|
|
match = 0;
|
|
|
|
/* Never match fabric nodes for RSCNs */
|
|
if ((did & Fabric_DID_MASK) == Fabric_DID_MASK)
|
|
return(0);
|
|
|
|
/* If we are doing a FULL RSCN rediscovery, match everything */
|
|
if (phba->fc_flag & FC_RSCN_DISCOVERY) {
|
|
return did;
|
|
}
|
|
|
|
for (i = 0; i < phba->fc_rscn_id_cnt; i++) {
|
|
mp = phba->fc_rscn_id_list[i];
|
|
lp = (uint32_t *) mp->virt;
|
|
cmd = *lp++;
|
|
payload_len = be32_to_cpu(cmd) & 0xffff; /* payload length */
|
|
payload_len -= sizeof (uint32_t); /* take off word 0 */
|
|
while (payload_len) {
|
|
rscn_did.un.word = *lp++;
|
|
rscn_did.un.word = be32_to_cpu(rscn_did.un.word);
|
|
payload_len -= sizeof (uint32_t);
|
|
switch (rscn_did.un.b.resv) {
|
|
case 0: /* Single N_Port ID effected */
|
|
if (ns_did.un.word == rscn_did.un.word) {
|
|
match = did;
|
|
}
|
|
break;
|
|
case 1: /* Whole N_Port Area effected */
|
|
if ((ns_did.un.b.domain == rscn_did.un.b.domain)
|
|
&& (ns_did.un.b.area == rscn_did.un.b.area))
|
|
{
|
|
match = did;
|
|
}
|
|
break;
|
|
case 2: /* Whole N_Port Domain effected */
|
|
if (ns_did.un.b.domain == rscn_did.un.b.domain)
|
|
{
|
|
match = did;
|
|
}
|
|
break;
|
|
case 3: /* Whole Fabric effected */
|
|
match = did;
|
|
break;
|
|
default:
|
|
/* Unknown Identifier in RSCN list */
|
|
lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY,
|
|
"%d:0217 Unknown Identifier in "
|
|
"RSCN payload Data: x%x\n",
|
|
phba->brd_no, rscn_did.un.word);
|
|
break;
|
|
}
|
|
if (match) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return match;
|
|
}
|
|
|
|
static int
|
|
lpfc_rscn_recovery_check(struct lpfc_hba * phba)
|
|
{
|
|
struct lpfc_nodelist *ndlp = NULL, *next_ndlp;
|
|
struct list_head *listp;
|
|
struct list_head *node_list[7];
|
|
int i;
|
|
|
|
/* Look at all nodes effected by pending RSCNs and move
|
|
* them to NPR list.
|
|
*/
|
|
node_list[0] = &phba->fc_npr_list; /* MUST do this list first */
|
|
node_list[1] = &phba->fc_nlpmap_list;
|
|
node_list[2] = &phba->fc_nlpunmap_list;
|
|
node_list[3] = &phba->fc_prli_list;
|
|
node_list[4] = &phba->fc_reglogin_list;
|
|
node_list[5] = &phba->fc_adisc_list;
|
|
node_list[6] = &phba->fc_plogi_list;
|
|
for (i = 0; i < 7; i++) {
|
|
listp = node_list[i];
|
|
if (list_empty(listp))
|
|
continue;
|
|
|
|
list_for_each_entry_safe(ndlp, next_ndlp, listp, nlp_listp) {
|
|
if (!(lpfc_rscn_payload_check(phba, ndlp->nlp_DID)))
|
|
continue;
|
|
|
|
lpfc_disc_state_machine(phba, ndlp, NULL,
|
|
NLP_EVT_DEVICE_RECOVERY);
|
|
|
|
/* Make sure NLP_DELAY_TMO is NOT running
|
|
* after a device recovery event.
|
|
*/
|
|
if (ndlp->nlp_flag & NLP_DELAY_TMO)
|
|
lpfc_cancel_retry_delay_tmo(phba, ndlp);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
lpfc_els_rcv_rscn(struct lpfc_hba * phba,
|
|
struct lpfc_iocbq * cmdiocb,
|
|
struct lpfc_nodelist * ndlp, uint8_t newnode)
|
|
{
|
|
struct lpfc_dmabuf *pcmd;
|
|
uint32_t *lp;
|
|
IOCB_t *icmd;
|
|
uint32_t payload_len, cmd;
|
|
|
|
icmd = &cmdiocb->iocb;
|
|
pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
|
|
lp = (uint32_t *) pcmd->virt;
|
|
|
|
cmd = *lp++;
|
|
payload_len = be32_to_cpu(cmd) & 0xffff; /* payload length */
|
|
payload_len -= sizeof (uint32_t); /* take off word 0 */
|
|
cmd &= ELS_CMD_MASK;
|
|
|
|
/* RSCN received */
|
|
lpfc_printf_log(phba,
|
|
KERN_INFO,
|
|
LOG_DISCOVERY,
|
|
"%d:0214 RSCN received Data: x%x x%x x%x x%x\n",
|
|
phba->brd_no,
|
|
phba->fc_flag, payload_len, *lp, phba->fc_rscn_id_cnt);
|
|
|
|
/* If we are about to begin discovery, just ACC the RSCN.
|
|
* Discovery processing will satisfy it.
|
|
*/
|
|
if (phba->hba_state <= LPFC_NS_QRY) {
|
|
lpfc_els_rsp_acc(phba, ELS_CMD_ACC, cmdiocb, ndlp, NULL,
|
|
newnode);
|
|
return 0;
|
|
}
|
|
|
|
/* If we are already processing an RSCN, save the received
|
|
* RSCN payload buffer, cmdiocb->context2 to process later.
|
|
*/
|
|
if (phba->fc_flag & (FC_RSCN_MODE | FC_NDISC_ACTIVE)) {
|
|
if ((phba->fc_rscn_id_cnt < FC_MAX_HOLD_RSCN) &&
|
|
!(phba->fc_flag & FC_RSCN_DISCOVERY)) {
|
|
spin_lock_irq(phba->host->host_lock);
|
|
phba->fc_flag |= FC_RSCN_MODE;
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
phba->fc_rscn_id_list[phba->fc_rscn_id_cnt++] = pcmd;
|
|
|
|
/* If we zero, cmdiocb->context2, the calling
|
|
* routine will not try to free it.
|
|
*/
|
|
cmdiocb->context2 = NULL;
|
|
|
|
/* Deferred RSCN */
|
|
lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
|
|
"%d:0235 Deferred RSCN "
|
|
"Data: x%x x%x x%x\n",
|
|
phba->brd_no, phba->fc_rscn_id_cnt,
|
|
phba->fc_flag, phba->hba_state);
|
|
} else {
|
|
spin_lock_irq(phba->host->host_lock);
|
|
phba->fc_flag |= FC_RSCN_DISCOVERY;
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
/* ReDiscovery RSCN */
|
|
lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
|
|
"%d:0234 ReDiscovery RSCN "
|
|
"Data: x%x x%x x%x\n",
|
|
phba->brd_no, phba->fc_rscn_id_cnt,
|
|
phba->fc_flag, phba->hba_state);
|
|
}
|
|
/* Send back ACC */
|
|
lpfc_els_rsp_acc(phba, ELS_CMD_ACC, cmdiocb, ndlp, NULL,
|
|
newnode);
|
|
|
|
/* send RECOVERY event for ALL nodes that match RSCN payload */
|
|
lpfc_rscn_recovery_check(phba);
|
|
return 0;
|
|
}
|
|
|
|
phba->fc_flag |= FC_RSCN_MODE;
|
|
phba->fc_rscn_id_list[phba->fc_rscn_id_cnt++] = pcmd;
|
|
/*
|
|
* If we zero, cmdiocb->context2, the calling routine will
|
|
* not try to free it.
|
|
*/
|
|
cmdiocb->context2 = NULL;
|
|
|
|
lpfc_set_disctmo(phba);
|
|
|
|
/* Send back ACC */
|
|
lpfc_els_rsp_acc(phba, ELS_CMD_ACC, cmdiocb, ndlp, NULL, newnode);
|
|
|
|
/* send RECOVERY event for ALL nodes that match RSCN payload */
|
|
lpfc_rscn_recovery_check(phba);
|
|
|
|
return lpfc_els_handle_rscn(phba);
|
|
}
|
|
|
|
int
|
|
lpfc_els_handle_rscn(struct lpfc_hba * phba)
|
|
{
|
|
struct lpfc_nodelist *ndlp;
|
|
|
|
/* Start timer for RSCN processing */
|
|
lpfc_set_disctmo(phba);
|
|
|
|
/* RSCN processed */
|
|
lpfc_printf_log(phba,
|
|
KERN_INFO,
|
|
LOG_DISCOVERY,
|
|
"%d:0215 RSCN processed Data: x%x x%x x%x x%x\n",
|
|
phba->brd_no,
|
|
phba->fc_flag, 0, phba->fc_rscn_id_cnt,
|
|
phba->hba_state);
|
|
|
|
/* To process RSCN, first compare RSCN data with NameServer */
|
|
phba->fc_ns_retry = 0;
|
|
ndlp = lpfc_findnode_did(phba, NLP_SEARCH_UNMAPPED, NameServer_DID);
|
|
if (ndlp) {
|
|
/* Good ndlp, issue CT Request to NameServer */
|
|
if (lpfc_ns_cmd(phba, ndlp, SLI_CTNS_GID_FT) == 0) {
|
|
/* Wait for NameServer query cmpl before we can
|
|
continue */
|
|
return 1;
|
|
}
|
|
} else {
|
|
/* If login to NameServer does not exist, issue one */
|
|
/* Good status, issue PLOGI to NameServer */
|
|
ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, NameServer_DID);
|
|
if (ndlp) {
|
|
/* Wait for NameServer login cmpl before we can
|
|
continue */
|
|
return 1;
|
|
}
|
|
ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
|
|
if (!ndlp) {
|
|
lpfc_els_flush_rscn(phba);
|
|
return 0;
|
|
} else {
|
|
lpfc_nlp_init(phba, ndlp, NameServer_DID);
|
|
ndlp->nlp_type |= NLP_FABRIC;
|
|
ndlp->nlp_prev_state = ndlp->nlp_state;
|
|
ndlp->nlp_state = NLP_STE_PLOGI_ISSUE;
|
|
lpfc_issue_els_plogi(phba, NameServer_DID, 0);
|
|
/* Wait for NameServer login cmpl before we can
|
|
continue */
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
lpfc_els_flush_rscn(phba);
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
lpfc_els_rcv_flogi(struct lpfc_hba * phba,
|
|
struct lpfc_iocbq * cmdiocb,
|
|
struct lpfc_nodelist * ndlp, uint8_t newnode)
|
|
{
|
|
struct lpfc_dmabuf *pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
|
|
uint32_t *lp = (uint32_t *) pcmd->virt;
|
|
IOCB_t *icmd = &cmdiocb->iocb;
|
|
struct serv_parm *sp;
|
|
LPFC_MBOXQ_t *mbox;
|
|
struct ls_rjt stat;
|
|
uint32_t cmd, did;
|
|
int rc;
|
|
|
|
cmd = *lp++;
|
|
sp = (struct serv_parm *) lp;
|
|
|
|
/* FLOGI received */
|
|
|
|
lpfc_set_disctmo(phba);
|
|
|
|
if (phba->fc_topology == TOPOLOGY_LOOP) {
|
|
/* We should never receive a FLOGI in loop mode, ignore it */
|
|
did = icmd->un.elsreq64.remoteID;
|
|
|
|
/* An FLOGI ELS command <elsCmd> was received from DID <did> in
|
|
Loop Mode */
|
|
lpfc_printf_log(phba, KERN_ERR, LOG_ELS,
|
|
"%d:0113 An FLOGI ELS command x%x was received "
|
|
"from DID x%x in Loop Mode\n",
|
|
phba->brd_no, cmd, did);
|
|
return 1;
|
|
}
|
|
|
|
did = Fabric_DID;
|
|
|
|
if ((lpfc_check_sparm(phba, ndlp, sp, CLASS3))) {
|
|
/* For a FLOGI we accept, then if our portname is greater
|
|
* then the remote portname we initiate Nport login.
|
|
*/
|
|
|
|
rc = memcmp(&phba->fc_portname, &sp->portName,
|
|
sizeof (struct lpfc_name));
|
|
|
|
if (!rc) {
|
|
if ((mbox = mempool_alloc(phba->mbox_mem_pool,
|
|
GFP_KERNEL)) == 0) {
|
|
return 1;
|
|
}
|
|
lpfc_linkdown(phba);
|
|
lpfc_init_link(phba, mbox,
|
|
phba->cfg_topology,
|
|
phba->cfg_link_speed);
|
|
mbox->mb.un.varInitLnk.lipsr_AL_PA = 0;
|
|
mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
|
|
rc = lpfc_sli_issue_mbox
|
|
(phba, mbox, (MBX_NOWAIT | MBX_STOP_IOCB));
|
|
if (rc == MBX_NOT_FINISHED) {
|
|
mempool_free( mbox, phba->mbox_mem_pool);
|
|
}
|
|
return 1;
|
|
} else if (rc > 0) { /* greater than */
|
|
spin_lock_irq(phba->host->host_lock);
|
|
phba->fc_flag |= FC_PT2PT_PLOGI;
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
}
|
|
phba->fc_flag |= FC_PT2PT;
|
|
phba->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP);
|
|
} else {
|
|
/* Reject this request because invalid parameters */
|
|
stat.un.b.lsRjtRsvd0 = 0;
|
|
stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
|
|
stat.un.b.lsRjtRsnCodeExp = LSEXP_SPARM_OPTIONS;
|
|
stat.un.b.vendorUnique = 0;
|
|
lpfc_els_rsp_reject(phba, stat.un.lsRjtError, cmdiocb, ndlp);
|
|
return 1;
|
|
}
|
|
|
|
/* Send back ACC */
|
|
lpfc_els_rsp_acc(phba, ELS_CMD_PLOGI, cmdiocb, ndlp, NULL, newnode);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
lpfc_els_rcv_rnid(struct lpfc_hba * phba,
|
|
struct lpfc_iocbq * cmdiocb, struct lpfc_nodelist * ndlp)
|
|
{
|
|
struct lpfc_dmabuf *pcmd;
|
|
uint32_t *lp;
|
|
IOCB_t *icmd;
|
|
RNID *rn;
|
|
struct ls_rjt stat;
|
|
uint32_t cmd, did;
|
|
|
|
icmd = &cmdiocb->iocb;
|
|
did = icmd->un.elsreq64.remoteID;
|
|
pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
|
|
lp = (uint32_t *) pcmd->virt;
|
|
|
|
cmd = *lp++;
|
|
rn = (RNID *) lp;
|
|
|
|
/* RNID received */
|
|
|
|
switch (rn->Format) {
|
|
case 0:
|
|
case RNID_TOPOLOGY_DISC:
|
|
/* Send back ACC */
|
|
lpfc_els_rsp_rnid_acc(phba, rn->Format, cmdiocb, ndlp);
|
|
break;
|
|
default:
|
|
/* Reject this request because format not supported */
|
|
stat.un.b.lsRjtRsvd0 = 0;
|
|
stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
|
|
stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
|
|
stat.un.b.vendorUnique = 0;
|
|
lpfc_els_rsp_reject(phba, stat.un.lsRjtError, cmdiocb, ndlp);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
lpfc_els_rcv_lirr(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
|
|
struct lpfc_nodelist * ndlp)
|
|
{
|
|
struct ls_rjt stat;
|
|
|
|
/* For now, unconditionally reject this command */
|
|
stat.un.b.lsRjtRsvd0 = 0;
|
|
stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
|
|
stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
|
|
stat.un.b.vendorUnique = 0;
|
|
lpfc_els_rsp_reject(phba, stat.un.lsRjtError, cmdiocb, ndlp);
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
lpfc_els_rsp_rps_acc(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb)
|
|
{
|
|
struct lpfc_sli *psli;
|
|
struct lpfc_sli_ring *pring;
|
|
MAILBOX_t *mb;
|
|
IOCB_t *icmd;
|
|
RPS_RSP *rps_rsp;
|
|
uint8_t *pcmd;
|
|
struct lpfc_iocbq *elsiocb;
|
|
struct lpfc_nodelist *ndlp;
|
|
uint16_t xri, status;
|
|
uint32_t cmdsize;
|
|
|
|
psli = &phba->sli;
|
|
pring = &psli->ring[LPFC_ELS_RING];
|
|
mb = &pmb->mb;
|
|
|
|
ndlp = (struct lpfc_nodelist *) pmb->context2;
|
|
xri = (uint16_t) ((unsigned long)(pmb->context1));
|
|
pmb->context1 = NULL;
|
|
pmb->context2 = NULL;
|
|
|
|
if (mb->mbxStatus) {
|
|
mempool_free( pmb, phba->mbox_mem_pool);
|
|
return;
|
|
}
|
|
|
|
cmdsize = sizeof(RPS_RSP) + sizeof(uint32_t);
|
|
mempool_free( pmb, phba->mbox_mem_pool);
|
|
elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, lpfc_max_els_tries, ndlp,
|
|
ndlp->nlp_DID, ELS_CMD_ACC);
|
|
if (!elsiocb)
|
|
return;
|
|
|
|
icmd = &elsiocb->iocb;
|
|
icmd->ulpContext = xri;
|
|
|
|
pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
|
|
*((uint32_t *) (pcmd)) = ELS_CMD_ACC;
|
|
pcmd += sizeof (uint32_t); /* Skip past command */
|
|
rps_rsp = (RPS_RSP *)pcmd;
|
|
|
|
if (phba->fc_topology != TOPOLOGY_LOOP)
|
|
status = 0x10;
|
|
else
|
|
status = 0x8;
|
|
if (phba->fc_flag & FC_FABRIC)
|
|
status |= 0x4;
|
|
|
|
rps_rsp->rsvd1 = 0;
|
|
rps_rsp->portStatus = be16_to_cpu(status);
|
|
rps_rsp->linkFailureCnt = be32_to_cpu(mb->un.varRdLnk.linkFailureCnt);
|
|
rps_rsp->lossSyncCnt = be32_to_cpu(mb->un.varRdLnk.lossSyncCnt);
|
|
rps_rsp->lossSignalCnt = be32_to_cpu(mb->un.varRdLnk.lossSignalCnt);
|
|
rps_rsp->primSeqErrCnt = be32_to_cpu(mb->un.varRdLnk.primSeqErrCnt);
|
|
rps_rsp->invalidXmitWord = be32_to_cpu(mb->un.varRdLnk.invalidXmitWord);
|
|
rps_rsp->crcCnt = be32_to_cpu(mb->un.varRdLnk.crcCnt);
|
|
|
|
/* Xmit ELS RPS ACC response tag <ulpIoTag> */
|
|
lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
|
|
"%d:0118 Xmit ELS RPS ACC response tag x%x "
|
|
"Data: x%x x%x x%x x%x x%x\n",
|
|
phba->brd_no,
|
|
elsiocb->iocb.ulpIoTag,
|
|
elsiocb->iocb.ulpContext, ndlp->nlp_DID,
|
|
ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi);
|
|
|
|
elsiocb->iocb_cmpl = lpfc_cmpl_els_acc;
|
|
phba->fc_stat.elsXmitACC++;
|
|
if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
|
|
lpfc_els_free_iocb(phba, elsiocb);
|
|
}
|
|
return;
|
|
}
|
|
|
|
static int
|
|
lpfc_els_rcv_rps(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
|
|
struct lpfc_nodelist * ndlp)
|
|
{
|
|
uint32_t *lp;
|
|
uint8_t flag;
|
|
LPFC_MBOXQ_t *mbox;
|
|
struct lpfc_dmabuf *pcmd;
|
|
RPS *rps;
|
|
struct ls_rjt stat;
|
|
|
|
if ((ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) &&
|
|
(ndlp->nlp_state != NLP_STE_MAPPED_NODE)) {
|
|
stat.un.b.lsRjtRsvd0 = 0;
|
|
stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
|
|
stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
|
|
stat.un.b.vendorUnique = 0;
|
|
lpfc_els_rsp_reject(phba, stat.un.lsRjtError, cmdiocb, ndlp);
|
|
}
|
|
|
|
pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
|
|
lp = (uint32_t *) pcmd->virt;
|
|
flag = (be32_to_cpu(*lp++) & 0xf);
|
|
rps = (RPS *) lp;
|
|
|
|
if ((flag == 0) ||
|
|
((flag == 1) && (be32_to_cpu(rps->un.portNum) == 0)) ||
|
|
((flag == 2) && (memcmp(&rps->un.portName, &phba->fc_portname,
|
|
sizeof (struct lpfc_name)) == 0))) {
|
|
if ((mbox = mempool_alloc(phba->mbox_mem_pool, GFP_ATOMIC))) {
|
|
lpfc_read_lnk_stat(phba, mbox);
|
|
mbox->context1 =
|
|
(void *)((unsigned long)cmdiocb->iocb.ulpContext);
|
|
mbox->context2 = ndlp;
|
|
mbox->mbox_cmpl = lpfc_els_rsp_rps_acc;
|
|
if (lpfc_sli_issue_mbox (phba, mbox,
|
|
(MBX_NOWAIT | MBX_STOP_IOCB)) != MBX_NOT_FINISHED) {
|
|
/* Mbox completion will send ELS Response */
|
|
return 0;
|
|
}
|
|
mempool_free(mbox, phba->mbox_mem_pool);
|
|
}
|
|
}
|
|
stat.un.b.lsRjtRsvd0 = 0;
|
|
stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
|
|
stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
|
|
stat.un.b.vendorUnique = 0;
|
|
lpfc_els_rsp_reject(phba, stat.un.lsRjtError, cmdiocb, ndlp);
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
lpfc_els_rsp_rpl_acc(struct lpfc_hba * phba, uint16_t cmdsize,
|
|
struct lpfc_iocbq * oldiocb, struct lpfc_nodelist * ndlp)
|
|
{
|
|
IOCB_t *icmd;
|
|
IOCB_t *oldcmd;
|
|
RPL_RSP rpl_rsp;
|
|
struct lpfc_iocbq *elsiocb;
|
|
struct lpfc_sli_ring *pring;
|
|
struct lpfc_sli *psli;
|
|
uint8_t *pcmd;
|
|
|
|
psli = &phba->sli;
|
|
pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
|
|
|
|
elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry,
|
|
ndlp, ndlp->nlp_DID, ELS_CMD_ACC);
|
|
if (!elsiocb)
|
|
return 1;
|
|
|
|
icmd = &elsiocb->iocb;
|
|
oldcmd = &oldiocb->iocb;
|
|
icmd->ulpContext = oldcmd->ulpContext; /* Xri */
|
|
|
|
pcmd = (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
|
|
*((uint32_t *) (pcmd)) = ELS_CMD_ACC;
|
|
pcmd += sizeof (uint16_t);
|
|
*((uint16_t *)(pcmd)) = be16_to_cpu(cmdsize);
|
|
pcmd += sizeof(uint16_t);
|
|
|
|
/* Setup the RPL ACC payload */
|
|
rpl_rsp.listLen = be32_to_cpu(1);
|
|
rpl_rsp.index = 0;
|
|
rpl_rsp.port_num_blk.portNum = 0;
|
|
rpl_rsp.port_num_blk.portID = be32_to_cpu(phba->fc_myDID);
|
|
memcpy(&rpl_rsp.port_num_blk.portName, &phba->fc_portname,
|
|
sizeof(struct lpfc_name));
|
|
|
|
memcpy(pcmd, &rpl_rsp, cmdsize - sizeof(uint32_t));
|
|
|
|
|
|
/* Xmit ELS RPL ACC response tag <ulpIoTag> */
|
|
lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
|
|
"%d:0120 Xmit ELS RPL ACC response tag x%x "
|
|
"Data: x%x x%x x%x x%x x%x\n",
|
|
phba->brd_no,
|
|
elsiocb->iocb.ulpIoTag,
|
|
elsiocb->iocb.ulpContext, ndlp->nlp_DID,
|
|
ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi);
|
|
|
|
elsiocb->iocb_cmpl = lpfc_cmpl_els_acc;
|
|
|
|
phba->fc_stat.elsXmitACC++;
|
|
if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
|
|
lpfc_els_free_iocb(phba, elsiocb);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
lpfc_els_rcv_rpl(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
|
|
struct lpfc_nodelist * ndlp)
|
|
{
|
|
struct lpfc_dmabuf *pcmd;
|
|
uint32_t *lp;
|
|
uint32_t maxsize;
|
|
uint16_t cmdsize;
|
|
RPL *rpl;
|
|
struct ls_rjt stat;
|
|
|
|
if ((ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) &&
|
|
(ndlp->nlp_state != NLP_STE_MAPPED_NODE)) {
|
|
stat.un.b.lsRjtRsvd0 = 0;
|
|
stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
|
|
stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
|
|
stat.un.b.vendorUnique = 0;
|
|
lpfc_els_rsp_reject(phba, stat.un.lsRjtError, cmdiocb, ndlp);
|
|
}
|
|
|
|
pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
|
|
lp = (uint32_t *) pcmd->virt;
|
|
rpl = (RPL *) (lp + 1);
|
|
|
|
maxsize = be32_to_cpu(rpl->maxsize);
|
|
|
|
/* We support only one port */
|
|
if ((rpl->index == 0) &&
|
|
((maxsize == 0) ||
|
|
((maxsize * sizeof(uint32_t)) >= sizeof(RPL_RSP)))) {
|
|
cmdsize = sizeof(uint32_t) + sizeof(RPL_RSP);
|
|
} else {
|
|
cmdsize = sizeof(uint32_t) + maxsize * sizeof(uint32_t);
|
|
}
|
|
lpfc_els_rsp_rpl_acc(phba, cmdsize, cmdiocb, ndlp);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
lpfc_els_rcv_farp(struct lpfc_hba * phba,
|
|
struct lpfc_iocbq * cmdiocb, struct lpfc_nodelist * ndlp)
|
|
{
|
|
struct lpfc_dmabuf *pcmd;
|
|
uint32_t *lp;
|
|
IOCB_t *icmd;
|
|
FARP *fp;
|
|
uint32_t cmd, cnt, did;
|
|
|
|
icmd = &cmdiocb->iocb;
|
|
did = icmd->un.elsreq64.remoteID;
|
|
pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
|
|
lp = (uint32_t *) pcmd->virt;
|
|
|
|
cmd = *lp++;
|
|
fp = (FARP *) lp;
|
|
|
|
/* FARP-REQ received from DID <did> */
|
|
lpfc_printf_log(phba,
|
|
KERN_INFO,
|
|
LOG_IP,
|
|
"%d:0601 FARP-REQ received from DID x%x\n",
|
|
phba->brd_no, did);
|
|
|
|
/* We will only support match on WWPN or WWNN */
|
|
if (fp->Mflags & ~(FARP_MATCH_NODE | FARP_MATCH_PORT)) {
|
|
return 0;
|
|
}
|
|
|
|
cnt = 0;
|
|
/* If this FARP command is searching for my portname */
|
|
if (fp->Mflags & FARP_MATCH_PORT) {
|
|
if (memcmp(&fp->RportName, &phba->fc_portname,
|
|
sizeof (struct lpfc_name)) == 0)
|
|
cnt = 1;
|
|
}
|
|
|
|
/* If this FARP command is searching for my nodename */
|
|
if (fp->Mflags & FARP_MATCH_NODE) {
|
|
if (memcmp(&fp->RnodeName, &phba->fc_nodename,
|
|
sizeof (struct lpfc_name)) == 0)
|
|
cnt = 1;
|
|
}
|
|
|
|
if (cnt) {
|
|
if ((ndlp->nlp_state == NLP_STE_UNMAPPED_NODE) ||
|
|
(ndlp->nlp_state == NLP_STE_MAPPED_NODE)) {
|
|
/* Log back into the node before sending the FARP. */
|
|
if (fp->Rflags & FARP_REQUEST_PLOGI) {
|
|
ndlp->nlp_prev_state = ndlp->nlp_state;
|
|
ndlp->nlp_state = NLP_STE_PLOGI_ISSUE;
|
|
lpfc_nlp_list(phba, ndlp, NLP_PLOGI_LIST);
|
|
lpfc_issue_els_plogi(phba, ndlp->nlp_DID, 0);
|
|
}
|
|
|
|
/* Send a FARP response to that node */
|
|
if (fp->Rflags & FARP_REQUEST_FARPR) {
|
|
lpfc_issue_els_farpr(phba, did, 0);
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
lpfc_els_rcv_farpr(struct lpfc_hba * phba,
|
|
struct lpfc_iocbq * cmdiocb, struct lpfc_nodelist * ndlp)
|
|
{
|
|
struct lpfc_dmabuf *pcmd;
|
|
uint32_t *lp;
|
|
IOCB_t *icmd;
|
|
uint32_t cmd, did;
|
|
|
|
icmd = &cmdiocb->iocb;
|
|
did = icmd->un.elsreq64.remoteID;
|
|
pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
|
|
lp = (uint32_t *) pcmd->virt;
|
|
|
|
cmd = *lp++;
|
|
/* FARP-RSP received from DID <did> */
|
|
lpfc_printf_log(phba,
|
|
KERN_INFO,
|
|
LOG_IP,
|
|
"%d:0600 FARP-RSP received from DID x%x\n",
|
|
phba->brd_no, did);
|
|
|
|
/* ACCEPT the Farp resp request */
|
|
lpfc_els_rsp_acc(phba, ELS_CMD_ACC, cmdiocb, ndlp, NULL, 0);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
lpfc_els_rcv_fan(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
|
|
struct lpfc_nodelist * fan_ndlp)
|
|
{
|
|
struct lpfc_dmabuf *pcmd;
|
|
uint32_t *lp;
|
|
IOCB_t *icmd;
|
|
uint32_t cmd, did;
|
|
FAN *fp;
|
|
struct lpfc_nodelist *ndlp, *next_ndlp;
|
|
|
|
/* FAN received */
|
|
lpfc_printf_log(phba, KERN_INFO, LOG_ELS, "%d:0265 FAN received\n",
|
|
phba->brd_no);
|
|
|
|
icmd = &cmdiocb->iocb;
|
|
did = icmd->un.elsreq64.remoteID;
|
|
pcmd = (struct lpfc_dmabuf *)cmdiocb->context2;
|
|
lp = (uint32_t *)pcmd->virt;
|
|
|
|
cmd = *lp++;
|
|
fp = (FAN *)lp;
|
|
|
|
/* FAN received; Fan does not have a reply sequence */
|
|
|
|
if (phba->hba_state == LPFC_LOCAL_CFG_LINK) {
|
|
if ((memcmp(&phba->fc_fabparam.nodeName, &fp->FnodeName,
|
|
sizeof(struct lpfc_name)) != 0) ||
|
|
(memcmp(&phba->fc_fabparam.portName, &fp->FportName,
|
|
sizeof(struct lpfc_name)) != 0)) {
|
|
/*
|
|
* This node has switched fabrics. FLOGI is required
|
|
* Clean up the old rpi's
|
|
*/
|
|
|
|
list_for_each_entry_safe(ndlp, next_ndlp,
|
|
&phba->fc_npr_list, nlp_listp) {
|
|
|
|
if (ndlp->nlp_type & NLP_FABRIC) {
|
|
/*
|
|
* Clean up old Fabric, Nameserver and
|
|
* other NLP_FABRIC logins
|
|
*/
|
|
lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
|
|
} else if (!(ndlp->nlp_flag & NLP_NPR_ADISC)) {
|
|
/* Fail outstanding I/O now since this
|
|
* device is marked for PLOGI
|
|
*/
|
|
lpfc_unreg_rpi(phba, ndlp);
|
|
}
|
|
}
|
|
|
|
phba->hba_state = LPFC_FLOGI;
|
|
lpfc_set_disctmo(phba);
|
|
lpfc_initial_flogi(phba);
|
|
return 0;
|
|
}
|
|
/* Discovery not needed,
|
|
* move the nodes to their original state.
|
|
*/
|
|
list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_npr_list,
|
|
nlp_listp) {
|
|
|
|
switch (ndlp->nlp_prev_state) {
|
|
case NLP_STE_UNMAPPED_NODE:
|
|
ndlp->nlp_prev_state = NLP_STE_NPR_NODE;
|
|
ndlp->nlp_state = NLP_STE_UNMAPPED_NODE;
|
|
lpfc_nlp_list(phba, ndlp, NLP_UNMAPPED_LIST);
|
|
break;
|
|
|
|
case NLP_STE_MAPPED_NODE:
|
|
ndlp->nlp_prev_state = NLP_STE_NPR_NODE;
|
|
ndlp->nlp_state = NLP_STE_MAPPED_NODE;
|
|
lpfc_nlp_list(phba, ndlp, NLP_MAPPED_LIST);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Start discovery - this should just do CLEAR_LA */
|
|
lpfc_disc_start(phba);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
lpfc_els_timeout(unsigned long ptr)
|
|
{
|
|
struct lpfc_hba *phba;
|
|
unsigned long iflag;
|
|
|
|
phba = (struct lpfc_hba *)ptr;
|
|
if (phba == 0)
|
|
return;
|
|
spin_lock_irqsave(phba->host->host_lock, iflag);
|
|
if (!(phba->work_hba_events & WORKER_ELS_TMO)) {
|
|
phba->work_hba_events |= WORKER_ELS_TMO;
|
|
if (phba->work_wait)
|
|
wake_up(phba->work_wait);
|
|
}
|
|
spin_unlock_irqrestore(phba->host->host_lock, iflag);
|
|
return;
|
|
}
|
|
|
|
void
|
|
lpfc_els_timeout_handler(struct lpfc_hba *phba)
|
|
{
|
|
struct lpfc_sli_ring *pring;
|
|
struct lpfc_iocbq *tmp_iocb, *piocb;
|
|
IOCB_t *cmd = NULL;
|
|
struct lpfc_dmabuf *pcmd;
|
|
struct list_head *dlp;
|
|
uint32_t *elscmd;
|
|
uint32_t els_command;
|
|
uint32_t timeout;
|
|
uint32_t remote_ID;
|
|
|
|
if (phba == 0)
|
|
return;
|
|
spin_lock_irq(phba->host->host_lock);
|
|
/* If the timer is already canceled do nothing */
|
|
if (!(phba->work_hba_events & WORKER_ELS_TMO)) {
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
return;
|
|
}
|
|
timeout = (uint32_t)(phba->fc_ratov << 1);
|
|
|
|
pring = &phba->sli.ring[LPFC_ELS_RING];
|
|
dlp = &pring->txcmplq;
|
|
|
|
list_for_each_entry_safe(piocb, tmp_iocb, &pring->txcmplq, list) {
|
|
cmd = &piocb->iocb;
|
|
|
|
if (piocb->iocb_flag & LPFC_IO_LIBDFC) {
|
|
continue;
|
|
}
|
|
pcmd = (struct lpfc_dmabuf *) piocb->context2;
|
|
elscmd = (uint32_t *) (pcmd->virt);
|
|
els_command = *elscmd;
|
|
|
|
if ((els_command == ELS_CMD_FARP)
|
|
|| (els_command == ELS_CMD_FARPR)) {
|
|
continue;
|
|
}
|
|
|
|
if (piocb->drvrTimeout > 0) {
|
|
if (piocb->drvrTimeout >= timeout) {
|
|
piocb->drvrTimeout -= timeout;
|
|
} else {
|
|
piocb->drvrTimeout = 0;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
list_del(&piocb->list);
|
|
pring->txcmplq_cnt--;
|
|
|
|
if (cmd->ulpCommand == CMD_GEN_REQUEST64_CR) {
|
|
struct lpfc_nodelist *ndlp;
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
ndlp = lpfc_findnode_rpi(phba, cmd->ulpContext);
|
|
spin_lock_irq(phba->host->host_lock);
|
|
remote_ID = ndlp->nlp_DID;
|
|
if (cmd->un.elsreq64.bdl.ulpIoTag32) {
|
|
lpfc_sli_issue_abort_iotag32(phba,
|
|
pring, piocb);
|
|
}
|
|
} else {
|
|
remote_ID = cmd->un.elsreq64.remoteID;
|
|
}
|
|
|
|
lpfc_printf_log(phba,
|
|
KERN_ERR,
|
|
LOG_ELS,
|
|
"%d:0127 ELS timeout Data: x%x x%x x%x x%x\n",
|
|
phba->brd_no, els_command,
|
|
remote_ID, cmd->ulpCommand, cmd->ulpIoTag);
|
|
|
|
/*
|
|
* The iocb has timed out; abort it.
|
|
*/
|
|
if (piocb->iocb_cmpl) {
|
|
cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
|
|
cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
(piocb->iocb_cmpl) (phba, piocb, piocb);
|
|
spin_lock_irq(phba->host->host_lock);
|
|
} else
|
|
lpfc_sli_release_iocbq(phba, piocb);
|
|
}
|
|
if (phba->sli.ring[LPFC_ELS_RING].txcmplq_cnt)
|
|
mod_timer(&phba->els_tmofunc, jiffies + HZ * timeout);
|
|
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
}
|
|
|
|
void
|
|
lpfc_els_flush_cmd(struct lpfc_hba * phba)
|
|
{
|
|
struct lpfc_sli_ring *pring;
|
|
struct lpfc_iocbq *tmp_iocb, *piocb;
|
|
IOCB_t *cmd = NULL;
|
|
struct lpfc_dmabuf *pcmd;
|
|
uint32_t *elscmd;
|
|
uint32_t els_command;
|
|
|
|
pring = &phba->sli.ring[LPFC_ELS_RING];
|
|
spin_lock_irq(phba->host->host_lock);
|
|
list_for_each_entry_safe(piocb, tmp_iocb, &pring->txq, list) {
|
|
cmd = &piocb->iocb;
|
|
|
|
if (piocb->iocb_flag & LPFC_IO_LIBDFC) {
|
|
continue;
|
|
}
|
|
|
|
/* Do not flush out the QUE_RING and ABORT/CLOSE iocbs */
|
|
if ((cmd->ulpCommand == CMD_QUE_RING_BUF_CN) ||
|
|
(cmd->ulpCommand == CMD_QUE_RING_BUF64_CN) ||
|
|
(cmd->ulpCommand == CMD_CLOSE_XRI_CN) ||
|
|
(cmd->ulpCommand == CMD_ABORT_XRI_CN)) {
|
|
continue;
|
|
}
|
|
|
|
pcmd = (struct lpfc_dmabuf *) piocb->context2;
|
|
elscmd = (uint32_t *) (pcmd->virt);
|
|
els_command = *elscmd;
|
|
|
|
list_del(&piocb->list);
|
|
pring->txcmplq_cnt--;
|
|
|
|
cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
|
|
cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
|
|
|
|
if (piocb->iocb_cmpl) {
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
(piocb->iocb_cmpl) (phba, piocb, piocb);
|
|
spin_lock_irq(phba->host->host_lock);
|
|
} else
|
|
lpfc_sli_release_iocbq(phba, piocb);
|
|
}
|
|
|
|
list_for_each_entry_safe(piocb, tmp_iocb, &pring->txcmplq, list) {
|
|
cmd = &piocb->iocb;
|
|
|
|
if (piocb->iocb_flag & LPFC_IO_LIBDFC) {
|
|
continue;
|
|
}
|
|
pcmd = (struct lpfc_dmabuf *) piocb->context2;
|
|
elscmd = (uint32_t *) (pcmd->virt);
|
|
els_command = *elscmd;
|
|
|
|
list_del(&piocb->list);
|
|
pring->txcmplq_cnt--;
|
|
|
|
cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
|
|
cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
|
|
|
|
if (piocb->iocb_cmpl) {
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
(piocb->iocb_cmpl) (phba, piocb, piocb);
|
|
spin_lock_irq(phba->host->host_lock);
|
|
} else
|
|
lpfc_sli_release_iocbq(phba, piocb);
|
|
}
|
|
spin_unlock_irq(phba->host->host_lock);
|
|
return;
|
|
}
|
|
|
|
void
|
|
lpfc_els_unsol_event(struct lpfc_hba * phba,
|
|
struct lpfc_sli_ring * pring, struct lpfc_iocbq * elsiocb)
|
|
{
|
|
struct lpfc_sli *psli;
|
|
struct lpfc_nodelist *ndlp;
|
|
struct lpfc_dmabuf *mp;
|
|
uint32_t *lp;
|
|
IOCB_t *icmd;
|
|
struct ls_rjt stat;
|
|
uint32_t cmd;
|
|
uint32_t did;
|
|
uint32_t newnode;
|
|
uint32_t drop_cmd = 0; /* by default do NOT drop received cmd */
|
|
uint32_t rjt_err = 0;
|
|
|
|
psli = &phba->sli;
|
|
icmd = &elsiocb->iocb;
|
|
|
|
if ((icmd->ulpStatus == IOSTAT_LOCAL_REJECT) &&
|
|
((icmd->un.ulpWord[4] & 0xff) == IOERR_RCV_BUFFER_WAITING)) {
|
|
/* Not enough posted buffers; Try posting more buffers */
|
|
phba->fc_stat.NoRcvBuf++;
|
|
lpfc_post_buffer(phba, pring, 0, 1);
|
|
return;
|
|
}
|
|
|
|
/* If there are no BDEs associated with this IOCB,
|
|
* there is nothing to do.
|
|
*/
|
|
if (icmd->ulpBdeCount == 0)
|
|
return;
|
|
|
|
/* type of ELS cmd is first 32bit word in packet */
|
|
mp = lpfc_sli_ringpostbuf_get(phba, pring, getPaddr(icmd->un.
|
|
cont64[0].
|
|
addrHigh,
|
|
icmd->un.
|
|
cont64[0].addrLow));
|
|
if (mp == 0) {
|
|
drop_cmd = 1;
|
|
goto dropit;
|
|
}
|
|
|
|
newnode = 0;
|
|
lp = (uint32_t *) mp->virt;
|
|
cmd = *lp++;
|
|
lpfc_post_buffer(phba, &psli->ring[LPFC_ELS_RING], 1, 1);
|
|
|
|
if (icmd->ulpStatus) {
|
|
lpfc_mbuf_free(phba, mp->virt, mp->phys);
|
|
kfree(mp);
|
|
drop_cmd = 1;
|
|
goto dropit;
|
|
}
|
|
|
|
/* Check to see if link went down during discovery */
|
|
if (lpfc_els_chk_latt(phba)) {
|
|
lpfc_mbuf_free(phba, mp->virt, mp->phys);
|
|
kfree(mp);
|
|
drop_cmd = 1;
|
|
goto dropit;
|
|
}
|
|
|
|
did = icmd->un.rcvels.remoteID;
|
|
ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, did);
|
|
if (!ndlp) {
|
|
/* Cannot find existing Fabric ndlp, so allocate a new one */
|
|
ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
|
|
if (!ndlp) {
|
|
lpfc_mbuf_free(phba, mp->virt, mp->phys);
|
|
kfree(mp);
|
|
drop_cmd = 1;
|
|
goto dropit;
|
|
}
|
|
|
|
lpfc_nlp_init(phba, ndlp, did);
|
|
newnode = 1;
|
|
if ((did & Fabric_DID_MASK) == Fabric_DID_MASK) {
|
|
ndlp->nlp_type |= NLP_FABRIC;
|
|
}
|
|
ndlp->nlp_state = NLP_STE_UNUSED_NODE;
|
|
lpfc_nlp_list(phba, ndlp, NLP_UNUSED_LIST);
|
|
}
|
|
|
|
phba->fc_stat.elsRcvFrame++;
|
|
elsiocb->context1 = ndlp;
|
|
elsiocb->context2 = mp;
|
|
|
|
if ((cmd & ELS_CMD_MASK) == ELS_CMD_RSCN) {
|
|
cmd &= ELS_CMD_MASK;
|
|
}
|
|
/* ELS command <elsCmd> received from NPORT <did> */
|
|
lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
|
|
"%d:0112 ELS command x%x received from NPORT x%x "
|
|
"Data: x%x\n", phba->brd_no, cmd, did, phba->hba_state);
|
|
|
|
switch (cmd) {
|
|
case ELS_CMD_PLOGI:
|
|
phba->fc_stat.elsRcvPLOGI++;
|
|
if (phba->hba_state < LPFC_DISC_AUTH) {
|
|
rjt_err = 1;
|
|
break;
|
|
}
|
|
ndlp = lpfc_plogi_confirm_nport(phba, mp, ndlp);
|
|
lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_PLOGI);
|
|
break;
|
|
case ELS_CMD_FLOGI:
|
|
phba->fc_stat.elsRcvFLOGI++;
|
|
lpfc_els_rcv_flogi(phba, elsiocb, ndlp, newnode);
|
|
if (newnode) {
|
|
lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
|
|
}
|
|
break;
|
|
case ELS_CMD_LOGO:
|
|
phba->fc_stat.elsRcvLOGO++;
|
|
if (phba->hba_state < LPFC_DISC_AUTH) {
|
|
rjt_err = 1;
|
|
break;
|
|
}
|
|
lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_LOGO);
|
|
break;
|
|
case ELS_CMD_PRLO:
|
|
phba->fc_stat.elsRcvPRLO++;
|
|
if (phba->hba_state < LPFC_DISC_AUTH) {
|
|
rjt_err = 1;
|
|
break;
|
|
}
|
|
lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_PRLO);
|
|
break;
|
|
case ELS_CMD_RSCN:
|
|
phba->fc_stat.elsRcvRSCN++;
|
|
lpfc_els_rcv_rscn(phba, elsiocb, ndlp, newnode);
|
|
if (newnode) {
|
|
lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
|
|
}
|
|
break;
|
|
case ELS_CMD_ADISC:
|
|
phba->fc_stat.elsRcvADISC++;
|
|
if (phba->hba_state < LPFC_DISC_AUTH) {
|
|
rjt_err = 1;
|
|
break;
|
|
}
|
|
lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_ADISC);
|
|
break;
|
|
case ELS_CMD_PDISC:
|
|
phba->fc_stat.elsRcvPDISC++;
|
|
if (phba->hba_state < LPFC_DISC_AUTH) {
|
|
rjt_err = 1;
|
|
break;
|
|
}
|
|
lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_PDISC);
|
|
break;
|
|
case ELS_CMD_FARPR:
|
|
phba->fc_stat.elsRcvFARPR++;
|
|
lpfc_els_rcv_farpr(phba, elsiocb, ndlp);
|
|
break;
|
|
case ELS_CMD_FARP:
|
|
phba->fc_stat.elsRcvFARP++;
|
|
lpfc_els_rcv_farp(phba, elsiocb, ndlp);
|
|
break;
|
|
case ELS_CMD_FAN:
|
|
phba->fc_stat.elsRcvFAN++;
|
|
lpfc_els_rcv_fan(phba, elsiocb, ndlp);
|
|
break;
|
|
case ELS_CMD_PRLI:
|
|
phba->fc_stat.elsRcvPRLI++;
|
|
if (phba->hba_state < LPFC_DISC_AUTH) {
|
|
rjt_err = 1;
|
|
break;
|
|
}
|
|
lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_PRLI);
|
|
break;
|
|
case ELS_CMD_LIRR:
|
|
phba->fc_stat.elsRcvLIRR++;
|
|
lpfc_els_rcv_lirr(phba, elsiocb, ndlp);
|
|
if (newnode) {
|
|
lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
|
|
}
|
|
break;
|
|
case ELS_CMD_RPS:
|
|
phba->fc_stat.elsRcvRPS++;
|
|
lpfc_els_rcv_rps(phba, elsiocb, ndlp);
|
|
if (newnode) {
|
|
lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
|
|
}
|
|
break;
|
|
case ELS_CMD_RPL:
|
|
phba->fc_stat.elsRcvRPL++;
|
|
lpfc_els_rcv_rpl(phba, elsiocb, ndlp);
|
|
if (newnode) {
|
|
lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
|
|
}
|
|
break;
|
|
case ELS_CMD_RNID:
|
|
phba->fc_stat.elsRcvRNID++;
|
|
lpfc_els_rcv_rnid(phba, elsiocb, ndlp);
|
|
if (newnode) {
|
|
lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
|
|
}
|
|
break;
|
|
default:
|
|
/* Unsupported ELS command, reject */
|
|
rjt_err = 1;
|
|
|
|
/* Unknown ELS command <elsCmd> received from NPORT <did> */
|
|
lpfc_printf_log(phba, KERN_ERR, LOG_ELS,
|
|
"%d:0115 Unknown ELS command x%x received from "
|
|
"NPORT x%x\n", phba->brd_no, cmd, did);
|
|
if (newnode) {
|
|
lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
|
|
}
|
|
break;
|
|
}
|
|
|
|
/* check if need to LS_RJT received ELS cmd */
|
|
if (rjt_err) {
|
|
stat.un.b.lsRjtRsvd0 = 0;
|
|
stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
|
|
stat.un.b.lsRjtRsnCodeExp = LSEXP_NOTHING_MORE;
|
|
stat.un.b.vendorUnique = 0;
|
|
lpfc_els_rsp_reject(phba, stat.un.lsRjtError, elsiocb, ndlp);
|
|
}
|
|
|
|
if (elsiocb->context2) {
|
|
lpfc_mbuf_free(phba, mp->virt, mp->phys);
|
|
kfree(mp);
|
|
}
|
|
dropit:
|
|
/* check if need to drop received ELS cmd */
|
|
if (drop_cmd == 1) {
|
|
lpfc_printf_log(phba, KERN_ERR, LOG_ELS,
|
|
"%d:0111 Dropping received ELS cmd "
|
|
"Data: x%x x%x x%x\n", phba->brd_no,
|
|
icmd->ulpStatus, icmd->un.ulpWord[4],
|
|
icmd->ulpTimeout);
|
|
phba->fc_stat.elsRcvDrop++;
|
|
}
|
|
return;
|
|
}
|