/*******************************************************************************
**
*Copyright (c) 2014 PMC-Sierra, Inc. All rights reserved.
*
*Redistribution and use in source and binary forms, with or without modification, are permitted provided
*that the following conditions are met:
*1. Redistributions of source code must retain the above copyright notice, this list of conditions and the
*following disclaimer.
*2. Redistributions in binary form must reproduce the above copyright notice,
*this list of conditions and the following disclaimer in the documentation and/or other materials provided
*with the distribution.
*
*THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED
*WARRANTIES,INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
*FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
*FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
*NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
*BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
*LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
*SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
**
********************************************************************************/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <dev/pms/config.h>
#include <dev/pms/freebsd/driver/common/osenv.h>
#include <dev/pms/freebsd/driver/common/ostypes.h>
#include <dev/pms/freebsd/driver/common/osdebug.h>
#include <dev/pms/RefTisa/sallsdk/api/sa.h>
#include <dev/pms/RefTisa/sallsdk/api/saapi.h>
#include <dev/pms/RefTisa/sallsdk/api/saosapi.h>
#ifdef FDS_DM
#include <dev/pms/RefTisa/discovery/api/dm.h>
#include <dev/pms/RefTisa/discovery/api/dmapi.h>
#include <dev/pms/RefTisa/discovery/api/tddmapi.h>
#include <dev/pms/RefTisa/discovery/dm/dmdefs.h>
#include <dev/pms/RefTisa/discovery/dm/dmtypes.h>
#include <dev/pms/RefTisa/discovery/dm/dmproto.h>
/*****************************************************************************/
/*! \brief dmDiscover
*
*
* Purpose: A discovery is started by this function
*
* \param dmRoot: DM context handle.
* \param dmPortContext: Pointer to this instance of port context
* \param option: Discovery option
*
* \return:
* DM_RC_SUCCESS
* DM_RC_FAILURE
*
*/
/*****************************************************************************/
osGLOBAL bit32
dmDiscover(
dmRoot_t *dmRoot,
dmPortContext_t *dmPortContext,
bit32 option)
{
dmIntPortContext_t *onePortContext = agNULL;
bit32 ret = DM_RC_FAILURE;
DM_DBG3(("dmDiscover: start\n"));
onePortContext = (dmIntPortContext_t *)dmPortContext->dmData;
if (onePortContext == agNULL)
{
DM_DBG1(("dmDiscover: onePortContext is NULL!!!\n"));
return DM_RC_FAILURE;
}
if (onePortContext->valid == agFALSE)
{
DM_DBG1(("dmDiscover: invalid port!!!\n"));
return DM_RC_FAILURE;
}
if (onePortContext->RegFailed == agTRUE)
{
DM_DBG1(("dmDiscover: Registration failed!!!\n"));
return DM_RC_FAILURE;
}
switch ( option )
{
case DM_DISCOVERY_OPTION_FULL_START:
DM_DBG3(("dmDiscover: full, pid %d\n", onePortContext->id));
onePortContext->discovery.type = DM_DISCOVERY_OPTION_FULL_START;
dmDiscoveryResetMCN(dmRoot, onePortContext);
ret = dmFullDiscover(dmRoot, onePortContext);
break;
case DM_DISCOVERY_OPTION_INCREMENTAL_START:
DM_DBG3(("dmDiscover: incremental, pid %d\n", onePortContext->id));
onePortContext->discovery.type = DM_DISCOVERY_OPTION_INCREMENTAL_START;
dmDiscoveryResetMCN(dmRoot, onePortContext);
ret = dmIncrementalDiscover(dmRoot, onePortContext, agFALSE);
break;
case DM_DISCOVERY_OPTION_ABORT:
DM_DBG3(("dmDiscover: abort\n"));
if (onePortContext->DiscoveryState != DM_DSTATE_COMPLETED)
{
if (onePortContext->discovery.pendingSMP == 0)
{
dmDiscoverAbort(dmRoot, onePortContext);
tddmDiscoverCB(
dmRoot,
onePortContext->dmPortContext,
dmDiscAborted
);
}
else
{
DM_DBG3(("dmDiscover: abortInProgress\n"));
onePortContext->DiscoveryAbortInProgress = agTRUE;
tddmDiscoverCB(
dmRoot,
dmPortContext,
dmDiscAbortInProgress
);
}
}
else
{
DM_DBG3(("dmDiscover: no discovery to abort\n"));
tddmDiscoverCB(
dmRoot,
dmPortContext,
dmDiscAbortInvalid
);
}
ret = DM_RC_SUCCESS;
break;
default:
break;
}
return ret;
}
osGLOBAL bit32
dmFullDiscover(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext
)
{
dmExpander_t *oneExpander = agNULL;
dmSASSubID_t dmSASSubID;
dmDeviceData_t *oneExpDeviceData = agNULL;
DM_DBG1(("dmFullDiscover: start\n"));
if (onePortContext->valid == agFALSE)
{
DM_DBG1(("dmFullDiscover: invalid port!!!\n"));
return DM_RC_FAILURE;
}
if (onePortContext->DiscoveryState == DM_DSTATE_STARTED)
{
DM_DBG1(("dmFullDiscover: no two instances of discovery allowed!!!\n"));
return DM_RC_FAILURE;
}
onePortContext->DiscoveryState = DM_DSTATE_STARTED;
dmSASSubID.sasAddressHi = onePortContext->sasRemoteAddressHi;
dmSASSubID.sasAddressLo = onePortContext->sasRemoteAddressLo;
/* check OnePortContext->discovery.discoveringExpanderList */
oneExpander = dmExpFind(dmRoot, onePortContext, dmSASSubID.sasAddressHi, dmSASSubID.sasAddressLo);
if (oneExpander != agNULL)
{
oneExpDeviceData = oneExpander->dmDevice;
}
else
{
/* check dmAllShared->mainExpanderList */
oneExpander = dmExpMainListFind(dmRoot, onePortContext, dmSASSubID.sasAddressHi, dmSASSubID.sasAddressLo);
if (oneExpander != agNULL)
{
oneExpDeviceData = oneExpander->dmDevice;
}
}
if (oneExpDeviceData != agNULL)
{
dmSASSubID.initiator_ssp_stp_smp = oneExpDeviceData->initiator_ssp_stp_smp;
dmSASSubID.target_ssp_stp_smp = oneExpDeviceData->target_ssp_stp_smp;
oneExpDeviceData->registered = agTRUE;
dmAddSASToSharedcontext(dmRoot, onePortContext, &dmSASSubID, oneExpDeviceData, 0xFF);
}
else
{
DM_DBG1(("dmFullDiscover:oneExpDeviceData is NULL!!!\n"));
return DM_RC_FAILURE;
}
dmUpStreamDiscoverStart(dmRoot, onePortContext);
return DM_RC_SUCCESS;
}
osGLOBAL bit32
dmIncrementalDiscover(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
bit32 flag
)
{
dmExpander_t *oneExpander = agNULL;
dmSASSubID_t dmSASSubID;
dmDeviceData_t *oneExpDeviceData = agNULL;
DM_DBG1(("dmIncrementalDiscover: start\n"));
if (onePortContext->valid == agFALSE)
{
DM_DBG1(("dmIncrementalDiscover: invalid port!!!\n"));
return DM_RC_FAILURE;
}
/* TDM triggerred; let go DM triggerred */
if (flag == agFALSE)
{
if (onePortContext->DiscoveryState == DM_DSTATE_STARTED)
{
DM_DBG1(("dmIncrementalDiscover: no two instances of discovery allowed!!!\n"));
return DM_RC_FAILURE;
}
}
onePortContext->DiscoveryState = DM_DSTATE_STARTED;
onePortContext->discovery.type = DM_DISCOVERY_OPTION_INCREMENTAL_START;
dmSASSubID.sasAddressHi = onePortContext->sasRemoteAddressHi;
dmSASSubID.sasAddressLo = onePortContext->sasRemoteAddressLo;
/* check OnePortContext->discovery.discoveringExpanderList */
oneExpander = dmExpFind(dmRoot, onePortContext, dmSASSubID.sasAddressHi, dmSASSubID.sasAddressLo);
if (oneExpander != agNULL)
{
oneExpDeviceData = oneExpander->dmDevice;
}
else
{
/* check dmAllShared->mainExpanderList */
oneExpander = dmExpMainListFind(dmRoot, onePortContext, dmSASSubID.sasAddressHi, dmSASSubID.sasAddressLo);
if (oneExpander != agNULL)
{
oneExpDeviceData = oneExpander->dmDevice;
}
}
if (oneExpDeviceData != agNULL)
{
dmSASSubID.initiator_ssp_stp_smp = oneExpDeviceData->initiator_ssp_stp_smp;
dmSASSubID.target_ssp_stp_smp = oneExpDeviceData->target_ssp_stp_smp;
oneExpDeviceData->registered = agTRUE;
dmAddSASToSharedcontext(dmRoot, onePortContext, &dmSASSubID, oneExpDeviceData, 0xFF);
}
else
{
DM_DBG1(("dmIncrementalDiscover:oneExpDeviceData is NULL!!!\n"));
return DM_RC_FAILURE;
}
dmUpStreamDiscoverStart(dmRoot, onePortContext);
return DM_RC_SUCCESS;
}
osGLOBAL void
dmUpStreamDiscoverStart(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext
)
{
// dmExpander_t *oneExpander = agNULL;
bit32 sasAddressHi, sasAddressLo;
dmDeviceData_t *oneDeviceData;
dmExpander_t *oneExpander = agNULL;
DM_DBG3(("dmUpStreamDiscoverStart: start\n"));
if (onePortContext->valid == agFALSE)
{
DM_DBG1(("dmUpStreamDiscoverStart: invalid port!!!\n"));
return;
}
/*
at this point, the 1st expander should have been registered.
find an expander from onePortContext
*/
sasAddressHi = onePortContext->sasRemoteAddressHi;
sasAddressLo = onePortContext->sasRemoteAddressLo;
DM_DBG3(("dmUpStreamDiscoverStart: Port Remote AddrHi 0x%08x Remote AddrLo 0x%08x\n", sasAddressHi, sasAddressLo));
oneDeviceData = dmDeviceFind(dmRoot, onePortContext, sasAddressHi, sasAddressLo);
// oneDeviceData = oneExpander->dmDevice;
// start here
onePortContext->discovery.status = DISCOVERY_UP_STREAM;
if (oneDeviceData == agNULL)
{
DM_DBG1(("dmUpStreamDiscoverStart: oneExpander is NULL, wrong!!!\n"));
return;
}
else
{
if ( (oneDeviceData->SASSpecDeviceType == SAS_EDGE_EXPANDER_DEVICE)
||
(oneDeviceData->SASSpecDeviceType == SAS_FANOUT_EXPANDER_DEVICE)
||
DEVICE_IS_SMP_TARGET(oneDeviceData)
)
{
#if 1 /* for incremental discovery */
/* start here: if not on discoveringExpanderList, alloc and add
dmNewEXPorNot()
*/
oneExpander = dmExpFind(dmRoot, onePortContext, sasAddressHi, sasAddressLo);
if ( oneExpander == agNULL)
{
/* alloc and add */
oneExpander = dmDiscoveringExpanderAlloc(dmRoot, onePortContext, oneDeviceData);
if ( oneExpander != agNULL)
{
dmDiscoveringExpanderAdd(dmRoot, onePortContext, oneExpander);
}
else
{
DM_DBG1(("dmUpStreamDiscoverStart: failed to allocate expander or discovey aborted!!!\n"));
return;
}
}
#endif
dmUpStreamDiscovering(dmRoot, onePortContext, oneDeviceData);
}
else
{
DM_DBG1(("dmUpStreamDiscoverStart: oneDeviceData is not an Expander did %d, wrong!!!\n", oneDeviceData->id));
return;
}
}
return;
}
/* sends report general */
osGLOBAL void
dmUpStreamDiscovering(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
dmDeviceData_t *oneDeviceData
)
{
dmList_t *ExpanderList;
dmExpander_t *oneNextExpander = agNULL;
DM_DBG3(("dmUpStreamDiscovering: start\n"));
if (onePortContext->valid == agFALSE)
{
DM_DBG1(("dmUpStreamDiscovering: invalid port!!!\n"));
return;
}
tddmSingleThreadedEnter(dmRoot, DM_EXPANDER_LOCK);
if (DMLIST_EMPTY(&(onePortContext->discovery.discoveringExpanderList)))
{
tddmSingleThreadedLeave(dmRoot, DM_EXPANDER_LOCK);
DM_DBG3(("dmUpStreamDiscovering: should be the end\n"));
oneNextExpander = agNULL;
}
else
{
DMLIST_DEQUEUE_FROM_HEAD(&ExpanderList, &(onePortContext->discovery.discoveringExpanderList));
oneNextExpander = DMLIST_OBJECT_BASE(dmExpander_t, linkNode, ExpanderList);
if ( oneNextExpander != agNULL)
{
DMLIST_ENQUEUE_AT_HEAD(&(oneNextExpander->linkNode), &(onePortContext->discovery.discoveringExpanderList));
DM_DBG3(("dmUpStreamDiscovering tdsaSASUpStreamDiscovering: dequeue head\n"));
DM_DBG3(("dmUpStreamDiscovering: expander id %d\n", oneNextExpander->id));
}
else
{
DM_DBG1(("dmUpStreamDiscovering: oneNextExpander is NULL!!!\n"));
}
tddmSingleThreadedLeave(dmRoot, DM_EXPANDER_LOCK);
}
if (oneNextExpander != agNULL)
{
dmReportGeneralSend(dmRoot, oneNextExpander->dmDevice);
}
else
{
DM_DBG3(("dmUpStreamDiscovering: No more expander list\n"));
dmDownStreamDiscoverStart(dmRoot, onePortContext, oneDeviceData);
}
return;
}
osGLOBAL void
dmDownStreamDiscoverStart(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
dmDeviceData_t *oneDeviceData
)
{
dmExpander_t *UpStreamExpander;
dmExpander_t *oneExpander;
DM_DBG3(("dmDownStreamDiscoverStart: start\n"));
if (dmDiscoverCheck(dmRoot, onePortContext) == agTRUE)
{
DM_DBG1(("dmDownStreamDiscoverStart: invalid port or aborted discovery!!!\n"));
return;
}
/* set discovery status */
onePortContext->discovery.status = DISCOVERY_DOWN_STREAM;
/* If it's an expander */
if ( (oneDeviceData->SASSpecDeviceType == SAS_EDGE_EXPANDER_DEVICE)
|| (oneDeviceData->SASSpecDeviceType == SAS_FANOUT_EXPANDER_DEVICE)
|| DEVICE_IS_SMP_TARGET(oneDeviceData)
)
{
oneExpander = oneDeviceData->dmExpander;
UpStreamExpander = oneExpander->dmUpStreamExpander;
/* If the two expanders are the root of two edge sets; sub-to-sub */
if ( (UpStreamExpander != agNULL) && ( UpStreamExpander->dmUpStreamExpander == oneExpander ) )
{
DM_DBG3(("dmDownStreamDiscoverStart: Root found pExpander=%p pUpStreamExpander=%p\n",
oneExpander, UpStreamExpander));
//Saves the root expander
onePortContext->discovery.RootExp = oneExpander;
DM_DBG3(("dmDownStreamDiscoverStart: Root exp addrHi 0x%08x\n", oneExpander->dmDevice->SASAddressID.sasAddressHi));
DM_DBG3(("dmDownStreamDiscoverStart: Root exp addrLo 0x%08x\n", oneExpander->dmDevice->SASAddressID.sasAddressLo));
/* reset up stream inform for pExpander */
oneExpander->dmUpStreamExpander = agNULL;
/* Add the pExpander to discovering list */
dmDiscoveringExpanderAdd(dmRoot, onePortContext, oneExpander);
/* reset up stream inform for oneExpander */
UpStreamExpander->dmUpStreamExpander = agNULL;
/* Add the UpStreamExpander to discovering list */
dmDiscoveringExpanderAdd(dmRoot, onePortContext, UpStreamExpander);
}
/* If the two expanders are not the root of two edge sets. eg) one root */
else
{
//Saves the root expander
onePortContext->discovery.RootExp = oneExpander;
DM_DBG3(("dmDownStreamDiscoverStart: NO Root pExpander=%p\n", oneExpander));
DM_DBG3(("dmDownStreamDiscoverStart: Root exp addrHi 0x%08x\n", oneExpander->dmDevice->SASAddressID.sasAddressHi));
DM_DBG3(("dmDownStreamDiscoverStart: Root exp addrLo 0x%08x\n", oneExpander->dmDevice->SASAddressID.sasAddressLo));
/* (2.2.2.1) Add the pExpander to discovering list */
dmDiscoveringExpanderAdd(dmRoot, onePortContext, oneExpander);
}
}
/* Continue down stream discovering */
dmDownStreamDiscovering(dmRoot, onePortContext, oneDeviceData);
return;
}
osGLOBAL void
dmDownStreamDiscovering(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
dmDeviceData_t *oneDeviceData
)
{
dmExpander_t *NextExpander = agNULL;
dmList_t *ExpanderList;
DM_DBG3(("dmDownStreamDiscovering: start\n"));
if (dmDiscoverCheck(dmRoot, onePortContext) == agTRUE)
{
DM_DBG1(("dmDownStreamDiscovering: invalid port or aborted discovery!!!\n"));
return;
}
tddmSingleThreadedEnter(dmRoot, DM_EXPANDER_LOCK);
if (DMLIST_EMPTY(&(onePortContext->discovery.discoveringExpanderList)))
{
tddmSingleThreadedLeave(dmRoot, DM_EXPANDER_LOCK);
DM_DBG3(("dmDownStreamDiscovering: should be the end\n"));
NextExpander = agNULL;
}
else
{
DMLIST_DEQUEUE_FROM_HEAD(&ExpanderList, &(onePortContext->discovery.discoveringExpanderList));
NextExpander = DMLIST_OBJECT_BASE(dmExpander_t, linkNode, ExpanderList);
if ( NextExpander != agNULL)
{
DMLIST_ENQUEUE_AT_HEAD(&(NextExpander->linkNode), &(onePortContext->discovery.discoveringExpanderList));
DM_DBG3(("dmDownStreamDiscovering tdsaSASDownStreamDiscovering: dequeue head\n"));
DM_DBG3(("dmDownStreamDiscovering: expander id %d\n", NextExpander->id));
}
else
{
DM_DBG1(("dmDownStreamDiscovering: NextExpander is NULL!!!\n"));
}
tddmSingleThreadedLeave(dmRoot, DM_EXPANDER_LOCK);
}
/* If there is an expander for continue discoving */
if ( NextExpander != agNULL)
{
DM_DBG3(("dmDownStreamDiscovering: Found pNextExpander=%p discoveryStatus=0x%x\n",
NextExpander, onePortContext->discovery.status));
switch (onePortContext->discovery.status)
{
/* If the discovery status is DISCOVERY_DOWN_STREAM */
case DISCOVERY_DOWN_STREAM:
/* Send report general for the next expander */
DM_DBG3(("dmDownStreamDiscovering: DownStream pNextExpander=%p\n", NextExpander));
DM_DBG3(("dmDownStreamDiscovering: oneDeviceData %p did %d\n", oneDeviceData, oneDeviceData->id));
DM_DBG3(("dmDownStreamDiscovering: oneExpander %p did %d\n", oneDeviceData->dmExpander, oneDeviceData->dmExpander->id));
DM_DBG3(("dmDownStreamDiscovering: 2nd oneDeviceData %p did %d\n", NextExpander->dmDevice, NextExpander->dmDevice->id));
DM_DBG3(("dmDownStreamDiscovering: 2nd oneExpander %p did %d\n", NextExpander, NextExpander->id));
DM_DBG3(("dmDownStreamDiscovering: 2nd used oneExpander %p did %d\n", NextExpander->dmDevice->dmExpander, NextExpander->dmDevice->dmExpander->id));
if (NextExpander != NextExpander->dmDevice->dmExpander)
{
DM_DBG3(("dmDownStreamDiscovering: wrong!!!\n"));
}
dmReportGeneralSend(dmRoot, NextExpander->dmDevice);
break;
/* If the discovery status is DISCOVERY_CONFIG_ROUTING */
case DISCOVERY_CONFIG_ROUTING:
case DISCOVERY_REPORT_PHY_SATA:
/* set discovery status */
onePortContext->discovery.status = DISCOVERY_DOWN_STREAM;
DM_DBG3(("dmDownStreamDiscovering: pPort->discovery.status=DISCOVERY_CONFIG_ROUTING, make it DOWN_STREAM\n"));
/* If not the last phy */
if ( NextExpander->discoveringPhyId < NextExpander->dmDevice->numOfPhys )
{
DM_DBG3(("dmDownStreamDiscovering: pNextExpander->discoveringPhyId=0x%x pNextExpander->numOfPhys=0x%x. Send More Discover\n",
NextExpander->discoveringPhyId, NextExpander->dmDevice->numOfPhys));
/* Send discover for the next expander */
dmDiscoverSend(dmRoot, NextExpander->dmDevice);
}
/* If it's the last phy */
else
{
DM_DBG3(("dmDownStreamDiscovering: Last Phy, remove expander%p start DownStream=%p\n",
NextExpander, NextExpander->dmDevice));
dmDiscoveringExpanderRemove(dmRoot, onePortContext, NextExpander);
dmDownStreamDiscovering(dmRoot, onePortContext, NextExpander->dmDevice);
}
break;
default:
DM_DBG3(("dmDownStreamDiscovering: *** Unknown pPort->discovery.status=0x%x\n", onePortContext->discovery.status));
}
}
/* If no expander for continue discoving */
else
{
DM_DBG3(("dmDownStreamDiscovering: No more expander DONE\n"));
/* discover done */
dmDiscoverDone(dmRoot, onePortContext, DM_RC_SUCCESS);
}
return;
}
osGLOBAL void
dmUpStreamDiscoverExpanderPhy(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
dmExpander_t *oneExpander,
smpRespDiscover_t *pDiscoverResp
)
{
agsaSASIdentify_t sasIdentify;
dmSASSubID_t dmSASSubID;
bit32 attachedSasHi, attachedSasLo;
dmExpander_t *AttachedExpander = agNULL;
bit8 connectionRate;
dmDeviceData_t *oneDeviceData = agNULL;
dmDeviceData_t *AttachedDevice = agNULL;
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
DM_DBG3(("dmUpStreamDiscoverExpanderPhy: start\n"));
if (dmDiscoverCheck(dmRoot, onePortContext) == agTRUE)
{
DM_DBG1(("dmUpStreamDiscoverExpanderPhy: invalid port or aborted discovery!!!\n"));
return;
}
if (oneExpander != oneExpander->dmDevice->dmExpander)
{
DM_DBG1(("dmUpStreamDiscoverExpanderPhy: wrong!!!\n"));
}
dm_memset(&sasIdentify, 0, sizeof(agsaSASIdentify_t));
oneDeviceData = oneExpander->dmDevice;
DM_DBG3(("dmUpStreamDiscoverExpanderPhy: Phy #%d of SAS %08x-%08x\n",
oneExpander->discoveringPhyId,
oneDeviceData->SASAddressID.sasAddressHi,
oneDeviceData->SASAddressID.sasAddressLo));
DM_DBG3((" Attached device: %s\n",
( DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == 0 ? "No Device" :
(DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == 1 ? "End Device" :
(DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == 2 ? "Edge Expander" : "Fanout Expander")))));
if ( DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) != SAS_NO_DEVICE)
{
DM_DBG3((" SAS address : %08x-%08x\n",
DISCRSP_GET_ATTACHED_SAS_ADDRESSHI(pDiscoverResp),
DISCRSP_GET_ATTACHED_SAS_ADDRESSLO(pDiscoverResp)));
DM_DBG3((" SSP Target : %d\n", DISCRSP_IS_SSP_TARGET(pDiscoverResp)?1:0));
DM_DBG3((" STP Target : %d\n", DISCRSP_IS_STP_TARGET(pDiscoverResp)?1:0));
DM_DBG3((" SMP Target : %d\n", DISCRSP_IS_SMP_TARGET(pDiscoverResp)?1:0));
DM_DBG3((" SATA DEVICE : %d\n", DISCRSP_IS_SATA_DEVICE(pDiscoverResp)?1:0));
DM_DBG3((" SSP Initiator : %d\n", DISCRSP_IS_SSP_INITIATOR(pDiscoverResp)?1:0));
DM_DBG3((" STP Initiator : %d\n", DISCRSP_IS_STP_INITIATOR(pDiscoverResp)?1:0));
DM_DBG3((" SMP Initiator : %d\n", DISCRSP_IS_SMP_INITIATOR(pDiscoverResp)?1:0));
DM_DBG3((" Phy ID : %d\n", pDiscoverResp->phyIdentifier));
DM_DBG3((" Attached Phy ID: %d\n", pDiscoverResp->attachedPhyIdentifier));
}
/* for debugging */
if (oneExpander->discoveringPhyId != pDiscoverResp->phyIdentifier)
{
DM_DBG1(("dmUpStreamDiscoverExpanderPhy: !!! Incorrect SMP response !!!\n"));
DM_DBG1(("dmUpStreamDiscoverExpanderPhy: Request PhyID #%d Response PhyID #%d !!!\n", oneExpander->discoveringPhyId, pDiscoverResp->phyIdentifier));
dmhexdump("NO_DEVICE", (bit8*)pDiscoverResp, sizeof(smpRespDiscover_t));
dmDiscoverDone(dmRoot, onePortContext, DM_RC_FAILURE);
return;
}
/* saving routing attribute for non self-configuring expanders */
oneExpander->routingAttribute[pDiscoverResp->phyIdentifier] = (bit8)DISCRSP_GET_ROUTINGATTRIB(pDiscoverResp);
if ( oneDeviceData->SASSpecDeviceType == SAS_FANOUT_EXPANDER_DEVICE )
{
DM_DBG3(("dmUpStreamDiscoverExpanderPhy: SA_SAS_DEV_TYPE_FANOUT_EXPANDER\n"));
if ( DISCRSP_GET_ROUTINGATTRIB(pDiscoverResp) == SAS_ROUTING_SUBTRACTIVE)
{
DM_DBG1(("dmUpStreamDiscoverExpanderPhy: **** Topology Error subtractive routing on fanout expander device!!!\n"));
/* discovery error */
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo
= DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi
= DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier = oneExpander->discoveringPhyId;
DM_DBG1(("dmUpStreamDiscoverExpanderPhy: sasAddressHi 0x%08x sasAddressLo 0x%08x phyid 0x%x\n",
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi,
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo,
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier));
/* (2.1.3) discovery done */
dmDiscoverDone(dmRoot, onePortContext, DM_RC_FAILURE);
return;
}
}
else
{
DM_DBG3(("dmUpStreamDiscoverExpanderPhy: SA_SAS_DEV_TYPE_EDGE_EXPANDER\n"));
if ( DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) != SAS_NO_DEVICE)
{
/* Setup sasIdentify for the attached device */
sasIdentify.phyIdentifier = pDiscoverResp->phyIdentifier;
sasIdentify.deviceType_addressFrameType = (bit8)(pDiscoverResp->attachedDeviceType & 0x70);
sasIdentify.initiator_ssp_stp_smp = pDiscoverResp->attached_Ssp_Stp_Smp_Sata_Initiator;
sasIdentify.target_ssp_stp_smp = pDiscoverResp->attached_SataPS_Ssp_Stp_Smp_Sata_Target;
*(bit32*)sasIdentify.sasAddressHi = *(bit32*)pDiscoverResp->attachedSasAddressHi;
*(bit32*)sasIdentify.sasAddressLo = *(bit32*)pDiscoverResp->attachedSasAddressLo;
/* incremental discovery */
dmSASSubID.sasAddressHi = SA_IDFRM_GET_SAS_ADDRESSHI(&sasIdentify);
dmSASSubID.sasAddressLo = SA_IDFRM_GET_SAS_ADDRESSLO(&sasIdentify);
dmSASSubID.initiator_ssp_stp_smp = sasIdentify.initiator_ssp_stp_smp;
dmSASSubID.target_ssp_stp_smp = sasIdentify.target_ssp_stp_smp;
attachedSasHi = DISCRSP_GET_ATTACHED_SAS_ADDRESSHI(pDiscoverResp);
attachedSasLo = DISCRSP_GET_ATTACHED_SAS_ADDRESSLO(pDiscoverResp);
/* If the phy has subtractive routing attribute */
if ( DISCRSP_GET_ROUTINGATTRIB(pDiscoverResp) == SAS_ROUTING_SUBTRACTIVE)
{
DM_DBG3(("dmUpStreamDiscoverExpanderPhy: SA_SAS_ROUTING_SUBTRACTIVE\n"));
/* Setup upstream phys */
dmExpanderUpStreamPhyAdd(dmRoot, oneExpander, (bit8) pDiscoverResp->attachedPhyIdentifier);
/* If the expander already has an upsteam device set up */
if (oneExpander->hasUpStreamDevice == agTRUE)
{
/* just to update MCN */
dmPortSASDeviceFind(dmRoot, onePortContext, attachedSasLo, attachedSasHi, oneDeviceData);
/* If the sas address doesn't match */
if ( ((oneExpander->upStreamSASAddressHi != attachedSasHi) ||
(oneExpander->upStreamSASAddressLo != attachedSasLo)) &&
(DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == SAS_EDGE_EXPANDER_DEVICE ||
DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == SAS_FANOUT_EXPANDER_DEVICE)
)
{
/* TODO: discovery error, callback */
DM_DBG1(("dmUpStreamDiscoverExpanderPhy: **** Topology Error subtractive routing error - inconsistent SAS address!!!\n"));
/* call back to notify discovery error */
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo
= DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi
= DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier = oneExpander->discoveringPhyId;
DM_DBG1(("dmUpStreamDiscoverExpanderPhy: sasAddressHi 0x%08x sasAddressLo 0x%08x phyid 0x%x\n",
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi,
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo,
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier));
/* discovery done */
dmDiscoverDone(dmRoot, onePortContext, DM_RC_FAILURE);
}
}
else
{
/* Setup SAS address for up stream device */
oneExpander->hasUpStreamDevice = agTRUE;
oneExpander->upStreamSASAddressHi = attachedSasHi;
oneExpander->upStreamSASAddressLo = attachedSasLo;
if ( (onePortContext->sasLocalAddressHi != attachedSasHi)
|| (onePortContext->sasLocalAddressLo != attachedSasLo) )
{
/* Find the device from the discovered list */
AttachedDevice = dmPortSASDeviceFind(dmRoot, onePortContext, attachedSasLo, attachedSasHi, oneDeviceData);
/* New device, If the device has been discovered before */
if ( AttachedDevice != agNULL) /* old device */
{
DM_DBG3(("dmUpStreamDiscoverExpanderPhy: Seen This Device Before\n"));
/* If attached device is an edge expander */
if ( AttachedDevice->SASSpecDeviceType == SAS_EDGE_EXPANDER_DEVICE)
{
/* The attached device is an expander */
AttachedExpander = AttachedDevice->dmExpander;
/* If the two expanders are the root of the two edge expander sets */
if ( (AttachedExpander->upStreamSASAddressHi ==
DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo))
&& (AttachedExpander->upStreamSASAddressLo ==
DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo)) )
{
/* Setup upstream expander for the pExpander */
oneExpander->dmUpStreamExpander = AttachedExpander;
}
/* If the two expanders are not the root of the two edge expander sets */
else
{
/* TODO: loop found, discovery error, callback */
DM_DBG1(("dmUpStreamDiscoverExpanderPhy: **** Topology Error loop detection!!!\n"));
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo
= DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi
= DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier = oneExpander->discoveringPhyId;
DM_DBG1(("dmUpStreamDiscoverExpanderPhy: sasAddressHi 0x%08x sasAddressLo 0x%08x phyid 0x%x\n",
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi,
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo,
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier));
/* discovery done */
dmDiscoverDone(dmRoot, onePortContext, DM_RC_FAILURE);
}
}
/* If attached device is not an edge expander */
else
{
/*TODO: should not happen, ASSERT */
DM_DBG3(("dmUpStreamDiscoverExpanderPhy, *** Attached Device is not Edge. Confused!!!\n"));
}
} /* AttachedExpander != agNULL */
/* New device, If the device has not been discovered before */
else /* new device */
{
/* Add the device */
DM_DBG3(("dmUpStreamDiscoverExpanderPhy: New device\n"));
/* read minimum rate from the configuration
onePortContext->LinkRate is SPC's local link rate
*/
connectionRate = (bit8)MIN(onePortContext->LinkRate, DISCRSP_GET_LINKRATE(pDiscoverResp));
DM_DBG3(("dmUpStreamDiscoverExpanderPhy: link rate 0x%x\n", onePortContext->LinkRate));
DM_DBG3(("dmUpStreamDiscoverExpanderPhy: negotiatedPhyLinkRate 0x%x\n", DISCRSP_GET_LINKRATE(pDiscoverResp)));
DM_DBG3(("dmUpStreamDiscoverExpanderPhy: connectionRate 0x%x\n", connectionRate));
if (DISCRSP_IS_STP_TARGET(pDiscoverResp) || DISCRSP_IS_SATA_DEVICE(pDiscoverResp))
{
/* incremental discovery */
if (onePortContext->discovery.type == DM_DISCOVERY_OPTION_FULL_START)
{
AttachedDevice = dmPortSASDeviceAdd(
dmRoot,
onePortContext,
sasIdentify,
agFALSE,
connectionRate,
dmAllShared->itNexusTimeout,
0,
STP_DEVICE_TYPE,
oneDeviceData,
oneExpander,
pDiscoverResp->phyIdentifier
);
}
else
{
/* incremental discovery */
AttachedDevice = dmFindRegNValid(
dmRoot,
onePortContext,
&dmSASSubID
);
/* not registered and not valid; add this*/
if (AttachedDevice == agNULL)
{
AttachedDevice = dmPortSASDeviceAdd(
dmRoot,
onePortContext,
sasIdentify,
agFALSE,
connectionRate,
dmAllShared->itNexusTimeout,
0,
STP_DEVICE_TYPE,
oneDeviceData,
oneExpander,
pDiscoverResp->phyIdentifier
);
}
}
} /* DISCRSP_IS_STP_TARGET(pDiscoverResp) || DISCRSP_IS_SATA_DEVICE(pDiscoverResp) */
else
{
/* incremental discovery */
if (onePortContext->discovery.type == DM_DISCOVERY_OPTION_FULL_START)
{
AttachedDevice = dmPortSASDeviceAdd(
dmRoot,
onePortContext,
sasIdentify,
agFALSE,
connectionRate,
dmAllShared->itNexusTimeout,
0,
SAS_DEVICE_TYPE,
oneDeviceData,
oneExpander,
pDiscoverResp->phyIdentifier
);
}
else
{
/* incremental discovery */
AttachedDevice = dmFindRegNValid(
dmRoot,
onePortContext,
&dmSASSubID
);
/* not registered and not valid; add this*/
if (AttachedDevice == agNULL)
{
AttachedDevice = dmPortSASDeviceAdd(
dmRoot,
onePortContext,
sasIdentify,
agFALSE,
connectionRate,
dmAllShared->itNexusTimeout,
0,
SAS_DEVICE_TYPE,
oneDeviceData,
oneExpander,
pDiscoverResp->phyIdentifier
);
}
}
}
/* If the device is added successfully */
if ( AttachedDevice != agNULL)
{
/* (3.1.2.3.2.3.2.1) callback about new device */
if ( DISCRSP_IS_SSP_TARGET(pDiscoverResp)
|| DISCRSP_IS_SSP_INITIATOR(pDiscoverResp)
|| DISCRSP_IS_SMP_INITIATOR(pDiscoverResp)
|| DISCRSP_IS_SMP_INITIATOR(pDiscoverResp) )
{
DM_DBG3(("dmUpStreamDiscoverExpanderPhy: Found SSP/SMP SAS %08x-%08x\n",
attachedSasHi, attachedSasLo));
}
else
{
DM_DBG3(("dmUpStreamDiscoverExpanderPhy: Found a SAS STP device.\n"));
}
/* If the attached device is an expander */
if ( (DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == SAS_EDGE_EXPANDER_DEVICE)
|| (DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == SAS_FANOUT_EXPANDER_DEVICE) )
{
/* Allocate an expander data structure */
AttachedExpander = dmDiscoveringExpanderAlloc(
dmRoot,
onePortContext,
AttachedDevice
);
DM_DBG3(("dmUpStreamDiscoverExpanderPhy: Found expander=%p\n", AttachedExpander));
/* If allocate successfully */
if ( AttachedExpander != agNULL)
{
/* Add the pAttachedExpander to discovering list */
dmDiscoveringExpanderAdd(dmRoot, onePortContext, AttachedExpander);
/* Setup upstream expander for the pExpander */
oneExpander->dmUpStreamExpander = AttachedExpander;
}
/* If failed to allocate */
else
{
DM_DBG1(("dmUpStreamDiscoverExpanderPhy: Failed to allocate expander data structure!!!\n"));
dmDiscoverDone(dmRoot, onePortContext, DM_RC_FAILURE);
}
}
/* If the attached device is an end device */
else
{
DM_DBG3(("dmUpStreamDiscoverExpanderPhy: Found end device\n"));
/* LP2006-05-26 added upstream device to the newly found device */
AttachedDevice->dmExpander = oneExpander;
oneExpander->dmUpStreamExpander = agNULL;
}
}
else
{
DM_DBG1(("dmUpStreamDiscoverExpanderPhy: Failed to add a device!!!\n"));
dmDiscoverDone(dmRoot, onePortContext, DM_RC_FAILURE);
}
} /* else, new device */
} /* onePortContext->sasLocalAddressLo != attachedSasLo */
} /* else */
} /* DISCRSP_GET_ROUTINGATTRIB(pDiscoverResp) == SAS_ROUTING_SUBTRACTIVE */
} /* DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) != SAS_NO_DEVICE */
} /* big else */
oneExpander->discoveringPhyId ++;
if (onePortContext->discovery.status == DISCOVERY_UP_STREAM)
{
if ( oneExpander->discoveringPhyId < oneDeviceData->numOfPhys )
{
DM_DBG3(("dmUpStreamDiscoverExpanderPhy: DISCOVERY_UP_STREAM find more ...\n"));
/* continue discovery for the next phy */
dmDiscoverSend(dmRoot, oneDeviceData);
}
else
{
DM_DBG3(("dmUpStreamDiscoverExpanderPhy: DISCOVERY_UP_STREAM last phy continue upstream..\n"));
/* for MCN */
dmUpdateAllAdjacent(dmRoot, onePortContext, oneDeviceData);
/* remove the expander from the discovering list */
dmDiscoveringExpanderRemove(dmRoot, onePortContext, oneExpander);
/* continue upstream discovering */
dmUpStreamDiscovering(dmRoot, onePortContext, oneDeviceData);
}
}
else
{
DM_DBG3(("dmUpStreamDiscoverExpanderPhy: onePortContext->discovery.status not in DISCOVERY_UP_STREAM; status %d\n", onePortContext->discovery.status));
}
DM_DBG3(("dmUpStreamDiscoverExpanderPhy: end return phyID#%d\n", oneExpander->discoveringPhyId - 1));
return;
}
osGLOBAL void
dmUpStreamDiscover2ExpanderPhy(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
dmExpander_t *oneExpander,
smpRespDiscover2_t *pDiscoverResp
)
{
dmDeviceData_t *oneDeviceData;
dmDeviceData_t *AttachedDevice = agNULL;
dmExpander_t *AttachedExpander;
agsaSASIdentify_t sasIdentify;
bit8 connectionRate;
bit32 attachedSasHi, attachedSasLo;
dmSASSubID_t dmSASSubID;
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
DM_DBG2(("dmUpStreamDiscover2ExpanderPhy: start\n"));
if (dmDiscoverCheck(dmRoot, onePortContext) == agTRUE)
{
DM_DBG1(("dmUpStreamDiscover2ExpanderPhy: invalid port or aborted discovery!!!\n"));
return;
}
if (oneExpander != oneExpander->dmDevice->dmExpander)
{
DM_DBG1(("dmUpStreamDiscover2ExpanderPhy: wrong!!!\n"));
}
dm_memset(&sasIdentify, 0, sizeof(agsaSASIdentify_t));
oneDeviceData = oneExpander->dmDevice;
DM_DBG2(("dmUpStreamDiscover2ExpanderPhy: Phy #%d of SAS %08x-%08x\n",
oneExpander->discoveringPhyId,
oneDeviceData->SASAddressID.sasAddressHi,
oneDeviceData->SASAddressID.sasAddressLo));
DM_DBG2((" Attached device: %s\n",
( SAS2_DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == 0 ? "No Device" :
(SAS2_DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == 1 ? "End Device" :
(SAS2_DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == 2 ? "Edge Expander" : "Fanout Expander")))));
if ( SAS2_DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) != SAS_NO_DEVICE)
{
DM_DBG2((" SAS address : %08x-%08x\n",
SAS2_DISCRSP_GET_ATTACHED_SAS_ADDRESSHI(pDiscoverResp),
SAS2_DISCRSP_GET_ATTACHED_SAS_ADDRESSLO(pDiscoverResp)));
DM_DBG2((" SSP Target : %d\n", SAS2_DISCRSP_IS_SSP_TARGET(pDiscoverResp)?1:0));
DM_DBG2((" STP Target : %d\n", SAS2_DISCRSP_IS_STP_TARGET(pDiscoverResp)?1:0));
DM_DBG2((" SMP Target : %d\n", SAS2_DISCRSP_IS_SMP_TARGET(pDiscoverResp)?1:0));
DM_DBG2((" SATA DEVICE : %d\n", SAS2_DISCRSP_IS_SATA_DEVICE(pDiscoverResp)?1:0));
DM_DBG2((" SSP Initiator : %d\n", SAS2_DISCRSP_IS_SSP_INITIATOR(pDiscoverResp)?1:0));
DM_DBG2((" STP Initiator : %d\n", SAS2_DISCRSP_IS_STP_INITIATOR(pDiscoverResp)?1:0));
DM_DBG2((" SMP Initiator : %d\n", SAS2_DISCRSP_IS_SMP_INITIATOR(pDiscoverResp)?1:0));
DM_DBG2((" Phy ID : %d\n", pDiscoverResp->phyIdentifier));
DM_DBG2((" Attached Phy ID: %d\n", pDiscoverResp->attachedPhyIdentifier));
}
if (oneExpander->discoveringPhyId != pDiscoverResp->phyIdentifier)
{
DM_DBG1(("dmUpStreamDiscover2ExpanderPhy: !!! Incorrect SMP response !!!\n"));
DM_DBG1(("dmUpStreamDiscover2ExpanderPhy: Request PhyID #%d Response PhyID #%d\n", oneExpander->discoveringPhyId, pDiscoverResp->phyIdentifier));
dmhexdump("NO_DEVICE", (bit8*)pDiscoverResp, sizeof(smpRespDiscover2_t));
dmDiscoverDone(dmRoot, onePortContext, DM_RC_FAILURE);
return;
}
/* saving routing attribute for non self-configuring expanders */
oneExpander->routingAttribute[pDiscoverResp->phyIdentifier] = SAS2_DISCRSP_GET_ROUTINGATTRIB(pDiscoverResp);
if ( oneDeviceData->SASSpecDeviceType == SAS_FANOUT_EXPANDER_DEVICE )
{
DM_DBG2(("dmUpStreamDiscover2ExpanderPhy: SA_SAS_DEV_TYPE_FANOUT_EXPANDER\n"));
if ( SAS2_DISCRSP_GET_ROUTINGATTRIB(pDiscoverResp) == SAS_ROUTING_SUBTRACTIVE)
{
DM_DBG1(("dmUpStreamDiscover2ExpanderPhy: **** Topology Error subtractive routing on fanout expander device!!!\n"));
/* discovery error */
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo
= DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi
= DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier = oneExpander->discoveringPhyId;
DM_DBG1(("dmUpStreamDiscover2ExpanderPhy: sasAddressHi 0x%08x sasAddressLo 0x%08x phyid 0x%x\n",
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi,
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo,
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier));
/* (2.1.3) discovery done */
dmDiscoverDone(dmRoot, onePortContext, DM_RC_FAILURE);
return;
}
}
else
{
DM_DBG2(("dmUpStreamDiscover2ExpanderPhy: SA_SAS_DEV_TYPE_EDGE_EXPANDER\n"));
if ( SAS2_DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) != SAS_NO_DEVICE)
{
/* Setup sasIdentify for the attached device */
sasIdentify.phyIdentifier = pDiscoverResp->phyIdentifier;
sasIdentify.deviceType_addressFrameType = pDiscoverResp->attachedDeviceTypeReason & 0x70;
sasIdentify.initiator_ssp_stp_smp = pDiscoverResp->attached_Ssp_Stp_Smp_Sata_Initiator;
sasIdentify.target_ssp_stp_smp = pDiscoverResp->attached_SataPS_Ssp_Stp_Smp_Sata_Target;
*(bit32*)sasIdentify.sasAddressHi = *(bit32*)pDiscoverResp->attachedSasAddressHi;
*(bit32*)sasIdentify.sasAddressLo = *(bit32*)pDiscoverResp->attachedSasAddressLo;
/* incremental discovery */
dmSASSubID.sasAddressHi = SA_IDFRM_GET_SAS_ADDRESSHI(&sasIdentify);
dmSASSubID.sasAddressLo = SA_IDFRM_GET_SAS_ADDRESSLO(&sasIdentify);
dmSASSubID.initiator_ssp_stp_smp = sasIdentify.initiator_ssp_stp_smp;
dmSASSubID.target_ssp_stp_smp = sasIdentify.target_ssp_stp_smp;
attachedSasHi = SAS2_DISCRSP_GET_ATTACHED_SAS_ADDRESSHI(pDiscoverResp);
attachedSasLo = SAS2_DISCRSP_GET_ATTACHED_SAS_ADDRESSLO(pDiscoverResp);
/* If the phy has subtractive routing attribute */
if ( SAS2_DISCRSP_GET_ROUTINGATTRIB(pDiscoverResp) == SAS_ROUTING_SUBTRACTIVE)
{
DM_DBG2(("dmUpStreamDiscover2ExpanderPhy: SA_SAS_ROUTING_SUBTRACTIVE\n"));
/* Setup upstream phys */
dmExpanderUpStreamPhyAdd(dmRoot, oneExpander, (bit8) pDiscoverResp->attachedPhyIdentifier);
/* If the expander already has an upsteam device set up */
if (oneExpander->hasUpStreamDevice == agTRUE)
{
/* just to update MCN */
dmPortSASDeviceFind(dmRoot, onePortContext, attachedSasLo, attachedSasHi, oneDeviceData);
/* If the sas address doesn't match */
if ( ((oneExpander->upStreamSASAddressHi != attachedSasHi) ||
(oneExpander->upStreamSASAddressLo != attachedSasLo)) &&
(SAS2_DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == SAS_EDGE_EXPANDER_DEVICE ||
SAS2_DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == SAS_FANOUT_EXPANDER_DEVICE)
)
{
/* TODO: discovery error, callback */
DM_DBG1(("dmUpStreamDiscover2ExpanderPhy: **** Topology Error subtractive routing error - inconsistent SAS address!!!\n"));
/* call back to notify discovery error */
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo
= DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi
= DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier = oneExpander->discoveringPhyId;
DM_DBG1(("dmUpStreamDiscover2ExpanderPhy: sasAddressHi 0x%08x sasAddressLo 0x%08x phyid 0x%x\n",
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi,
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo,
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier));
/* discovery done */
dmDiscoverDone(dmRoot, onePortContext, DM_RC_FAILURE);
}
}
else
{
/* Setup SAS address for up stream device */
oneExpander->hasUpStreamDevice = agTRUE;
oneExpander->upStreamSASAddressHi = attachedSasHi;
oneExpander->upStreamSASAddressLo = attachedSasLo;
if ( (onePortContext->sasLocalAddressHi != attachedSasHi)
|| (onePortContext->sasLocalAddressLo != attachedSasLo) )
{
/* Find the device from the discovered list */
AttachedDevice = dmPortSASDeviceFind(dmRoot, onePortContext, attachedSasLo, attachedSasHi, oneDeviceData);
/* If the device has been discovered before */
if ( AttachedDevice != agNULL)
{
DM_DBG2(("dmUpStreamDiscover2ExpanderPhy: Seen This Device Before\n"));
/* If attached device is an edge expander */
if ( AttachedDevice->SASSpecDeviceType == SAS_EDGE_EXPANDER_DEVICE)
{
/* The attached device is an expander */
AttachedExpander = AttachedDevice->dmExpander;
/* If the two expanders are the root of the two edge expander sets */
if ( (AttachedExpander->upStreamSASAddressHi ==
DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo))
&& (AttachedExpander->upStreamSASAddressLo ==
DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo)) )
{
/* Setup upstream expander for the pExpander */
oneExpander->dmUpStreamExpander = AttachedExpander;
}
/* If the two expanders are not the root of the two edge expander sets */
else
{
/* TODO: loop found, discovery error, callback */
DM_DBG1(("dmUpStreamDiscover2ExpanderPhy: **** Topology Error loop detection!!!\n"));
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo
= DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi
= DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier = oneExpander->discoveringPhyId;
DM_DBG1(("dmUpStreamDiscover2ExpanderPhy: sasAddressHi 0x%08x sasAddressLo 0x%08x phyid 0x%x\n",
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi,
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo,
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier));
/* discovery done */
dmDiscoverDone(dmRoot, onePortContext, DM_RC_FAILURE);
}
}
/* If attached device is not an edge expander */
else
{
/*TODO: should not happen, ASSERT */
DM_DBG1(("dmUpStreamDiscover2ExpanderPhy, *** Attached Device is not Edge. Confused!!!\n"));
}
}
/* If the device has not been discovered before */
else
{
/* Add the device */
DM_DBG2(("dmUpStreamDiscover2ExpanderPhy: New device\n"));
/* read minimum rate from the configuration
onePortContext->LinkRate is SPC's local link rate
*/
connectionRate = MIN(onePortContext->LinkRate, SAS2_DISCRSP_GET_LOGICAL_LINKRATE(pDiscoverResp));
DM_DBG2(("dmUpStreamDiscover2ExpanderPhy: link rate 0x%x\n", onePortContext->LinkRate));
DM_DBG2(("dmUpStreamDiscover2ExpanderPhy: negotiatedPhyLinkRate 0x%x\n", SAS2_DISCRSP_GET_LINKRATE(pDiscoverResp)));
DM_DBG2(("dmUpStreamDiscover2ExpanderPhy: connectionRate 0x%x\n", connectionRate));
//hhhhhhhh
if (SAS2_DISCRSP_IS_STP_TARGET(pDiscoverResp) || SAS2_DISCRSP_IS_SATA_DEVICE(pDiscoverResp))
{
/* incremental discovery */
if (onePortContext->discovery.type == DM_DISCOVERY_OPTION_FULL_START)
{
AttachedDevice = dmPortSASDeviceAdd(
dmRoot,
onePortContext,
sasIdentify,
agFALSE,
connectionRate,
dmAllShared->itNexusTimeout,
0,
STP_DEVICE_TYPE,
oneDeviceData,
oneExpander,
pDiscoverResp->phyIdentifier
);
}
else
{
/* incremental discovery */
AttachedDevice = dmFindRegNValid(
dmRoot,
onePortContext,
&dmSASSubID
);
/* not registered and not valid; add this*/
if (AttachedDevice == agNULL)
{
AttachedDevice = dmPortSASDeviceAdd(
dmRoot,
onePortContext,
sasIdentify,
agFALSE,
connectionRate,
dmAllShared->itNexusTimeout,
0,
STP_DEVICE_TYPE,
oneDeviceData,
oneExpander,
pDiscoverResp->phyIdentifier
);
}
}
}
else
{
/* incremental discovery */
if (onePortContext->discovery.type == DM_DISCOVERY_OPTION_FULL_START)
{
AttachedDevice = dmPortSASDeviceAdd(
dmRoot,
onePortContext,
sasIdentify,
agFALSE,
connectionRate,
dmAllShared->itNexusTimeout,
0,
SAS_DEVICE_TYPE,
oneDeviceData,
oneExpander,
pDiscoverResp->phyIdentifier
);
}
else
{
/* incremental discovery */
AttachedDevice = dmFindRegNValid(
dmRoot,
onePortContext,
&dmSASSubID
);
/* not registered and not valid; add this*/
if (AttachedDevice == agNULL)
{
AttachedDevice = dmPortSASDeviceAdd(
dmRoot,
onePortContext,
sasIdentify,
agFALSE,
connectionRate,
dmAllShared->itNexusTimeout,
0,
SAS_DEVICE_TYPE,
oneDeviceData,
oneExpander,
pDiscoverResp->phyIdentifier
);
}
}
}
/* If the device is added successfully */
if ( AttachedDevice != agNULL)
{
/* (3.1.2.3.2.3.2.1) callback about new device */
if ( SAS2_DISCRSP_IS_SSP_TARGET(pDiscoverResp)
|| SAS2_DISCRSP_IS_SSP_INITIATOR(pDiscoverResp)
|| SAS2_DISCRSP_IS_SMP_INITIATOR(pDiscoverResp)
|| SAS2_DISCRSP_IS_SMP_INITIATOR(pDiscoverResp) )
{
DM_DBG2(("dmUpStreamDiscover2ExpanderPhy: Found SSP/SMP SAS %08x-%08x\n",
attachedSasHi, attachedSasLo));
}
else
{
DM_DBG2(("dmUpStreamDiscover2ExpanderPhy: Found a SAS STP device.\n"));
}
/* If the attached device is an expander */
if ( (SAS2_DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == SAS_EDGE_EXPANDER_DEVICE)
|| (SAS2_DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == SAS_FANOUT_EXPANDER_DEVICE) )
{
/* Allocate an expander data structure */
AttachedExpander = dmDiscoveringExpanderAlloc(
dmRoot,
onePortContext,
AttachedDevice
);
DM_DBG2(("dmUpStreamDiscover2ExpanderPhy: Found expander=%p\n", AttachedExpander));
/* If allocate successfully */
if ( AttachedExpander != agNULL)
{
/* Add the pAttachedExpander to discovering list */
dmDiscoveringExpanderAdd(dmRoot, onePortContext, AttachedExpander);
/* Setup upstream expander for the pExpander */
oneExpander->dmUpStreamExpander = AttachedExpander;
}
/* If failed to allocate */
else
{
DM_DBG1(("dmUpStreamDiscover2ExpanderPhy, Failed to allocate expander data structure!!!\n"));
dmDiscoverDone(dmRoot, onePortContext, DM_RC_FAILURE);
}
}
/* If the attached device is an end device */
else
{
DM_DBG2(("dmUpStreamDiscover2ExpanderPhy: Found end device\n"));
/* LP2006-05-26 added upstream device to the newly found device */
AttachedDevice->dmExpander = oneExpander;
oneExpander->dmUpStreamExpander = agNULL;
}
}
else
{
DM_DBG1(("dmUpStreamDiscover2ExpanderPhy, Failed to add a device!!!\n"));
dmDiscoverDone(dmRoot, onePortContext, DM_RC_FAILURE);
}
}
}
}
} /* substractive routing */
}
}
oneExpander->discoveringPhyId ++;
if (onePortContext->discovery.status == DISCOVERY_UP_STREAM)
{
if ( oneExpander->discoveringPhyId < oneDeviceData->numOfPhys )
{
DM_DBG2(("dmUpStreamDiscover2ExpanderPhy: DISCOVERY_UP_STREAM find more ...\n"));
/* continue discovery for the next phy */
dmDiscoverSend(dmRoot, oneDeviceData);
}
else
{
DM_DBG2(("dmUpStreamDiscover2ExpanderPhy: DISCOVERY_UP_STREAM last phy continue upstream..\n"));
/* for MCN */
dmUpdateAllAdjacent(dmRoot, onePortContext, oneDeviceData);
/* remove the expander from the discovering list */
dmDiscoveringExpanderRemove(dmRoot, onePortContext, oneExpander);
/* continue upstream discovering */
dmUpStreamDiscovering(dmRoot, onePortContext, oneDeviceData);
}
}
else
{
DM_DBG2(("dmUpStreamDiscover2ExpanderPhy: onePortContext->discovery.status not in DISCOVERY_UP_STREAM; status %d\n", onePortContext->discovery.status));
}
DM_DBG2(("dmUpStreamDiscover2ExpanderPhy: end return phyID#%d\n", oneExpander->discoveringPhyId - 1));
return;
}
osGLOBAL void
dmDownStreamDiscoverExpanderPhy(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
dmExpander_t *oneExpander,
smpRespDiscover_t *pDiscoverResp
)
{
agsaSASIdentify_t sasIdentify;
dmSASSubID_t dmSASSubID;
bit32 attachedSasHi, attachedSasLo;
dmExpander_t *AttachedExpander;
dmExpander_t *UpStreamExpander;
dmExpander_t *ConfigurableExpander = agNULL;
bit8 connectionRate, negotiatedPhyLinkRate;
bit32 configSASAddressHi;
bit32 configSASAddressLo;
bit32 dupConfigSASAddr = agFALSE;
dmDeviceData_t *oneDeviceData;
dmDeviceData_t *AttachedDevice = agNULL;
bit32 SAS2SAS11Check = agFALSE;
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
DM_DBG3(("dmDownStreamDiscoverExpanderPhy: start\n"));
DM_DBG3(("dmDownStreamDiscoverExpanderPhy: exp addrHi 0x%08x\n", oneExpander->dmDevice->SASAddressID.sasAddressHi));
DM_DBG3(("dmDownStreamDiscoverExpanderPhy: exp addrLo 0x%08x\n", oneExpander->dmDevice->SASAddressID.sasAddressLo));
DM_ASSERT(dmRoot, "(dmDownStreamDiscoverExpanderPhy) dmRoot NULL");
DM_ASSERT(onePortContext, "(dmDownStreamDiscoverExpanderPhy) pPort NULL");
DM_ASSERT(oneExpander, "(dmDownStreamDiscoverExpanderPhy) pExpander NULL");
DM_ASSERT(pDiscoverResp, "(dmDownStreamDiscoverExpanderPhy) pDiscoverResp NULL");
DM_DBG3(("dmDownStreamDiscoverExpanderPhy: onePortContxt=%p oneExpander=%p\n", onePortContext, oneExpander));
if (dmDiscoverCheck(dmRoot, onePortContext) == agTRUE)
{
DM_DBG1(("dmDownStreamDiscoverExpanderPhy: invalid port or aborted discovery!!!\n"));
return;
}
if (oneExpander != oneExpander->dmDevice->dmExpander)
{
DM_DBG1(("dmDownStreamDiscoverExpanderPhy: wrong!!!\n"));
}
/* (1) Find the device structure of the expander */
oneDeviceData = oneExpander->dmDevice;
DM_ASSERT(oneDeviceData, "(dmDownStreamDiscoverExpanderPhy) pDevice NULL");
/* for debugging */
DM_DBG3(("dmDownStreamDiscoverExpanderPhy: Phy #%d of SAS %08x-%08x\n",
oneExpander->discoveringPhyId,
oneDeviceData->SASAddressID.sasAddressHi,
oneDeviceData->SASAddressID.sasAddressLo));
DM_DBG3((" Attached device: %s\n",
( DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == 0 ? "No Device" :
(DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == 1 ? "End Device" :
(DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == 2 ? "Edge Expander" : "Fanout Expander")))));
/* for debugging */
if (oneExpander->discoveringPhyId != pDiscoverResp->phyIdentifier)
{
DM_DBG1(("dmDownStreamDiscoverExpanderPhy: !!! Incorrect SMP response !!!\n"));
DM_DBG1(("dmDownStreamDiscoverExpanderPhy: Request PhyID #%d Response PhyID #%d !!!\n", oneExpander->discoveringPhyId, pDiscoverResp->phyIdentifier));
dmhexdump("NO_DEVICE", (bit8*)pDiscoverResp, sizeof(smpRespDiscover_t));
dmDiscoverDone(dmRoot, onePortContext, DM_RC_FAILURE);
return;
}
if ( DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) != SAS_NO_DEVICE)
{
DM_DBG3((" SAS address : %08x-%08x\n",
DISCRSP_GET_ATTACHED_SAS_ADDRESSHI(pDiscoverResp),
DISCRSP_GET_ATTACHED_SAS_ADDRESSLO(pDiscoverResp)));
DM_DBG3((" SSP Target : %d\n", DISCRSP_IS_SSP_TARGET(pDiscoverResp)?1:0));
DM_DBG3((" STP Target : %d\n", DISCRSP_IS_STP_TARGET(pDiscoverResp)?1:0));
DM_DBG3((" SMP Target : %d\n", DISCRSP_IS_SMP_TARGET(pDiscoverResp)?1:0));
DM_DBG3((" SATA DEVICE : %d\n", DISCRSP_IS_SATA_DEVICE(pDiscoverResp)?1:0));
DM_DBG3((" SSP Initiator : %d\n", DISCRSP_IS_SSP_INITIATOR(pDiscoverResp)?1:0));
DM_DBG3((" STP Initiator : %d\n", DISCRSP_IS_STP_INITIATOR(pDiscoverResp)?1:0));
DM_DBG3((" SMP Initiator : %d\n", DISCRSP_IS_SMP_INITIATOR(pDiscoverResp)?1:0));
DM_DBG3((" Phy ID : %d\n", pDiscoverResp->phyIdentifier));
DM_DBG3((" Attached Phy ID: %d\n", pDiscoverResp->attachedPhyIdentifier));
}
/* end for debugging */
/* saving routing attribute for non self-configuring expanders */
oneExpander->routingAttribute[pDiscoverResp->phyIdentifier] = DISCRSP_GET_ROUTINGATTRIB(pDiscoverResp);
oneExpander->discoverSMPAllowed = agTRUE;
/* If a device is attached */
if ( DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) != SAS_NO_DEVICE)
{
/* Setup sasIdentify for the attached device */
sasIdentify.phyIdentifier = pDiscoverResp->phyIdentifier;
sasIdentify.deviceType_addressFrameType = pDiscoverResp->attachedDeviceType & 0x70;
sasIdentify.initiator_ssp_stp_smp = pDiscoverResp->attached_Ssp_Stp_Smp_Sata_Initiator;
sasIdentify.target_ssp_stp_smp = pDiscoverResp->attached_SataPS_Ssp_Stp_Smp_Sata_Target;
*(bit32*)sasIdentify.sasAddressHi = *(bit32*)pDiscoverResp->attachedSasAddressHi;
*(bit32*)sasIdentify.sasAddressLo = *(bit32*)pDiscoverResp->attachedSasAddressLo;
/* incremental discovery */
dmSASSubID.sasAddressHi = SA_IDFRM_GET_SAS_ADDRESSHI(&sasIdentify);
dmSASSubID.sasAddressLo = SA_IDFRM_GET_SAS_ADDRESSLO(&sasIdentify);
dmSASSubID.initiator_ssp_stp_smp = sasIdentify.initiator_ssp_stp_smp;
dmSASSubID.target_ssp_stp_smp = sasIdentify.target_ssp_stp_smp;
attachedSasHi = DISCRSP_GET_ATTACHED_SAS_ADDRESSHI(pDiscoverResp);
attachedSasLo = DISCRSP_GET_ATTACHED_SAS_ADDRESSLO(pDiscoverResp);
/* If it's a direct routing */
if ( DISCRSP_GET_ROUTINGATTRIB(pDiscoverResp) == SAS_ROUTING_DIRECT)
{
/* If the attached device is an expander */
if ( (DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == SAS_FANOUT_EXPANDER_DEVICE)
|| (DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == SAS_EDGE_EXPANDER_DEVICE) )
{
DM_DBG1(("dmDownStreamDiscoverExpanderPhy: **** Topology Error direct routing can't connect to expander!!!\n"));
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo
= DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi
= DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier = oneExpander->discoveringPhyId;
DM_DBG1(("dmDownStreamDiscoverExpanderPhy: sasAddressHi 0x%08x sasAddressLo 0x%08x phyid 0x%x\n",
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi,
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo,
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier));
dmDiscoverDone(dmRoot, onePortContext, DM_RC_FAILURE);
return;
}
}
/* If the expander's attached device is not myself */
if ( (attachedSasHi != onePortContext->sasLocalAddressHi)
|| (attachedSasLo != onePortContext->sasLocalAddressLo) )
{
/* Find the attached device from discovered list */
AttachedDevice = dmPortSASDeviceFind(dmRoot, onePortContext, attachedSasLo, attachedSasHi, oneDeviceData);
/* If the device has not been discovered before */
if ( AttachedDevice == agNULL) //11
{
/* If the phy has subtractive routing attribute */
if ( DISCRSP_GET_ROUTINGATTRIB(pDiscoverResp) == SAS_ROUTING_SUBTRACTIVE &&
(DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == SAS_EDGE_EXPANDER_DEVICE ||
DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == SAS_FANOUT_EXPANDER_DEVICE)
)
{
/* TODO: discovery error, callback */
DM_DBG1(("dmDownStreamDiscoverExpanderPhy: Deferred!!! **** Topology Error subtractive routing error - inconsistent SAS address!!!\n"));
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo
= DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi
= DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier = oneExpander->discoveringPhyId;
DM_DBG1(("dmDownStreamDiscoverExpanderPhy: sasAddressHi 0x%08x sasAddressLo 0x%08x phyid 0x%x\n",
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi,
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo,
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier));
onePortContext->discovery.DeferredError = agTRUE;
}
else /* 11 */
{
/* Add the device */
/* read minimum rate from the configuration
onePortContext->LinkRate is SPC's local link rate
*/
connectionRate = MIN(onePortContext->LinkRate, DISCRSP_GET_LINKRATE(pDiscoverResp));
DM_DBG3(("dmDownStreamDiscoverExpanderPhy: link rate 0x%x\n", DEVINFO_GET_LINKRATE(&oneDeviceData->agDeviceInfo)));
DM_DBG3(("dmDownStreamDiscoverExpanderPhy: negotiatedPhyLinkRate 0x%x\n", DISCRSP_GET_LINKRATE(pDiscoverResp)));
DM_DBG3(("dmDownStreamDiscoverExpanderPhy: connectionRate 0x%x\n", connectionRate));
if (DISCRSP_IS_STP_TARGET(pDiscoverResp) || DISCRSP_IS_SATA_DEVICE(pDiscoverResp))
{
if (onePortContext->discovery.type == DM_DISCOVERY_OPTION_FULL_START)
{
AttachedDevice = dmPortSASDeviceAdd(
dmRoot,
onePortContext,
sasIdentify,
agFALSE,
connectionRate,
dmAllShared->itNexusTimeout,
0,
STP_DEVICE_TYPE,
oneDeviceData,
oneExpander,
pDiscoverResp->phyIdentifier
);
}
else
{
/* incremental discovery */
AttachedDevice = dmFindRegNValid(
dmRoot,
onePortContext,
&dmSASSubID
);
/* not registered and not valid; add this*/
if (AttachedDevice == agNULL)
{
AttachedDevice = dmPortSASDeviceAdd(
dmRoot,
onePortContext,
sasIdentify,
agFALSE,
connectionRate,
dmAllShared->itNexusTimeout,
0,
STP_DEVICE_TYPE,
oneDeviceData,
oneExpander,
pDiscoverResp->phyIdentifier
);
}
}
} /* DISCRSP_IS_STP_TARGET(pDiscoverResp) || DISCRSP_IS_SATA_DEVICE(pDiscoverResp) */
else /* 22 */
{
if (onePortContext->discovery.type == DM_DISCOVERY_OPTION_FULL_START)
{
AttachedDevice = dmPortSASDeviceAdd(
dmRoot,
onePortContext,
sasIdentify,
agFALSE,
connectionRate,
dmAllShared->itNexusTimeout,
0,
SAS_DEVICE_TYPE,
oneDeviceData,
oneExpander,
pDiscoverResp->phyIdentifier
);
}
else
{
/* incremental discovery */
AttachedDevice = dmFindRegNValid(
dmRoot,
onePortContext,
&dmSASSubID
);
/* not registered and not valid; add this*/
if (AttachedDevice == agNULL)
{
AttachedDevice = dmPortSASDeviceAdd(
dmRoot,
onePortContext,
sasIdentify,
agFALSE,
connectionRate,
dmAllShared->itNexusTimeout,
0,
SAS_DEVICE_TYPE,
oneDeviceData,
oneExpander,
pDiscoverResp->phyIdentifier
);
}
}
} /* else 22 */
DM_DBG3(("dmDownStreamDiscoverExpanderPhy: newDevice pDevice=%p\n", AttachedDevice));
/* If the device is added successfully */
if ( AttachedDevice != agNULL)
{
if ( SA_IDFRM_IS_SSP_TARGET(&sasIdentify)
|| SA_IDFRM_IS_SMP_TARGET(&sasIdentify)
|| SA_IDFRM_IS_SSP_INITIATOR(&sasIdentify)
|| SA_IDFRM_IS_SMP_INITIATOR(&sasIdentify) )
{
DM_DBG3(("dmDownStreamDiscoverExpanderPhy: Report a new SAS device !!\n"));
}
else
{
if ( SA_IDFRM_IS_STP_TARGET(&sasIdentify) ||
SA_IDFRM_IS_SATA_DEVICE(&sasIdentify) )
{
DM_DBG3(("dmDownStreamDiscoverExpanderPhy: Found an STP or SATA device.\n"));
}
else
{
DM_DBG3(("dmDownStreamDiscoverExpanderPhy: Found Other type of device.\n"));
}
}
/* LP2006-05-26 added upstream device to the newly found device */
AttachedDevice->dmExpander = oneExpander;
DM_DBG3(("dmDownStreamDiscoverExpanderPhy: AttachedDevice %p did %d\n", AttachedDevice, AttachedDevice->id));
DM_DBG3(("dmDownStreamDiscoverExpanderPhy: Attached oneExpander %p did %d\n", AttachedDevice->dmExpander, AttachedDevice->dmExpander->id));
DM_DBG3(("dmDownStreamDiscoverExpanderPhy: oneDeviceData %p did %d\n", oneDeviceData, oneDeviceData->id));
DM_DBG3(("dmDownStreamDiscoverExpanderPhy: oneExpander %p did %d\n", oneDeviceData->dmExpander, oneDeviceData->dmExpander->id));
/* If the phy has table routing attribute */
if ( DISCRSP_GET_ROUTINGATTRIB(pDiscoverResp) == SAS_ROUTING_TABLE)
{
/* If the attached device is a fan out expander */
if ( DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == SAS_FANOUT_EXPANDER_DEVICE)
{
/* TODO: discovery error, callback */
DM_DBG1(("dmDownStreamDiscoverExpanderPhy: **** Topology Error two table routing phys are connected!!!\n"));
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo
= DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi
= DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier = oneExpander->discoveringPhyId;
DM_DBG1(("dmDownStreamDiscoverExpanderPhy: sasAddressHi 0x%08x sasAddressLo 0x%08x phyid 0x%x\n",
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi,
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo,
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier));
/* discovery done */
dmDiscoverDone(dmRoot, onePortContext, DM_RC_FAILURE);
}
else if ( DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == SAS_EDGE_EXPANDER_DEVICE)
{
/* Allocate an expander data structure */
AttachedExpander = dmDiscoveringExpanderAlloc(dmRoot, onePortContext, AttachedDevice);
DM_DBG3(("dmDownStreamDiscoverExpanderPhy: Found a EDGE exp device.%p\n", AttachedExpander));
/* If allocate successfully */
if ( AttachedExpander != agNULL)
{
/* set up downstream information on configurable expander */
dmExpanderDownStreamPhyAdd(dmRoot, oneExpander, (bit8) oneExpander->discoveringPhyId);
/* Setup upstream information */
dmExpanderUpStreamPhyAdd(dmRoot, AttachedExpander, (bit8) oneExpander->discoveringPhyId);
AttachedExpander->hasUpStreamDevice = agTRUE;
AttachedExpander->upStreamSASAddressHi
= DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo);
AttachedExpander->upStreamSASAddressLo
= DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo);
AttachedExpander->dmUpStreamExpander = oneExpander;
/* (2.3.2.2.2.2.2.2.2) Add the pAttachedExpander to discovering list */
dmDiscoveringExpanderAdd(dmRoot, onePortContext, AttachedExpander);
}
/* If failed to allocate */
else
{
DM_DBG1(("dmDownStreamDiscoverExpanderPhy: Failed to allocate expander data structure!!!\n"));
/* discovery done */
dmDiscoverDone(dmRoot, onePortContext, DM_RC_FAILURE);
}
}
} /* DISCRSP_GET_ROUTINGATTRIB(pDiscoverResp) == SAS_ROUTING_TABLE */
/* If status is still DISCOVERY_DOWN_STREAM */
if ( onePortContext->discovery.status == DISCOVERY_DOWN_STREAM)
{
DM_DBG3(("dmDownStreamDiscoverExpanderPhy: 1st before\n"));
dmDumpAllUpExp(dmRoot, onePortContext, oneExpander);
UpStreamExpander = oneExpander->dmUpStreamExpander;
ConfigurableExpander = dmFindConfigurableExp(dmRoot, onePortContext, oneExpander);
configSASAddressHi = DEVINFO_GET_SAS_ADDRESSHI(&AttachedDevice->agDeviceInfo);
configSASAddressLo = DEVINFO_GET_SAS_ADDRESSLO(&AttachedDevice->agDeviceInfo);
if (ConfigurableExpander)
{
if ( (ConfigurableExpander->dmDevice->SASAddressID.sasAddressHi
== DEVINFO_GET_SAS_ADDRESSHI(&AttachedDevice->agDeviceInfo)) &&
(ConfigurableExpander->dmDevice->SASAddressID.sasAddressLo
== DEVINFO_GET_SAS_ADDRESSLO(&AttachedDevice->agDeviceInfo))
)
{ /* directly attached between oneExpander and ConfigurableExpander */
DM_DBG3(("dmDownStreamDiscoverExpanderPhy: 1st before loc 1\n"));
configSASAddressHi = oneExpander->dmDevice->SASAddressID.sasAddressHi;
configSASAddressLo = oneExpander->dmDevice->SASAddressID.sasAddressLo;
}
else
{
DM_DBG3(("dmDownStreamDiscoverExpanderPhy: 1st before loc 2\n"));
configSASAddressHi = DEVINFO_GET_SAS_ADDRESSHI(&AttachedDevice->agDeviceInfo);
configSASAddressLo = DEVINFO_GET_SAS_ADDRESSLO(&AttachedDevice->agDeviceInfo);
}
} /* if !ConfigurableExpander */
dupConfigSASAddr = dmDuplicateConfigSASAddr(dmRoot,
ConfigurableExpander,
configSASAddressHi,
configSASAddressLo
);
if ( ConfigurableExpander && dupConfigSASAddr == agFALSE)
{
DM_DBG3(("dmDownStreamDiscoverExpanderPhy: 1st q123\n"));
UpStreamExpander->dmCurrentDownStreamExpander = oneExpander;
ConfigurableExpander->currentDownStreamPhyIndex =
dmFindCurrentDownStreamPhyIndex(dmRoot, ConfigurableExpander);
ConfigurableExpander->dmReturnginExpander = oneExpander;
dmRoutingEntryAdd(dmRoot,
ConfigurableExpander,
ConfigurableExpander->downStreamPhys[ConfigurableExpander->currentDownStreamPhyIndex],
configSASAddressHi,
configSASAddressLo
);
}
} /* onePortContext->discovery.status == DISCOVERY_DOWN_STREAM */
} /* AttachedDevice != agNULL */
/* If fail to add the device */
else
{
DM_DBG1(("dmDownStreamDiscoverExpanderPhy: Failed to add a device!!!\n"));
/* discovery done */
dmDiscoverDone(dmRoot, onePortContext, DM_RC_FAILURE);
}
} /* else 11 */
} /* AttachedDevice == agNULL */
/* If the device has been discovered before */
else /* haha discovered before 33 */
{
/* If the phy has subtractive routing attribute */
if ( DISCRSP_GET_ROUTINGATTRIB(pDiscoverResp) == SAS_ROUTING_SUBTRACTIVE)
{
/* If the expander doesn't have up stream device */
if ( oneExpander->hasUpStreamDevice == agFALSE)
{
/* TODO: discovery error, callback */
DM_DBG1(("dmDownStreamDiscoverExpanderPhy: **** Topology Error loop, or end device connects to two expanders!!!\n"));
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo
= DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi
= DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier = oneExpander->discoveringPhyId;
DM_DBG1(("dmDownStreamDiscoverExpanderPhy: sasAddressHi 0x%08x sasAddressLo 0x%08x phyid 0x%x\n",
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi,
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo,
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier));
/* discovery done */
dmDiscoverDone(dmRoot, onePortContext, DM_RC_FAILURE);
}
/* If the expander has up stream device */
else /* 44 */
{
/* If sas address doesn't match */
if ( (oneExpander->upStreamSASAddressHi != attachedSasHi)
|| (oneExpander->upStreamSASAddressLo != attachedSasLo) )
{
/* TODO: discovery error, callback */
DM_DBG1(("dmDownStreamDiscoverExpanderPhy: **** Topology Error two subtractive phys!!!\n"));
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo
= DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi
= DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier = oneExpander->discoveringPhyId;
DM_DBG1(("dmDownStreamDiscoverExpanderPhy: sasAddressHi 0x%08x sasAddressLo 0x%08x phyid 0x%x\n",
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi,
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo,
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier));
/* discovery done */
dmDiscoverDone(dmRoot, onePortContext, DM_RC_FAILURE);
}
} /* else 44 */
} /* DISCRSP_GET_ROUTINGATTRIB(pDiscoverResp) == SAS_ROUTING_SUBTRACTIVE */
/* If the phy has table routing attribute */
else if ( DISCRSP_GET_ROUTINGATTRIB(pDiscoverResp) == SAS_ROUTING_TABLE)
{
/* If the attached device is a fan out expander */
if ( DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == SAS_FANOUT_EXPANDER_DEVICE)
{
/* (2.3.3.2.1.1) TODO: discovery error, callback */
DM_DBG1(("dmDownStreamDiscoverExpanderPhy: **** Topology Error fan out expander to routing table phy!!!\n"));
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo
= DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi
= DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier = oneExpander->discoveringPhyId;
DM_DBG1(("dmDownStreamDiscoverExpanderPhy: sasAddressHi 0x%08x sasAddressLo 0x%08x phyid 0x%x\n",
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi,
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo,
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier));
/* discovery done */
dmDiscoverDone(dmRoot, onePortContext, DM_RC_FAILURE);
}
/* If the attached device is an edge expander */
else if ( DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == SAS_EDGE_EXPANDER_DEVICE)
{
/* Setup up stream inform */
AttachedExpander = AttachedDevice->dmExpander;
DM_DBG3(("dmDownStreamDiscoverExpanderPhy: Found edge expander=%p\n", AttachedExpander));
/* If the attached expander has up stream device */
if ( AttachedExpander->hasUpStreamDevice == agTRUE)
{
/* compare the sas address */
if ( (AttachedExpander->upStreamSASAddressHi
!= DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo))
|| (AttachedExpander->upStreamSASAddressLo
!= DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo)))
{
/* TODO: discovery error, callback */
SAS2SAS11Check = dmSAS2SAS11ErrorCheck(dmRoot, onePortContext, AttachedExpander, oneExpander, oneExpander);
if (SAS2SAS11Check == agTRUE)
{
DM_DBG1(("dmDownStreamDiscoverExpanderPhy: **** Topology Error SAS2 and SAS1.1!!!\n"));
}
else
{
DM_DBG1(("dmDownStreamDiscoverExpanderPhy: **** Topology Error two table routing phys connected (1)!!!\n"));
}
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo
= DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi
= DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier = oneExpander->discoveringPhyId;
DM_DBG1(("dmDownStreamDiscoverExpanderPhy: sasAddressHi 0x%08x sasAddressLo 0x%08x phyid 0x%x\n",
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi,
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo,
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier));
/* discovery done */
dmDiscoverDone(dmRoot, onePortContext, DM_RC_FAILURE);
}
else
{
DM_DBG3(("dmDownStreamDiscoverExpanderPhy: Add edge expander=%p\n", AttachedExpander));
/* set up downstream information on configurable expander */
dmExpanderDownStreamPhyAdd(dmRoot, oneExpander, (bit8) oneExpander->discoveringPhyId);
/* haha */
dmExpanderUpStreamPhyAdd(dmRoot, AttachedExpander, (bit8) oneExpander->discoveringPhyId);
/* Add the pAttachedExpander to discovering list */
dmDiscoveringExpanderAdd(dmRoot, onePortContext, AttachedExpander);
}
} /* AttachedExpander->hasUpStreamDevice == agTRUE */
/* If the attached expander doesn't have up stream device */
else
{
/* TODO: discovery error, callback */
DM_DBG1(("dmDownStreamDiscoverExpanderPhy: **** Topology Error two table routing phys connected (2)!!!\n"));
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo
= DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi
= DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier = oneExpander->discoveringPhyId;
DM_DBG1(("dmDownStreamDiscoverExpanderPhy: sasAddressHi 0x%08x sasAddressLo 0x%08x phyid 0x%x\n",
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi,
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo,
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier));
/* discovery done */
dmDiscoverDone(dmRoot, onePortContext, DM_RC_FAILURE);
}
} /* DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == SAS_EDGE_EXPANDER_DEVICE */
} /* DISCRSP_GET_ROUTINGATTRIB(pDiscoverResp) == SAS_ROUTING_TABLE */
/* do this regradless of sub or table */
/* If status is still DISCOVERY_DOWN_STREAM */
if ( onePortContext->discovery.status == DISCOVERY_DOWN_STREAM)
{
DM_DBG3(("dmDownStreamDiscoverExpanderPhy: 2nd before\n"));
dmDumpAllUpExp(dmRoot, onePortContext, oneExpander);
UpStreamExpander = oneExpander->dmUpStreamExpander;
ConfigurableExpander = dmFindConfigurableExp(dmRoot, onePortContext, oneExpander);
configSASAddressHi = DEVINFO_GET_SAS_ADDRESSHI(&AttachedDevice->agDeviceInfo);
configSASAddressLo = DEVINFO_GET_SAS_ADDRESSLO(&AttachedDevice->agDeviceInfo);
if (ConfigurableExpander)
{
if ( (ConfigurableExpander->dmDevice->SASAddressID.sasAddressHi
== DEVINFO_GET_SAS_ADDRESSHI(&AttachedDevice->agDeviceInfo)) &&
(ConfigurableExpander->dmDevice->SASAddressID.sasAddressLo
== DEVINFO_GET_SAS_ADDRESSLO(&AttachedDevice->agDeviceInfo))
)
{ /* directly attached between oneExpander and ConfigurableExpander */
DM_DBG3(("dmDownStreamDiscoverExpanderPhy: 2nd before loc 1\n"));
configSASAddressHi = oneExpander->dmDevice->SASAddressID.sasAddressHi;
configSASAddressLo = oneExpander->dmDevice->SASAddressID.sasAddressLo;
}
else
{
DM_DBG3(("dmDownStreamDiscoverExpanderPhy: 2nd before loc 2\n"));
configSASAddressHi = DEVINFO_GET_SAS_ADDRESSHI(&AttachedDevice->agDeviceInfo);
configSASAddressLo = DEVINFO_GET_SAS_ADDRESSLO(&AttachedDevice->agDeviceInfo);
}
} /* if !ConfigurableExpander */
dupConfigSASAddr = dmDuplicateConfigSASAddr(dmRoot,
ConfigurableExpander,
configSASAddressHi,
configSASAddressLo
);
if ( ConfigurableExpander && dupConfigSASAddr == agFALSE)
{
DM_DBG3(("dmDownStreamDiscoverExpanderPhy: 2nd q123 \n"));
UpStreamExpander->dmCurrentDownStreamExpander = oneExpander;
ConfigurableExpander->currentDownStreamPhyIndex =
dmFindCurrentDownStreamPhyIndex(dmRoot, ConfigurableExpander);
ConfigurableExpander->dmReturnginExpander = oneExpander;
dmRoutingEntryAdd(dmRoot,
ConfigurableExpander,
ConfigurableExpander->downStreamPhys[ConfigurableExpander->currentDownStreamPhyIndex],
configSASAddressHi,
configSASAddressLo
);
}
} /* onePortContext->discovery.status == DISCOVERY_DOWN_STREAM */
/* incremental discovery */
if (onePortContext->discovery.type == DM_DISCOVERY_OPTION_INCREMENTAL_START)
{
connectionRate = MIN(onePortContext->LinkRate, DISCRSP_GET_LINKRATE(pDiscoverResp));
if (DISCRSP_IS_STP_TARGET(pDiscoverResp) || DISCRSP_IS_SATA_DEVICE(pDiscoverResp))
{
DM_DBG3(("dmDownStreamDiscoverExpanderPhy: incremental SATA_STP\n"));
dmPortSASDeviceAdd(
dmRoot,
onePortContext,
sasIdentify,
agFALSE,
connectionRate,
dmAllShared->itNexusTimeout,
0,
STP_DEVICE_TYPE,
oneDeviceData,
oneExpander,
pDiscoverResp->phyIdentifier
);
}
else
{
DM_DBG3(("dmDownStreamDiscoverExpanderPhy: incremental SAS\n"));
dmPortSASDeviceAdd(
dmRoot,
onePortContext,
sasIdentify,
agFALSE,
connectionRate,
dmAllShared->itNexusTimeout,
0,
SAS_DEVICE_TYPE,
oneDeviceData,
oneExpander,
pDiscoverResp->phyIdentifier
);
}
} /* onePortContext->discovery.type == DM_DISCOVERY_OPTION_INCREMENTAL_START */
} /* else 33 */
} /* (attachedSasLo != onePortContext->sasLocalAddressLo) */
else /* else 44 */
{
DM_DBG3(("dmDownStreamDiscoverExpanderPhy: Found Self\n"));
DM_DBG3(("dmDownStreamDiscoverExpanderPhy: 3rd before\n"));
dmDumpAllUpExp(dmRoot, onePortContext, oneExpander);
UpStreamExpander = oneExpander->dmUpStreamExpander;
ConfigurableExpander = dmFindConfigurableExp(dmRoot, onePortContext, oneExpander);
dupConfigSASAddr = dmDuplicateConfigSASAddr(dmRoot,
ConfigurableExpander,
onePortContext->sasLocalAddressHi,
onePortContext->sasLocalAddressLo
);
if ( ConfigurableExpander && dupConfigSASAddr == agFALSE)
{
DM_DBG3(("dmDownStreamDiscoverExpanderPhy: 3rd q123 Setup routing table\n"));
UpStreamExpander->dmCurrentDownStreamExpander = oneExpander;
ConfigurableExpander->currentDownStreamPhyIndex =
dmFindCurrentDownStreamPhyIndex(dmRoot, ConfigurableExpander);
ConfigurableExpander->dmReturnginExpander = oneExpander;
dmRoutingEntryAdd(dmRoot,
ConfigurableExpander,
ConfigurableExpander->downStreamPhys[ConfigurableExpander->currentDownStreamPhyIndex],
onePortContext->sasLocalAddressHi,
onePortContext->sasLocalAddressLo
);
}
} /* else 44 */
} /* DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) != SAS_NO_DEVICE */
/* If no device is attached */
else
{
DM_DBG2(("!!!!!!!!!!!!!!!!!!!!! SPIN SATA !!!!!!!!!!!!!!!!!!!!!!!!!!!\n"));
negotiatedPhyLinkRate = DISCRSP_GET_LINKRATE(pDiscoverResp); // added by thenil
if (negotiatedPhyLinkRate == 0x03)
{
DM_DBG1(("dmDownStreamDiscover2ExpanderPhy: SPIN SATA sent reset\n"));
dmPhyControlSend(dmRoot,
oneDeviceData,
SMP_PHY_CONTROL_HARD_RESET,
pDiscoverResp->phyIdentifier
);
}
/* do nothing */
}
/* Increment the discovering phy id */
oneExpander->discoveringPhyId ++;
/* If the discovery status is DISCOVERY_DOWN_STREAM */
if ( onePortContext->discovery.status == DISCOVERY_DOWN_STREAM )
{
/* If not the last phy */
if ( oneExpander->discoveringPhyId < oneDeviceData->numOfPhys )
{
DM_DBG3(("dmDownStreamDiscoverExpanderPhy: More Phys to discover\n"));
/* continue discovery for the next phy */
dmDiscoverSend(dmRoot, oneDeviceData);
}
/* If the last phy */
else
{
DM_DBG3(("dmDownStreamDiscoverExpanderPhy: No More Phys\n"));
/* for MCN */
dmUpdateAllAdjacent(dmRoot, onePortContext, oneDeviceData);
/* remove the expander from the discovering list */
dmDiscoveringExpanderRemove(dmRoot, onePortContext, oneExpander);
/* continue downstream discovering */
dmDownStreamDiscovering(dmRoot, onePortContext, oneDeviceData);
}
}
else
{
DM_DBG3(("dmDownStreamDiscoverExpanderPhy: onePortContext->discovery.status not in DISCOVERY_DOWN_STREAM; status %d\n", onePortContext->discovery.status));
}
DM_DBG3(("dmDownStreamDiscoverExpanderPhy: end return phyID#%d\n", oneExpander->discoveringPhyId - 1));
return;
}
/* works at SAS2 expander (called in dmDownStreamDiscover2ExpanderPhy())
if currentExpander is SAS2, called in dmDownStreamDiscover2ExpanderPhy()
if currentExpander is SAS1.1, called in dmDownStreamDiscoverExpanderPhy()
*/
osGLOBAL bit32
dmSAS2SAS11ErrorCheck(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
dmExpander_t *topExpander,
dmExpander_t *bottomExpander,
dmExpander_t *currentExpander
)
{
bit32 result = agFALSE, i = 0;
bit8 downStreamPhyID, upStreamPhyID;
DM_DBG2(("dmSAS2SAS11ErrorCheck: start\n"));
if (topExpander == agNULL)
{
DM_DBG2(("dmSAS2SAS11ErrorCheck: topExpander is NULL\n"));
return result;
}
if (bottomExpander == agNULL)
{
DM_DBG2(("dmSAS2SAS11ErrorCheck: bottomExpander is NULL\n"));
return result;
}
if (currentExpander == agNULL)
{
DM_DBG2(("dmSAS2SAS11ErrorCheck: currentExpander is NULL\n"));
return result;
}
DM_DBG2(("dmSAS2SAS11ErrorCheck: topExpander addrHi 0x%08x addrLo 0x%08x\n",
topExpander->dmDevice->SASAddressID.sasAddressHi, topExpander->dmDevice->SASAddressID.sasAddressLo));
DM_DBG2(("dmSAS2SAS11ErrorCheck: bottomExpander addrHi 0x%08x addrLo 0x%08x\n",
bottomExpander->dmDevice->SASAddressID.sasAddressHi, bottomExpander->dmDevice->SASAddressID.sasAddressLo));
DM_DBG2(("dmSAS2SAS11ErrorCheck: currentExpander addrHi 0x%08x addrLo 0x%08x\n",
currentExpander->dmDevice->SASAddressID.sasAddressHi, currentExpander->dmDevice->SASAddressID.sasAddressLo));
for (i=0;i<DM_MAX_EXPANDER_PHYS;i++)
{
downStreamPhyID = topExpander->downStreamPhys[i];
upStreamPhyID = bottomExpander->upStreamPhys[i];
if (currentExpander->SAS2 == 1)
{
if ( downStreamPhyID == upStreamPhyID &&
topExpander->routingAttribute[downStreamPhyID] == SAS_ROUTING_TABLE &&
bottomExpander->routingAttribute[i] == SAS_ROUTING_SUBTRACTIVE &&
topExpander->SAS2 == 0 &&
bottomExpander->SAS2 == 1
)
{
result = agTRUE;
break;
}
}
else if (currentExpander->SAS2 == 0)
{
if ( downStreamPhyID == upStreamPhyID &&
topExpander->routingAttribute[downStreamPhyID] == SAS_ROUTING_SUBTRACTIVE &&
bottomExpander->routingAttribute[i] == SAS_ROUTING_TABLE &&
topExpander->SAS2 == 1 &&
bottomExpander->SAS2 == 0
)
{
result = agTRUE;
break;
}
}
}
return result;
}
osGLOBAL void
dmDownStreamDiscover2ExpanderPhy(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
dmExpander_t *oneExpander,
smpRespDiscover2_t *pDiscoverResp
)
{
dmDeviceData_t *oneDeviceData;
dmExpander_t *UpStreamExpander;
dmDeviceData_t *AttachedDevice = agNULL;
dmExpander_t *AttachedExpander;
agsaSASIdentify_t sasIdentify;
bit8 connectionRate;
bit32 attachedSasHi, attachedSasLo;
dmSASSubID_t dmSASSubID;
dmExpander_t *ConfigurableExpander = agNULL;
bit32 dupConfigSASAddr = agFALSE;
bit32 configSASAddressHi;
bit32 configSASAddressLo;
bit32 SAS2SAS11Check = agFALSE;
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
DM_DBG2(("dmDownStreamDiscover2ExpanderPhy: start\n"));
DM_DBG2(("dmDownStreamDiscover2ExpanderPhy: exp addrHi 0x%08x\n", oneExpander->dmDevice->SASAddressID.sasAddressHi));
DM_DBG2(("dmDownStreamDiscover2ExpanderPhy: exp addrLo 0x%08x\n", oneExpander->dmDevice->SASAddressID.sasAddressLo));
DM_ASSERT(dmRoot, "(dmDownStreamDiscover2ExpanderPhy) dmRoot NULL");
DM_ASSERT(onePortContext, "(dmDownStreamDiscover2ExpanderPhy) pPort NULL");
DM_ASSERT(oneExpander, "(dmDownStreamDiscover2ExpanderPhy) pExpander NULL");
DM_ASSERT(pDiscoverResp, "(dmDownStreamDiscover2ExpanderPhy) pDiscoverResp NULL");
DM_DBG2(("dmDownStreamDiscover2ExpanderPhy: onePortContxt=%p oneExpander=%p oneDeviceData=%p\n", onePortContext, oneExpander, oneExpander->dmDevice));
if (dmDiscoverCheck(dmRoot, onePortContext) == agTRUE)
{
DM_DBG1(("dmDownStreamDiscover2ExpanderPhy: invalid port or aborted discovery!!!\n"));
return;
}
if (oneExpander != oneExpander->dmDevice->dmExpander)
{
DM_DBG1(("dmDownStreamDiscover2ExpanderPhy: wrong!!!\n"));
}
/* (1) Find the device structure of the expander */
oneDeviceData = oneExpander->dmDevice;
DM_ASSERT(oneDeviceData, "(dmDownStreamDiscover2ExpanderPhy) pDevice NULL");
/* for debugging */
DM_DBG2(("dmDownStreamDiscover2ExpanderPhy: Phy #%d of SAS %08x-%08x\n",
oneExpander->discoveringPhyId,
oneDeviceData->SASAddressID.sasAddressHi,
oneDeviceData->SASAddressID.sasAddressLo));
DM_DBG2((" Attached device: %s\n",
( SAS2_DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == 0 ? "No Device" :
(SAS2_DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == 1 ? "End Device" :
(SAS2_DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == 2 ? "Edge Expander" : "Fanout Expander")))));
/* for debugging */
if (oneExpander->discoveringPhyId != pDiscoverResp->phyIdentifier)
{
DM_DBG1(("dmDownStreamDiscover2ExpanderPhy: !!! Incorrect SMP response !!!\n"));
DM_DBG1(("dmDownStreamDiscover2ExpanderPhy: Request PhyID #%d Response PhyID #%d\n", oneExpander->discoveringPhyId, pDiscoverResp->phyIdentifier));
dmhexdump("NO_DEVICE", (bit8*)pDiscoverResp, sizeof(smpRespDiscover2_t));
dmDiscoverDone(dmRoot, onePortContext, DM_RC_FAILURE);
return;
}
if ( SAS2_DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) != SAS_NO_DEVICE)
{
DM_DBG2((" SAS address : %08x-%08x\n",
SAS2_DISCRSP_GET_ATTACHED_SAS_ADDRESSHI(pDiscoverResp),
SAS2_DISCRSP_GET_ATTACHED_SAS_ADDRESSLO(pDiscoverResp)));
DM_DBG2((" SSP Target : %d\n", SAS2_DISCRSP_IS_SSP_TARGET(pDiscoverResp)?1:0));
DM_DBG2((" STP Target : %d\n", SAS2_DISCRSP_IS_STP_TARGET(pDiscoverResp)?1:0));
DM_DBG2((" SMP Target : %d\n", SAS2_DISCRSP_IS_SMP_TARGET(pDiscoverResp)?1:0));
DM_DBG2((" SATA DEVICE : %d\n", SAS2_DISCRSP_IS_SATA_DEVICE(pDiscoverResp)?1:0));
DM_DBG2((" SSP Initiator : %d\n", SAS2_DISCRSP_IS_SSP_INITIATOR(pDiscoverResp)?1:0));
DM_DBG2((" STP Initiator : %d\n", SAS2_DISCRSP_IS_STP_INITIATOR(pDiscoverResp)?1:0));
DM_DBG2((" SMP Initiator : %d\n", SAS2_DISCRSP_IS_SMP_INITIATOR(pDiscoverResp)?1:0));
DM_DBG2((" Phy ID : %d\n", pDiscoverResp->phyIdentifier));
DM_DBG2((" Attached Phy ID: %d\n", pDiscoverResp->attachedPhyIdentifier));
}
/* saving routing attribute for non self-configuring expanders */
oneExpander->routingAttribute[pDiscoverResp->phyIdentifier] = SAS2_DISCRSP_GET_ROUTINGATTRIB(pDiscoverResp);
oneExpander->discoverSMPAllowed = agTRUE;
/* If a device is attached */
if ( SAS2_DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) != SAS_NO_DEVICE)
{
/* Setup sasIdentify for the attached device */
sasIdentify.phyIdentifier = pDiscoverResp->phyIdentifier;
sasIdentify.deviceType_addressFrameType = pDiscoverResp->attachedDeviceTypeReason & 0x70;
sasIdentify.initiator_ssp_stp_smp = pDiscoverResp->attached_Ssp_Stp_Smp_Sata_Initiator;
sasIdentify.target_ssp_stp_smp = pDiscoverResp->attached_SataPS_Ssp_Stp_Smp_Sata_Target;
*(bit32*)sasIdentify.sasAddressHi = *(bit32*)pDiscoverResp->attachedSasAddressHi;
*(bit32*)sasIdentify.sasAddressLo = *(bit32*)pDiscoverResp->attachedSasAddressLo;
/* incremental discovery */
dmSASSubID.sasAddressHi = SA_IDFRM_GET_SAS_ADDRESSHI(&sasIdentify);
dmSASSubID.sasAddressLo = SA_IDFRM_GET_SAS_ADDRESSLO(&sasIdentify);
dmSASSubID.initiator_ssp_stp_smp = sasIdentify.initiator_ssp_stp_smp;
dmSASSubID.target_ssp_stp_smp = sasIdentify.target_ssp_stp_smp;
attachedSasHi = SAS2_DISCRSP_GET_ATTACHED_SAS_ADDRESSHI(pDiscoverResp);
attachedSasLo = SAS2_DISCRSP_GET_ATTACHED_SAS_ADDRESSLO(pDiscoverResp);
/* If it's a direct routing */
if ( SAS2_DISCRSP_GET_ROUTINGATTRIB(pDiscoverResp) == SAS_ROUTING_DIRECT)
{
/* If the attached device is an expander */
if ( (SAS2_DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == SAS_FANOUT_EXPANDER_DEVICE)
|| (SAS2_DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == SAS_EDGE_EXPANDER_DEVICE) )
{
DM_DBG1(("dmDownStreamDiscover2ExpanderPhy: **** Topology Error direct routing can't connect to expander!!!\n"));
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo
= DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi
= DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier = oneExpander->discoveringPhyId;
DM_DBG1(("dmDownStreamDiscover2ExpanderPhy: sasAddressHi 0x%08x sasAddressLo 0x%08x phyid 0x%x\n",
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi,
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo,
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier));
dmDiscoverDone(dmRoot, onePortContext, DM_RC_FAILURE);
return;
}
}
/* If the expander's attached device is not myself */
if ( (attachedSasHi != onePortContext->sasLocalAddressHi)
|| (attachedSasLo != onePortContext->sasLocalAddressLo) )
{
/* Find the attached device from discovered list */
AttachedDevice = dmPortSASDeviceFind(dmRoot, onePortContext, attachedSasLo, attachedSasHi, oneDeviceData);
/* If the device has not been discovered before */
if ( AttachedDevice == agNULL) //11
{
//qqqqqq
if (0)
{
DM_DBG1(("dmDownStreamDiscover2ExpanderPhy: **** Topology Error subtractive routing error - inconsistent SAS address!!!\n"));
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo
= DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi
= DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier = oneExpander->discoveringPhyId;
DM_DBG1(("dmDownStreamDiscover2ExpanderPhy: sasAddressHi 0x%08x sasAddressLo 0x%08x phyid 0x%x\n",
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi,
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo,
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier));
/* discovery done */
dmDiscoverDone(dmRoot, onePortContext, DM_RC_FAILURE);
}
else
{
/* Add the device */
/* read minimum rate from the configuration
onePortContext->LinkRate is SPC's local link rate
*/
connectionRate = MIN(onePortContext->LinkRate, SAS2_DISCRSP_GET_LOGICAL_LINKRATE(pDiscoverResp));
DM_DBG2(("dmDownStreamDiscover2ExpanderPhy: link rate 0x%x\n", DEVINFO_GET_LINKRATE(&oneDeviceData->agDeviceInfo)));
DM_DBG2(("dmDownStreamDiscover2ExpanderPhy: negotiatedPhyLinkRate 0x%x\n", SAS2_DISCRSP_GET_LINKRATE(pDiscoverResp)));
DM_DBG2(("dmDownStreamDiscover2ExpanderPhy: connectionRate 0x%x\n", connectionRate));
if (SAS2_DISCRSP_IS_STP_TARGET(pDiscoverResp) || SAS2_DISCRSP_IS_SATA_DEVICE(pDiscoverResp))
{
if (onePortContext->discovery.type == DM_DISCOVERY_OPTION_FULL_START)
{
AttachedDevice = dmPortSASDeviceAdd(
dmRoot,
onePortContext,
sasIdentify,
agFALSE,
connectionRate,
dmAllShared->itNexusTimeout,
0,
STP_DEVICE_TYPE,
oneDeviceData,
oneExpander,
pDiscoverResp->phyIdentifier
);
}
else
{
/* incremental discovery */
AttachedDevice = dmFindRegNValid(
dmRoot,
onePortContext,
&dmSASSubID
);
/* not registered and not valid; add this*/
if (AttachedDevice == agNULL)
{
AttachedDevice = dmPortSASDeviceAdd(
dmRoot,
onePortContext,
sasIdentify,
agFALSE,
connectionRate,
dmAllShared->itNexusTimeout,
0,
STP_DEVICE_TYPE,
oneDeviceData,
oneExpander,
pDiscoverResp->phyIdentifier
);
}
}
}
else
{
if (onePortContext->discovery.type == DM_DISCOVERY_OPTION_FULL_START)
{
AttachedDevice = dmPortSASDeviceAdd(
dmRoot,
onePortContext,
sasIdentify,
agFALSE,
connectionRate,
dmAllShared->itNexusTimeout,
0,
SAS_DEVICE_TYPE,
oneDeviceData,
oneExpander,
pDiscoverResp->phyIdentifier
);
}
else
{
/* incremental discovery */
AttachedDevice = dmFindRegNValid(
dmRoot,
onePortContext,
&dmSASSubID
);
/* not registered and not valid; add this*/
if (AttachedDevice == agNULL)
{
AttachedDevice = dmPortSASDeviceAdd(
dmRoot,
onePortContext,
sasIdentify,
agFALSE,
connectionRate,
dmAllShared->itNexusTimeout,
0,
SAS_DEVICE_TYPE,
oneDeviceData,
oneExpander,
pDiscoverResp->phyIdentifier
);
}
}
}
DM_DBG2(("dmDownStreamDiscover2ExpanderPhy: newDevice pDevice=%p\n", AttachedDevice));
/* If the device is added successfully */
if ( AttachedDevice != agNULL)
{
if ( SA_IDFRM_IS_SSP_TARGET(&sasIdentify)
|| SA_IDFRM_IS_SMP_TARGET(&sasIdentify)
|| SA_IDFRM_IS_SSP_INITIATOR(&sasIdentify)
|| SA_IDFRM_IS_SMP_INITIATOR(&sasIdentify) )
{
DM_DBG2(("dmDownStreamDiscover2ExpanderPhy: Report a new SAS device !!\n"));
}
else
{
if ( SA_IDFRM_IS_STP_TARGET(&sasIdentify) ||
SA_IDFRM_IS_SATA_DEVICE(&sasIdentify) )
{
DM_DBG2(("dmDownStreamDiscover2ExpanderPhy: Found an STP or SATA device.\n"));
}
else
{
DM_DBG2(("dmDownStreamDiscover2ExpanderPhy: Found Other type of device.\n"));
}
}
/* LP2006-05-26 added upstream device to the newly found device */
AttachedDevice->dmExpander = oneExpander;
DM_DBG3(("dmDownStreamDiscover2ExpanderPhy: AttachedDevice %p did %d\n", AttachedDevice, AttachedDevice->id));
DM_DBG3(("dmDownStreamDiscover2ExpanderPhy: Attached oneExpander %p did %d\n", AttachedDevice->dmExpander, AttachedDevice->dmExpander->id));
DM_DBG3(("dmDownStreamDiscover2ExpanderPhy: oneDeviceData %p did %d\n", oneDeviceData, oneDeviceData->id));
DM_DBG3(("dmDownStreamDiscover2ExpanderPhy: oneExpander %p did %d\n", oneDeviceData->dmExpander, oneDeviceData->dmExpander->id));
/* If the phy has table routing attribute */
if ( SAS2_DISCRSP_GET_ROUTINGATTRIB(pDiscoverResp) == SAS_ROUTING_TABLE)
{
/* If the attached device is a fan out expander */
if ( SAS2_DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == SAS_FANOUT_EXPANDER_DEVICE)
{
/* TODO: discovery error, callback */
DM_DBG1(("dmDownStreamDiscover2ExpanderPhy: **** Topology Error two table routing phys are connected!!!\n"));
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo
= DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi
= DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier = oneExpander->discoveringPhyId;
DM_DBG1(("dmDownStreamDiscover2ExpanderPhy: sasAddressHi 0x%08x sasAddressLo 0x%08x phyid 0x%x\n",
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi,
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo,
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier));
/* discovery done */
dmDiscoverDone(dmRoot, onePortContext, DM_RC_FAILURE);
}
else if ( SAS2_DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == SAS_EDGE_EXPANDER_DEVICE)
{
/* Allocate an expander data structure */
AttachedExpander = dmDiscoveringExpanderAlloc(dmRoot, onePortContext, AttachedDevice);
DM_DBG2(("dmDownStreamDiscover2ExpanderPhy: Found a EDGE exp device.%p\n", AttachedExpander));
/* If allocate successfully */
if ( AttachedExpander != agNULL)
{
/* set up downstream information on configurable expander */
dmExpanderDownStreamPhyAdd(dmRoot, oneExpander, (bit8) oneExpander->discoveringPhyId);
/* Setup upstream information */
dmExpanderUpStreamPhyAdd(dmRoot, AttachedExpander, (bit8) oneExpander->discoveringPhyId);
//qqqqq
AttachedExpander->hasUpStreamDevice = agTRUE;
AttachedExpander->upStreamSASAddressHi
= DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo);
AttachedExpander->upStreamSASAddressLo
= DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo);
AttachedExpander->dmUpStreamExpander = oneExpander;
/* (2.3.2.2.2.2.2.2.2) Add the pAttachedExpander to discovering list */
dmDiscoveringExpanderAdd(dmRoot, onePortContext, AttachedExpander);
}
/* If failed to allocate */
else
{
DM_DBG1(("dmDownStreamDiscover2ExpanderPhy, Failed to allocate expander data structure!!!\n"));
/* discovery done */
dmDiscoverDone(dmRoot, onePortContext, DM_RC_FAILURE);
}
}
}
//qqqqq
else if ( SAS2_DISCRSP_GET_ROUTINGATTRIB(pDiscoverResp) == SAS_ROUTING_SUBTRACTIVE &&
(SAS2_DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == SAS_FANOUT_EXPANDER_DEVICE ||
SAS2_DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == SAS_EDGE_EXPANDER_DEVICE)
)
{
/* Allocate an expander data structure */
AttachedExpander = dmDiscoveringExpanderAlloc(dmRoot, onePortContext, AttachedDevice);
DM_DBG2(("dmDownStreamDiscover2ExpanderPhy: Found a EDGE/FANOUT exp device.%p\n", AttachedExpander));
/* If allocate successfully */
if ( AttachedExpander != agNULL)
{
/* set up downstream information on configurable expander */
dmExpanderDownStreamPhyAdd(dmRoot, oneExpander, (bit8) oneExpander->discoveringPhyId);
/* Setup upstream information */
dmExpanderUpStreamPhyAdd(dmRoot, AttachedExpander, (bit8) oneExpander->discoveringPhyId);
AttachedExpander->hasUpStreamDevice = agTRUE;
AttachedExpander->upStreamSASAddressHi
= DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo);
AttachedExpander->upStreamSASAddressLo
= DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo);
AttachedExpander->dmUpStreamExpander = oneExpander;
/* (2.3.2.2.2.2.2.2.2) Add the pAttachedExpander to discovering list */
dmDiscoveringExpanderAdd(dmRoot, onePortContext, AttachedExpander);
}
/* If failed to allocate */
else
{
DM_DBG1(("dmDownStreamDiscover2ExpanderPhy, Failed to allocate expander data structure (2)!!!\n"));
/* discovery done */
dmDiscoverDone(dmRoot, onePortContext, DM_RC_FAILURE);
}
}
/* If status is still DISCOVERY_DOWN_STREAM */
if ( onePortContext->discovery.status == DISCOVERY_DOWN_STREAM &&
onePortContext->discovery.ConfiguresOthers == agFALSE)
{
DM_DBG2(("dmDownStreamDiscover2ExpanderPhy: 1st before\n"));
dmDumpAllUpExp(dmRoot, onePortContext, oneExpander);
UpStreamExpander = oneExpander->dmUpStreamExpander;
ConfigurableExpander = dmFindConfigurableExp(dmRoot, onePortContext, oneExpander);
configSASAddressHi = DEVINFO_GET_SAS_ADDRESSHI(&AttachedDevice->agDeviceInfo);
configSASAddressLo = DEVINFO_GET_SAS_ADDRESSLO(&AttachedDevice->agDeviceInfo);
if (ConfigurableExpander)
{
if ( (ConfigurableExpander->dmDevice->SASAddressID.sasAddressHi
== DEVINFO_GET_SAS_ADDRESSHI(&AttachedDevice->agDeviceInfo)) &&
(ConfigurableExpander->dmDevice->SASAddressID.sasAddressLo
== DEVINFO_GET_SAS_ADDRESSLO(&AttachedDevice->agDeviceInfo))
)
{ /* directly attached between oneExpander and ConfigurableExpander */
DM_DBG2(("dmDownStreamDiscover2ExpanderPhy: 1st before loc 1\n"));
configSASAddressHi = oneExpander->dmDevice->SASAddressID.sasAddressHi;
configSASAddressLo = oneExpander->dmDevice->SASAddressID.sasAddressLo;
}
else
{
DM_DBG2(("dmDownStreamDiscover2ExpanderPhy: 1st before loc 2\n"));
configSASAddressHi = DEVINFO_GET_SAS_ADDRESSHI(&AttachedDevice->agDeviceInfo);
configSASAddressLo = DEVINFO_GET_SAS_ADDRESSLO(&AttachedDevice->agDeviceInfo);
}
} /* if !ConfigurableExpander */
dupConfigSASAddr = dmDuplicateConfigSASAddr(dmRoot,
ConfigurableExpander,
configSASAddressHi,
configSASAddressLo
);
if ( ConfigurableExpander && dupConfigSASAddr == agFALSE)
{
DM_DBG2(("dmDownStreamDiscover2ExpanderPhy: 1st q123\n"));
UpStreamExpander->dmCurrentDownStreamExpander = oneExpander;
ConfigurableExpander->currentDownStreamPhyIndex =
dmFindCurrentDownStreamPhyIndex(dmRoot, ConfigurableExpander);
ConfigurableExpander->dmReturnginExpander = oneExpander;
dmRoutingEntryAdd(dmRoot,
ConfigurableExpander,
ConfigurableExpander->downStreamPhys[ConfigurableExpander->currentDownStreamPhyIndex],
configSASAddressHi,
configSASAddressLo
);
}
}
}
/* If fail to add the device */
else
{
DM_DBG1(("dmDownStreamDiscover2ExpanderPhy, Failed to add a device!!!\n"));
/* discovery done */
dmDiscoverDone(dmRoot, onePortContext, DM_RC_FAILURE);
}
}
}
/* If the device has been discovered before */
else /* discovered before */
{
/* If the phy has subtractive routing attribute */
if ( SAS2_DISCRSP_GET_ROUTINGATTRIB(pDiscoverResp) == SAS_ROUTING_SUBTRACTIVE)
{
/* If the expander doesn't have up stream device */
if ( oneExpander->hasUpStreamDevice == agFALSE)
{
/* TODO: discovery error, callback */
DM_DBG1(("dmDownStreamDiscover2ExpanderPhy: **** Topology Error loop, or end device connects to two expanders!!!\n"));
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo
= DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi
= DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier = oneExpander->discoveringPhyId;
DM_DBG1(("dmDownStreamDiscover2ExpanderPhy: sasAddressHi 0x%08x sasAddressLo 0x%08x phyid 0x%x\n",
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi,
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo,
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier));
/* discovery done */
dmDiscoverDone(dmRoot, onePortContext, DM_RC_FAILURE);
}
/* If the expander has up stream device */
else
{
//qqqqq
/* If sas address doesn't match */
if ( (oneExpander->upStreamSASAddressHi != attachedSasHi)
|| (oneExpander->upStreamSASAddressLo != attachedSasLo) )
{
/* TODO: discovery error, callback */
DM_DBG1(("dmDownStreamDiscover2ExpanderPhy: **** two subtractive phys!!! Allowed in SAS2!!!\n"));
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo
= DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi
= DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier = oneExpander->discoveringPhyId;
onePortContext->discovery.DeferredError = agTRUE;
}
}
}
/* If the phy has table routing attribute */
else if ( SAS2_DISCRSP_GET_ROUTINGATTRIB(pDiscoverResp) == SAS_ROUTING_TABLE)
{
/* If the attached device is a fan out expander */
if ( SAS2_DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == SAS_FANOUT_EXPANDER_DEVICE)
{
/* (2.3.3.2.1.1) TODO: discovery error, callback */
DM_DBG1(("dmDownStreamDiscover2ExpanderPhy: **** Topology Error fan out expander to routing table phy!!!\n"));
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo
= DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi
= DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier = oneExpander->discoveringPhyId;
DM_DBG1(("dmDownStreamDiscover2ExpanderPhy: sasAddressHi 0x%08x sasAddressLo 0x%08x phyid 0x%x\n",
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi,
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo,
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier));
/* discovery done */
dmDiscoverDone(dmRoot, onePortContext, DM_RC_FAILURE);
}
/* If the attached device is an edge expander */
else if ( SAS2_DISCRSP_GET_ATTACHED_DEVTYPE(pDiscoverResp) == SAS_EDGE_EXPANDER_DEVICE)
{
/* Setup up stream inform */
AttachedExpander = AttachedDevice->dmExpander;
DM_DBG2(("dmDownStreamDiscover2ExpanderPhy: Found edge expander=%p\n", AttachedExpander));
//hhhhhh
/* If the attached expander has up stream device */
if ( AttachedExpander->hasUpStreamDevice == agTRUE)
{
/* compare the sas address */
if ( (AttachedExpander->upStreamSASAddressHi
!= DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo))
|| (AttachedExpander->upStreamSASAddressLo
!= DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo)))
{
if (AttachedExpander->TTTSupported && oneExpander->TTTSupported)
{
/*
needs further error checking
UpstreamExpanderOfAttachedExpander = AttachedExpander->UpStreamExpander
for (i=0;i<DM_MAX_EXPANDER_PHYS;i++)
{
if (UpstreamExpanderOfAttachedExpander->downStreamPhys[i] != 0 &&
}
*/
SAS2SAS11Check = dmSAS2SAS11ErrorCheck(dmRoot, onePortContext, AttachedExpander->dmUpStreamExpander, AttachedExpander, oneExpander);
if (SAS2SAS11Check == agTRUE)
{
DM_DBG1(("dmDownStreamDiscover2ExpanderPhy: **** Topology Error SAS2 and SAS1.1!!!\n"));
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo
= DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi
= DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier = oneExpander->discoveringPhyId;
DM_DBG1(("dmDownStreamDiscover2ExpanderPhy: sasAddressHi 0x%08x sasAddressLo 0x%08x phyid 0x%x\n",
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi,
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo,
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier));
/* discovery done */
dmDiscoverDone(dmRoot, onePortContext, DM_RC_FAILURE);
}
else
{
DM_DBG1(("dmDownStreamDiscover2ExpanderPhy: Allowed Table to Table (1)\n"));
/* move on to the next phys but should be not proceed after oneExpander */
oneExpander->UndoDueToTTTSupported = agTRUE;
onePortContext->discovery.DeferredError = agFALSE;
}
}
else
{
/* TODO: discovery error, callback */
DM_DBG1(("dmDownStreamDiscover2ExpanderPhy: **** Topology Error two table routing phys connected (1)!!!\n"));
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo
= DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi
= DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier = oneExpander->discoveringPhyId;
DM_DBG1(("dmDownStreamDiscover2ExpanderPhy: sasAddressHi 0x%08x sasAddressLo 0x%08x phyid 0x%x\n",
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi,
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo,
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier));
/* discovery done */
dmDiscoverDone(dmRoot, onePortContext, DM_RC_FAILURE);
}
}
else
{
DM_DBG2(("dmDownStreamDiscover2ExpanderPhy: Add edge expander=%p\n", AttachedExpander));
/* set up downstream information on configurable expander */
dmExpanderDownStreamPhyAdd(dmRoot, oneExpander, (bit8) oneExpander->discoveringPhyId);
/* haha */
dmExpanderUpStreamPhyAdd(dmRoot, AttachedExpander, (bit8) oneExpander->discoveringPhyId);
/* Add the pAttachedExpander to discovering list */
dmDiscoveringExpanderAdd(dmRoot, onePortContext, AttachedExpander);
}
}
/* If the attached expander doesn't have up stream device */
else
{
if (AttachedExpander->TTTSupported && oneExpander->TTTSupported)
{
DM_DBG1(("dmDownStreamDiscover2ExpanderPhy: Allowed Table to Table (2)\n"));
/* move on to the next phys but should be not proceed after oneExpander */
oneExpander->UndoDueToTTTSupported = agTRUE;
onePortContext->discovery.DeferredError = agFALSE;
}
else
{
/* TODO: discovery error, callback */
DM_DBG1(("dmDownStreamDiscover2ExpanderPhy: **** Topology Error two table routing phys connected (2)!!!\n"));
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo
= DEVINFO_GET_SAS_ADDRESSLO(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi
= DEVINFO_GET_SAS_ADDRESSHI(&oneDeviceData->agDeviceInfo);
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier = oneExpander->discoveringPhyId;
DM_DBG1(("dmDownStreamDiscover2ExpanderPhy: sasAddressHi 0x%08x sasAddressLo 0x%08x phyid 0x%x\n",
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressHi,
onePortContext->discovery.sasAddressIDDiscoverError.sasAddressLo,
onePortContext->discovery.sasAddressIDDiscoverError.phyIdentifier));
/* discovery done */
dmDiscoverDone(dmRoot, onePortContext, DM_RC_FAILURE);
}
}
}
} /* for else if (SAS2_DISCRSP_GET_ROUTINGATTRIB(pDiscoverResp) == SAS_ROUTING_TABLE) */
/* do this regradless of sub or table */
/* If status is still DISCOVERY_DOWN_STREAM */
if ( onePortContext->discovery.status == DISCOVERY_DOWN_STREAM &&
onePortContext->discovery.ConfiguresOthers == agFALSE)
{
DM_DBG2(("dmDownStreamDiscover2ExpanderPhy: 2nd before\n"));
dmDumpAllUpExp(dmRoot, onePortContext, oneExpander);
UpStreamExpander = oneExpander->dmUpStreamExpander;
ConfigurableExpander = dmFindConfigurableExp(dmRoot, onePortContext, oneExpander);
configSASAddressHi = DEVINFO_GET_SAS_ADDRESSHI(&AttachedDevice->agDeviceInfo);
configSASAddressLo = DEVINFO_GET_SAS_ADDRESSLO(&AttachedDevice->agDeviceInfo);
if (ConfigurableExpander)
{
if ( (ConfigurableExpander->dmDevice->SASAddressID.sasAddressHi
== DEVINFO_GET_SAS_ADDRESSHI(&AttachedDevice->agDeviceInfo)) &&
(ConfigurableExpander->dmDevice->SASAddressID.sasAddressLo
== DEVINFO_GET_SAS_ADDRESSLO(&AttachedDevice->agDeviceInfo))
)
{ /* directly attached between oneExpander and ConfigurableExpander */
DM_DBG2(("dmDownStreamDiscover2ExpanderPhy: 2nd before loc 1\n"));
configSASAddressHi = oneExpander->dmDevice->SASAddressID.sasAddressHi;
configSASAddressLo = oneExpander->dmDevice->SASAddressID.sasAddressLo;
}
else
{
DM_DBG2(("dmDownStreamDiscover2ExpanderPhy: 2nd before loc 2\n"));
configSASAddressHi = DEVINFO_GET_SAS_ADDRESSHI(&AttachedDevice->agDeviceInfo);
configSASAddressLo = DEVINFO_GET_SAS_ADDRESSLO(&AttachedDevice->agDeviceInfo);
}
} /* if !ConfigurableExpander */
dupConfigSASAddr = dmDuplicateConfigSASAddr(dmRoot,
ConfigurableExpander,
configSASAddressHi,
configSASAddressLo
);
if ( ConfigurableExpander && dupConfigSASAddr == agFALSE)
{
DM_DBG2(("dmDownStreamDiscover2ExpanderPhy: 2nd q123 \n"));
UpStreamExpander->dmCurrentDownStreamExpander = oneExpander;
ConfigurableExpander->currentDownStreamPhyIndex =
dmFindCurrentDownStreamPhyIndex(dmRoot, ConfigurableExpander);
ConfigurableExpander->dmReturnginExpander = oneExpander;
dmRoutingEntryAdd(dmRoot,
ConfigurableExpander,
ConfigurableExpander->downStreamPhys[ConfigurableExpander->currentDownStreamPhyIndex],
configSASAddressHi,
configSASAddressLo
);
}
} /* if (onePortContext->discovery.status == DISCOVERY_DOWN_STREAM) */
/* incremental discovery */
if (onePortContext->discovery.type == DM_DISCOVERY_OPTION_INCREMENTAL_START)
{
connectionRate = MIN(onePortContext->LinkRate, SAS2_DISCRSP_GET_LOGICAL_LINKRATE(pDiscoverResp));
if (SAS2_DISCRSP_IS_STP_TARGET(pDiscoverResp) || SAS2_DISCRSP_IS_SATA_DEVICE(pDiscoverResp))
{
DM_DBG2(("dmDownStreamDiscover2ExpanderPhy: incremental SATA_STP\n"));
dmPortSASDeviceAdd(
dmRoot,
onePortContext,
sasIdentify,
agFALSE,
connectionRate,
dmAllShared->itNexusTimeout,
0,
STP_DEVICE_TYPE,
oneDeviceData,
oneExpander,
pDiscoverResp->phyIdentifier
);
}
else
{
DM_DBG2(("dmDownStreamDiscover2ExpanderPhy: incremental SAS\n"));
dmPortSASDeviceAdd(
dmRoot,
onePortContext,
sasIdentify,
agFALSE,
connectionRate,
dmAllShared->itNexusTimeout,
0,
SAS_DEVICE_TYPE,
oneDeviceData,
oneExpander,
pDiscoverResp->phyIdentifier
);
}
}
}/* else; existing devce */
} /* not attached to myself */
/* If the attached device is myself */
else
{
DM_DBG2(("dmDownStreamDiscover2ExpanderPhy: Found Self\n"));
DM_DBG2(("dmDownStreamDiscover2ExpanderPhy: 3rd before\n"));
dmDumpAllUpExp(dmRoot, onePortContext, oneExpander);
if (onePortContext->discovery.ConfiguresOthers == agFALSE)
{
UpStreamExpander = oneExpander->dmUpStreamExpander;
ConfigurableExpander = dmFindConfigurableExp(dmRoot, onePortContext, oneExpander);
dupConfigSASAddr = dmDuplicateConfigSASAddr(dmRoot,
ConfigurableExpander,
onePortContext->sasLocalAddressHi,
onePortContext->sasLocalAddressLo
);
if ( ConfigurableExpander && dupConfigSASAddr == agFALSE)
{
DM_DBG2(("dmDownStreamDiscover2ExpanderPhy: 3rd q123 Setup routing table\n"));
UpStreamExpander->dmCurrentDownStreamExpander = oneExpander;
ConfigurableExpander->currentDownStreamPhyIndex =
dmFindCurrentDownStreamPhyIndex(dmRoot, ConfigurableExpander);
ConfigurableExpander->dmReturnginExpander = oneExpander;
dmRoutingEntryAdd(dmRoot,
ConfigurableExpander,
ConfigurableExpander->downStreamPhys[ConfigurableExpander->currentDownStreamPhyIndex],
onePortContext->sasLocalAddressHi,
onePortContext->sasLocalAddressLo
);
}
}
}
}
/* If no device is attached */
else
{
}
/* Increment the discovering phy id */
oneExpander->discoveringPhyId ++;
/* If the discovery status is DISCOVERY_DOWN_STREAM */
if ( onePortContext->discovery.status == DISCOVERY_DOWN_STREAM )
{
/* If not the last phy */
if ( oneExpander->discoveringPhyId < oneDeviceData->numOfPhys )
{
DM_DBG2(("dmDownStreamDiscover2ExpanderPhy: More Phys to discover\n"));
/* continue discovery for the next phy */
dmDiscoverSend(dmRoot, oneDeviceData);
}
/* If the last phy */
else
{
DM_DBG2(("dmDownStreamDiscover2ExpanderPhy: No More Phys\n"));
/* for MCN */
dmUpdateAllAdjacent(dmRoot, onePortContext, oneDeviceData);
ConfigurableExpander = dmFindConfigurableExp(dmRoot, onePortContext, oneExpander);
if (oneExpander->UndoDueToTTTSupported == agTRUE && ConfigurableExpander != agNULL)
// if (oneExpander->UndoDueToTTTSupported == agTRUE)
{
DM_DBG2(("dmDownStreamDiscover2ExpanderPhy: Not sure!!!\n"));
dmDiscoveringUndoAdd(dmRoot, onePortContext, oneExpander);
oneExpander->UndoDueToTTTSupported = agFALSE;
}
/* remove the expander from the discovering list */
dmDiscoveringExpanderRemove(dmRoot, onePortContext, oneExpander);
/* continue downstream discovering */
dmDownStreamDiscovering(dmRoot, onePortContext, oneDeviceData);
}
}
else
{
DM_DBG2(("dmDownStreamDiscover2ExpanderPhy: onePortContext->discovery.status not in DISCOVERY_DOWN_STREAM; status %d\n", onePortContext->discovery.status));
}
DM_DBG2(("dmDownStreamDiscover2ExpanderPhy: end return phyID#%d\n", oneExpander->discoveringPhyId - 1));
return;
}
osGLOBAL void
dmDiscoveringUndoAdd(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
dmExpander_t *oneExpander
)
{
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
dmList_t *ExpanderList;
dmExpander_t *tempExpander;
dmIntPortContext_t *tmpOnePortContext = onePortContext;
DM_DBG2(("dmDiscoveringUndoAdd: start\n"));
if (DMLIST_EMPTY(&(tmpOnePortContext->discovery.discoveringExpanderList)))
{
DM_DBG2(("dmDiscoveringUndoAdd: empty discoveringExpanderList\n"));
return;
}
// DM_DBG2(("dmDiscoveringUndoAdd: before\n"));
// dmDumpAllExp(dmRoot, onePortContext, oneExpander);
ExpanderList = tmpOnePortContext->discovery.discoveringExpanderList.flink;
while (ExpanderList != &(tmpOnePortContext->discovery.discoveringExpanderList))
{
tempExpander = DMLIST_OBJECT_BASE(dmExpander_t, linkNode, ExpanderList);
if ( tempExpander == agNULL)
{
DM_DBG1(("dmDiscoveringUndoAdd: tempExpander is NULL!!!\n"));
return;
}
if (tempExpander->dmUpStreamExpander == oneExpander)
{
DM_DBG2(("dmDiscoveringUndoAdd: match!!! expander id %d\n", tempExpander->id));
DM_DBG2(("dmDiscoveringUndoAdd: exp addrHi 0x%08x\n", tempExpander->dmDevice->SASAddressID.sasAddressHi));
DM_DBG2(("dmDiscoveringUndoAdd: exp addrLo 0x%08x\n", tempExpander->dmDevice->SASAddressID.sasAddressLo));
tddmSingleThreadedEnter(dmRoot, DM_EXPANDER_LOCK);
DMLIST_DEQUEUE_THIS(&(tempExpander->linkNode));
// DMLIST_ENQUEUE_AT_TAIL(&(tempExpander->linkNode), &(dmAllShared->freeExpanderList));
DMLIST_ENQUEUE_AT_TAIL(&(tempExpander->linkNode), &(dmAllShared->mainExpanderList));
tddmSingleThreadedLeave(dmRoot, DM_EXPANDER_LOCK);
ExpanderList = tmpOnePortContext->discovery.discoveringExpanderList.flink;
}
if (DMLIST_EMPTY(&(tmpOnePortContext->discovery.discoveringExpanderList)))
{
DM_DBG2(("dmDiscoveringUndoAdd: hitting break\n"));
break;
}
ExpanderList = ExpanderList->flink;
}
// DM_DBG2(("dmDiscoveringUndoAdd: after\n"));
// dmDumpAllExp(dmRoot, onePortContext, oneExpander);
return;
}
osGLOBAL void
dmHandleZoneViolation(
dmRoot_t *dmRoot,
agsaRoot_t *agRoot,
agsaIORequest_t *agIORequest,
dmDeviceData_t *oneDeviceData,
dmSMPFrameHeader_t *frameHeader,
agsaFrameHandle_t frameHandle
)
{
dmIntPortContext_t *onePortContext = agNULL;
dmExpander_t *oneExpander = agNULL;
DM_DBG1(("dmHandleZoneViolation: start\n"));
DM_DBG1(("dmHandleZoneViolation: sasAddressHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi));
DM_DBG1(("dmHandleZoneViolation: sasAddressLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo));
onePortContext = oneDeviceData->dmPortContext;
oneExpander = oneDeviceData->dmExpander;
if (dmDiscoverCheck(dmRoot, onePortContext) == agTRUE)
{
DM_DBG1(("dmHandleZoneViolation: invalid port or aborted discovery!!!\n"));
return;
}
/* for MCN */
dmUpdateAllAdjacent(dmRoot, onePortContext, oneDeviceData);
/* remove the expander from the discovering list */
dmDiscoveringExpanderRemove(dmRoot, onePortContext, oneExpander);
if ( onePortContext->discovery.status == DISCOVERY_UP_STREAM)
{
/* continue upstream discovering */
dmUpStreamDiscovering(dmRoot, onePortContext, oneDeviceData);
}
else /* DISCOVERY_DOWN_STREAM or DISCOVERY_CONFIG_ROUTING */
{
/* continue downstream discovering */
dmDownStreamDiscovering(dmRoot, onePortContext, oneDeviceData);
}
return;
}
osGLOBAL void
dmUpStreamDiscoverExpanderPhySkip(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
dmExpander_t *oneExpander
)
{
dmDeviceData_t *oneDeviceData;
DM_DBG3(("dmUpStreamDiscoverExpanderPhySkip: start\n"));
oneDeviceData = oneExpander->dmDevice;
DM_DBG3(("dmUpStreamDiscoverExpanderPhySkip: sasAddressHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi));
DM_DBG3(("dmUpStreamDiscoverExpanderPhySkip: sasAddressLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo));
oneExpander->discoveringPhyId++;
if (onePortContext->discovery.status == DISCOVERY_UP_STREAM)
{
if ( oneExpander->discoveringPhyId < oneDeviceData->numOfPhys )
{
DM_DBG3(("dmUpStreamDiscoverExpanderPhySkip: More Phys to discover\n"));
/* continue discovery for the next phy */
dmDiscoverSend(dmRoot, oneDeviceData);
}
else
{
DM_DBG3(("dmUpStreamDiscoverExpanderPhySkip: No More Phys\n"));
/* for MCN */
dmUpdateAllAdjacent(dmRoot, onePortContext, oneDeviceData);
/* remove the expander from the discovering list */
dmDiscoveringExpanderRemove(dmRoot, onePortContext, oneExpander);
/* continue upstream discovering */
dmUpStreamDiscovering(dmRoot, onePortContext, oneDeviceData);
}
}
else
{
DM_DBG3(("dmUpStreamDiscoverExpanderPhySkip: onePortContext->discovery.status not in DISCOVERY_UP_STREAM; status %d\n", onePortContext->discovery.status));
}
DM_DBG3(("dmUpStreamDiscoverExpanderPhySkip: end return phyID#%d\n", oneExpander->discoveringPhyId - 1));
return;
}
osGLOBAL void
dmUpStreamDiscover2ExpanderPhySkip(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
dmExpander_t *oneExpander
)
{
dmDeviceData_t *oneDeviceData;
DM_DBG2(("dmUpStreamDiscover2ExpanderPhySkip: start\n"));
oneDeviceData = oneExpander->dmDevice;
oneExpander->discoveringPhyId++;
if (onePortContext->discovery.status == DISCOVERY_UP_STREAM)
{
if ( oneExpander->discoveringPhyId < oneDeviceData->numOfPhys )
{
DM_DBG2(("dmUpStreamDiscover2ExpanderPhySkip: DISCOVERY_UP_STREAM find more ...\n"));
/* continue discovery for the next phy */
dmDiscoverSend(dmRoot, oneDeviceData);
}
else
{
DM_DBG2(("dmUpStreamDiscover2ExpanderPhySkip: DISCOVERY_UP_STREAM last phy continue upstream..\n"));
/* for MCN */
dmUpdateAllAdjacent(dmRoot, onePortContext, oneDeviceData);
/* remove the expander from the discovering list */
dmDiscoveringExpanderRemove(dmRoot, onePortContext, oneExpander);
/* continue upstream discovering */
dmUpStreamDiscovering(dmRoot, onePortContext, oneDeviceData);
}
}
else
{
DM_DBG2(("dmUpStreamDiscover2ExpanderPhySkip: onePortContext->discovery.status not in DISCOVERY_UP_STREAM; status %d\n", onePortContext->discovery.status));
}
DM_DBG2(("dmUpStreamDiscover2ExpanderPhySkip: end return phyID#%d\n", oneExpander->discoveringPhyId - 1));
return;
}
osGLOBAL void
dmDownStreamDiscoverExpanderPhySkip(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
dmExpander_t *oneExpander
)
{
dmDeviceData_t *oneDeviceData;
DM_DBG3(("dmDownStreamDiscoverExpanderPhySkip: start\n"));
oneDeviceData = oneExpander->dmDevice;
DM_DBG3(("dmDownStreamDiscoverExpanderPhySkip: sasAddressHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi));
DM_DBG3(("dmDownStreamDiscoverExpanderPhySkip: sasAddressLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo));
/* Increment the discovering phy id */
oneExpander->discoveringPhyId ++;
/* If the discovery status is DISCOVERY_DOWN_STREAM */
if ( onePortContext->discovery.status == DISCOVERY_DOWN_STREAM )
{
/* If not the last phy */
if ( oneExpander->discoveringPhyId < oneDeviceData->numOfPhys )
{
DM_DBG3(("dmDownStreamDiscoverExpanderPhySkip: More Phys to discover\n"));
/* continue discovery for the next phy */
dmDiscoverSend(dmRoot, oneDeviceData);
}
/* If the last phy */
else
{
DM_DBG3(("dmDownStreamDiscoverExpanderPhySkip: No More Phys\n"));
/* for MCN */
dmUpdateAllAdjacent(dmRoot, onePortContext, oneDeviceData);
/* remove the expander from the discovering list */
dmDiscoveringExpanderRemove(dmRoot, onePortContext, oneExpander);
/* continue downstream discovering */
dmDownStreamDiscovering(dmRoot, onePortContext, oneDeviceData);
}
}
else
{
DM_DBG3(("dmDownStreamDiscoverExpanderPhySkip: onePortContext->discovery.status not in DISCOVERY_DOWN_STREAM; status %d\n", onePortContext->discovery.status));
}
DM_DBG3(("dmDownStreamDiscoverExpanderPhySkip: end return phyID#%d\n", oneExpander->discoveringPhyId - 1));
return;
}
osGLOBAL void
dmDownStreamDiscover2ExpanderPhySkip(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
dmExpander_t *oneExpander
)
{
dmDeviceData_t *oneDeviceData;
DM_DBG2(("dmDownStreamDiscover2ExpanderPhySkip: start\n"));
oneDeviceData = oneExpander->dmDevice;
/* Increment the discovering phy id */
oneExpander->discoveringPhyId ++;
/* If the discovery status is DISCOVERY_DOWN_STREAM */
if ( onePortContext->discovery.status == DISCOVERY_DOWN_STREAM )
{
/* If not the last phy */
if ( oneExpander->discoveringPhyId < oneDeviceData->numOfPhys )
{
DM_DBG2(("dmDownStreamDiscover2ExpanderPhySkip: More Phys to discover\n"));
/* continue discovery for the next phy */
dmDiscoverSend(dmRoot, oneDeviceData);
}
/* If the last phy */
else
{
DM_DBG2(("dmDownStreamDiscover2ExpanderPhySkip: No More Phys\n"));
/* for MCN */
dmUpdateAllAdjacent(dmRoot, onePortContext, oneDeviceData);
/* remove the expander from the discovering list */
dmDiscoveringExpanderRemove(dmRoot, onePortContext, oneExpander);
/* continue downstream discovering */
dmDownStreamDiscovering(dmRoot, onePortContext, oneDeviceData);
}
}
else
{
DM_DBG2(("dmDownStreamDiscover2ExpanderPhySkip: onePortContext->discovery.status not in DISCOVERY_DOWN_STREAM; status %d\n", onePortContext->discovery.status));
}
DM_DBG2(("dmDownStreamDiscover2ExpanderPhySkip: end return phyID#%d\n", oneExpander->discoveringPhyId - 1));
return;
}
osGLOBAL void
dmExpanderUpStreamPhyAdd(
dmRoot_t *dmRoot,
dmExpander_t *oneExpander,
bit8 phyId
)
{
bit32 i;
bit32 hasSet = agFALSE;
DM_DBG3(("dmExpanderUpStreamPhyAdd: start, phyid %d\n", phyId));
DM_DBG3(("dmExpanderUpStreamPhyAdd: exp addrHi 0x%08x\n", oneExpander->dmDevice->SASAddressID.sasAddressHi));
DM_DBG3(("dmExpanderUpStreamPhyAdd: exp addrLo 0x%08x\n", oneExpander->dmDevice->SASAddressID.sasAddressLo));
DM_DBG3(("dmExpanderUpStreamPhyAdd: phyid %d numOfUpStreamPhys %d\n", phyId, oneExpander->numOfUpStreamPhys));
for ( i = 0; i < oneExpander->numOfUpStreamPhys; i ++ )
{
if ( oneExpander->upStreamPhys[i] == phyId )
{
hasSet = agTRUE;
break;
}
}
if ( hasSet == agFALSE )
{
oneExpander->upStreamPhys[oneExpander->numOfUpStreamPhys ++] = phyId;
}
DM_DBG3(("dmExpanderUpStreamPhyAdd: AFTER phyid %d numOfUpStreamPhys %d\n", phyId, oneExpander->numOfUpStreamPhys));
/* for debugging */
for ( i = 0; i < oneExpander->numOfUpStreamPhys; i ++ )
{
DM_DBG3(("dmExpanderUpStreamPhyAdd: index %d upstream[index] %d\n", i, oneExpander->upStreamPhys[i]));
}
return;
}
osGLOBAL void
dmExpanderDownStreamPhyAdd(
dmRoot_t *dmRoot,
dmExpander_t *oneExpander,
bit8 phyId
)
{
bit32 i;
bit32 hasSet = agFALSE;
DM_DBG3(("dmExpanderDownStreamPhyAdd: start, phyid %d\n", phyId));
DM_DBG3(("dmExpanderDownStreamPhyAdd: exp addrHi 0x%08x\n", oneExpander->dmDevice->SASAddressID.sasAddressHi));
DM_DBG3(("dmExpanderDownStreamPhyAdd: exp addrLo 0x%08x\n", oneExpander->dmDevice->SASAddressID.sasAddressLo));
DM_DBG3(("dmExpanderDownStreamPhyAdd: phyid %d numOfDownStreamPhys %d\n", phyId, oneExpander->numOfDownStreamPhys));
for ( i = 0; i < oneExpander->numOfDownStreamPhys; i ++ )
{
if ( oneExpander->downStreamPhys[i] == phyId )
{
hasSet = agTRUE;
break;
}
}
if ( hasSet == agFALSE )
{
oneExpander->downStreamPhys[oneExpander->numOfDownStreamPhys ++] = phyId;
}
DM_DBG3(("dmExpanderDownStreamPhyAdd: AFTER phyid %d numOfDownStreamPhys %d\n", phyId, oneExpander->numOfDownStreamPhys));
/* for debugging */
for ( i = 0; i < oneExpander->numOfDownStreamPhys; i ++ )
{
DM_DBG3(("dmExpanderDownStreamPhyAdd: index %d downstream[index] %d\n", i, oneExpander->downStreamPhys[i]));
}
return;
}
osGLOBAL void
dmDiscoveryReportMCN(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext
)
{
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
dmDeviceData_t *oneDeviceData = agNULL;
dmList_t *DeviceListList;
bit16 extension = 0;
dmDeviceData_t *oneAttachedExpDeviceData = agNULL;
DM_DBG2(("dmDiscoveryReportMCN: start\n"));
/*
if full disocvery, report all devices using MCN
if incremental discovery,
1. compare MCN and PrevMCN
2. report the changed ones; report MCN
3. set PrevMCN to MCN
PrevMCN = MCN
*/
DeviceListList = dmAllShared->MainDeviceList.flink;
while (DeviceListList != &(dmAllShared->MainDeviceList))
{
oneDeviceData = DMLIST_OBJECT_BASE(dmDeviceData_t, MainLink, DeviceListList);
if ( oneDeviceData == agNULL)
{
DM_DBG1(("dmDiscoveryReportMCN: oneDeviceData is NULL!!!\n"));
return;
}
DM_DBG3(("dmDiscoveryReportMCN: loop did %d\n", oneDeviceData->id));
if (oneDeviceData->dmPortContext == onePortContext)
{
DM_DBG2(("dmDiscoveryReportMCN: oneDeviceData sasAddressHi 0x%08x sasAddressLo 0x%08x\n",
oneDeviceData->SASAddressID.sasAddressHi, oneDeviceData->SASAddressID.sasAddressLo));
DM_DBG2(("dmDiscoveryReportMCN: MCN 0x%08x PrevMCN 0x%08x\n", oneDeviceData->MCN, oneDeviceData->PrevMCN));
if (onePortContext->discovery.type == DM_DISCOVERY_OPTION_FULL_START)
{
DM_DBG2(("dmDiscoveryReportMCN: FULL_START\n"));
}
else
{
DM_DBG2(("dmDiscoveryReportMCN: INCREMENTAL_START\n"));
}
/*
if MCN is 0, the device is removed
*/
if (oneDeviceData->MCN != oneDeviceData->PrevMCN && oneDeviceData->MCN != 0)
{
DM_DBG2(("dmDiscoveryReportMCN: reporting \n"));
extension = oneDeviceData->dmDeviceInfo.ext;
/* zero out MCN in extension */
extension = extension & 0x7FF;
/* sets MCN in extension */
extension = extension | (oneDeviceData->MCN << 11);
DEVINFO_PUT_EXT(&(oneDeviceData->dmDeviceInfo), extension);
DM_DBG5(("dmDiscoveryReportMCN: MCN 0x%08x PrevMCN 0x%08x\n", DEVINFO_GET_EXT_MCN(&(oneDeviceData->dmDeviceInfo)), oneDeviceData->PrevMCN));
if (oneDeviceData->ExpDevice != agNULL)
{
DM_DBG2(("dmDiscoveryReportMCN: attached expander case\n"));
oneAttachedExpDeviceData = oneDeviceData->ExpDevice;
tddmReportDevice(dmRoot, onePortContext->dmPortContext, &oneDeviceData->dmDeviceInfo, &oneAttachedExpDeviceData->dmDeviceInfo, dmDeviceMCNChange);
}
else
{
DM_DBG2(("dmDiscoveryReportMCN: No attached expander case\n"));
tddmReportDevice(dmRoot, onePortContext->dmPortContext, &oneDeviceData->dmDeviceInfo, agNULL, dmDeviceMCNChange);
}
oneDeviceData->PrevMCN = oneDeviceData->MCN;
}
else
{
DM_DBG2(("dmDiscoveryReportMCN: No change; no reporting \n"));
if (oneDeviceData->MCN == 0)
{
oneDeviceData->PrevMCN = oneDeviceData->MCN;
}
}
}
DeviceListList = DeviceListList->flink;
}
return;
}
osGLOBAL void
dmDiscoveryDumpMCN(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext
)
{
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
dmDeviceData_t *oneDeviceData = agNULL;
dmList_t *DeviceListList;
DM_DBG3(("dmDiscoveryDumpMCN: start\n"));
DeviceListList = dmAllShared->MainDeviceList.flink;
while (DeviceListList != &(dmAllShared->MainDeviceList))
{
oneDeviceData = DMLIST_OBJECT_BASE(dmDeviceData_t, MainLink, DeviceListList);
if (oneDeviceData == agNULL)
{
DM_DBG1(("dmDiscoveryDumpMCN: oneDeviceData is NULL!!!\n"));
return;
}
DM_DBG3(("dmDiscoveryDumpMCN: loop did %d\n", oneDeviceData->id));
if (oneDeviceData->dmPortContext == onePortContext)
{
DM_DBG3(("dmDiscoveryDumpMCN: oneDeviceData sasAddressHi 0x%08x sasAddressLo 0x%08x\n",
oneDeviceData->SASAddressID.sasAddressHi, oneDeviceData->SASAddressID.sasAddressLo));
DM_DBG3(("dmDiscoveryDumpMCN: MCN 0x%08x PrevMCN 0x%08x\n", oneDeviceData->MCN, oneDeviceData->PrevMCN));
}
DeviceListList = DeviceListList->flink;
}
return;
}
osGLOBAL void
dmDiscoveryResetMCN(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext
)
{
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
dmDeviceData_t *oneDeviceData = agNULL;
dmList_t *DeviceListList;
DM_DBG2(("dmDiscoveryResetMCN: start\n"));
/* reinitialize the device data belonging to this portcontext */
DeviceListList = dmAllShared->MainDeviceList.flink;
while (DeviceListList != &(dmAllShared->MainDeviceList))
{
oneDeviceData = DMLIST_OBJECT_BASE(dmDeviceData_t, MainLink, DeviceListList);
if (oneDeviceData == agNULL)
{
DM_DBG1(("dmDiscoveryResetMCN: oneDeviceData is NULL!!!\n"));
return;
}
DM_DBG3(("dmDiscoveryResetMCN: loop did %d\n", oneDeviceData->id));
if (oneDeviceData->dmPortContext == onePortContext)
{
if (oneDeviceData->ExpDevice != agNULL)
{
DM_DBG2(("dmDiscoveryResetMCN: resetting oneDeviceData->ExpDevice\n"));
oneDeviceData->ExpDevice = agNULL;
}
DM_DBG3(("dmDiscoveryResetMCN: resetting MCN and MCNdone\n"));
oneDeviceData->MCN = 0;
oneDeviceData->MCNDone = agFALSE;
DM_DBG2(("dmDiscoveryResetMCN: oneDeviceData sasAddressHi 0x%08x sasAddressLo 0x%08x\n",
oneDeviceData->SASAddressID.sasAddressHi, oneDeviceData->SASAddressID.sasAddressLo));
}
DeviceListList = DeviceListList->flink;
}
return;
}
/*
do min(oneDeviceData, found-one) in all upstream and downstream
find ajcanent expanders and mark it done; sees only ajcacent targets
*/
osGLOBAL void
dmUpdateAllAdjacent(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
dmDeviceData_t *oneDeviceData /* current one */
)
{
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
dmDeviceData_t *tmponeDeviceData = agNULL;
dmList_t *DeviceListList;
DM_DBG2(("dmUpdateAllAdjacent: start\n"));
if (oneDeviceData == agNULL)
{
DM_DBG1(("dmUpdateAllAdjacent: oneDeviceData is NULL!!!\n"));
return;
}
oneDeviceData->MCNDone = agTRUE;
DM_DBG2(("dmUpdateAllAdjacent: oneDeviceData sasAddressHi 0x%08x sasAddressLo 0x%08x\n",
oneDeviceData->SASAddressID.sasAddressHi, oneDeviceData->SASAddressID.sasAddressLo));
DeviceListList = dmAllShared->MainDeviceList.flink;
while (DeviceListList != &(dmAllShared->MainDeviceList))
{
tmponeDeviceData = DMLIST_OBJECT_BASE(dmDeviceData_t, MainLink, DeviceListList);
if ( tmponeDeviceData == agNULL)
{
DM_DBG1(("dmUpdateAllAdjacent: tmponeDeviceData is NULL!!!\n"));
return;
}
DM_DBG3(("dmUpdateAllAdjacent: loop did %d\n", tmponeDeviceData->id));
if (tmponeDeviceData->dmPortContext == onePortContext && tmponeDeviceData->ExpDevice == oneDeviceData)
{
DM_DBG2(("dmUpdateAllAdjacent: setting MCN DONE\n"));
DM_DBG2(("dmUpdateAllAdjacent: tmponeDeviceData sasAddressHi 0x%08x sasAddressLo 0x%08x\n",
tmponeDeviceData->SASAddressID.sasAddressHi, tmponeDeviceData->SASAddressID.sasAddressLo));
tmponeDeviceData->MCNDone = agTRUE;
if (oneDeviceData->directlyAttached == agFALSE)
{
DM_DBG2(("dmUpdateAllAdjacent: tmponeDeviceData MCN 0x%x\n", tmponeDeviceData->MCN));
DM_DBG2(("dmUpdateAllAdjacent: oneDeviceData MCN 0x%x\n", oneDeviceData->MCN));
tmponeDeviceData->MCN = MIN(oneDeviceData->MCN, tmponeDeviceData->MCN);
}
}
DeviceListList = DeviceListList->flink;
}
return;
}
osGLOBAL void
dmUpdateMCN(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
dmDeviceData_t *AdjacentDeviceData, /* adjacent expander */
dmDeviceData_t *oneDeviceData /* current one */
)
{
DM_DBG2(("dmUpdateMCN: start\n"));
if (AdjacentDeviceData == agNULL)
{
DM_DBG1(("dmUpdateMCN: AdjacentDeviceData is NULL!!!\n"));
return;
}
if (oneDeviceData == agNULL)
{
DM_DBG1(("dmUpdateMCN: oneDeviceData is NULL!!!\n"));
return;
}
DM_DBG2(("dmUpdateMCN: Current sasAddressHi 0x%08x sasAddressLo 0x%08x\n",
oneDeviceData->SASAddressID.sasAddressHi, oneDeviceData->SASAddressID.sasAddressLo));
DM_DBG2(("dmUpdateMCN: AdjacentDeviceData one sasAddressHi 0x%08x sasAddressLo 0x%08x\n",
AdjacentDeviceData->SASAddressID.sasAddressHi, AdjacentDeviceData->SASAddressID.sasAddressLo));
if (onePortContext->discovery.status == DISCOVERY_UP_STREAM)
{
DM_DBG2(("dmUpdateMCN: DISCOVERY_UP_STREAM\n"));
}
if (onePortContext->discovery.status == DISCOVERY_DOWN_STREAM)
{
DM_DBG2(("dmUpdateMCN: DISCOVERY_DOWN_STREAM\n"));
}
/* MCN */
/* directly attached one does not have MCN
update only adjacent device data
*/
if (oneDeviceData->directlyAttached == agTRUE && AdjacentDeviceData->MCNDone == agFALSE)
{
AdjacentDeviceData->MCN++;
DM_DBG2(("dmUpdateMCN: case 1 oneDeviceData MCN 0x%x\n", oneDeviceData->MCN));
DM_DBG2(("dmUpdateMCN: case 1 AdjacentDeviceData MCN 0x%x\n", AdjacentDeviceData->MCN));
}
else if (AdjacentDeviceData->MCNDone == agFALSE)
{
AdjacentDeviceData->MCN++;
AdjacentDeviceData->MCN = MIN(oneDeviceData->MCN, AdjacentDeviceData->MCN);
DM_DBG2(("dmUpdateMCN: case 2 oneDeviceData MCN 0x%x\n", oneDeviceData->MCN));
DM_DBG2(("dmUpdateMCN: case 2 AdjacentDeviceData MCN 0x%x\n", AdjacentDeviceData->MCN));
}
return;
}
/* go through expander list and device list array ??? */
osGLOBAL dmDeviceData_t *
dmPortSASDeviceFind(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
bit32 sasAddrLo,
bit32 sasAddrHi,
dmDeviceData_t *CurrentDeviceData /* current expander */
)
{
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
dmDeviceData_t *oneDeviceData, *RetDeviceData=agNULL;
dmList_t *DeviceListList;
DM_DBG3(("dmPortSASDeviceFind: start\n"));
DM_DBG3(("dmPortSASDeviceFind: sasAddressHi 0x%08x sasAddressLo 0x%08x\n", sasAddrHi, sasAddrLo));
DM_ASSERT((agNULL != dmRoot), "");
DM_ASSERT((agNULL != onePortContext), "");
tddmSingleThreadedEnter(dmRoot, DM_DEVICE_LOCK);
/* find a device's existence */
DeviceListList = dmAllShared->MainDeviceList.flink;
if (onePortContext->discovery.type == DM_DISCOVERY_OPTION_FULL_START)
{
DM_DBG3(("dmPortSASDeviceFind: Full discovery\n"));
while (DeviceListList != &(dmAllShared->MainDeviceList))
{
oneDeviceData = DMLIST_OBJECT_BASE(dmDeviceData_t, MainLink, DeviceListList);
if (oneDeviceData == agNULL)
{
DM_DBG1(("dmPortSASDeviceFind: oneDeviceData is NULL!!!\n"));
return agNULL;
}
if ((oneDeviceData->SASAddressID.sasAddressHi == sasAddrHi) &&
(oneDeviceData->SASAddressID.sasAddressLo == sasAddrLo) &&
(oneDeviceData->valid == agTRUE) &&
(oneDeviceData->dmPortContext == onePortContext)
)
{
DM_DBG3(("dmPortSASDeviceFind: Found pid %d did %d\n", onePortContext->id, oneDeviceData->id));
DM_DBG3(("dmPortSASDeviceFind: sasAddressHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi));
DM_DBG3(("dmPortSASDeviceFind: sasAddressLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo));
RetDeviceData = oneDeviceData;
dmUpdateMCN(dmRoot, onePortContext, RetDeviceData, CurrentDeviceData);
break;
}
DeviceListList = DeviceListList->flink;
}
}
else
{
/* incremental discovery */
DM_DBG3(("dmPortSASDeviceFind: Incremental discovery\n"));
while (DeviceListList != &(dmAllShared->MainDeviceList))
{
oneDeviceData = DMLIST_OBJECT_BASE(dmDeviceData_t, MainLink, DeviceListList);
if (oneDeviceData == agNULL)
{
DM_DBG1(("dmPortSASDeviceFind: oneDeviceData is NULL!!!\n"));
return agNULL;
}
if ((oneDeviceData->SASAddressID.sasAddressHi == sasAddrHi) &&
(oneDeviceData->SASAddressID.sasAddressLo == sasAddrLo) &&
(oneDeviceData->valid2 == agTRUE) &&
(oneDeviceData->dmPortContext == onePortContext)
)
{
DM_DBG3(("dmPortSASDeviceFind: Found pid %d did %d\n", onePortContext->id, oneDeviceData->id));
DM_DBG3(("dmPortSASDeviceFind: sasAddressHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi));
DM_DBG3(("dmPortSASDeviceFind: sasAddressLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo));
RetDeviceData = oneDeviceData;
dmUpdateMCN(dmRoot, onePortContext, RetDeviceData, CurrentDeviceData);
break;
}
DeviceListList = DeviceListList->flink;
}
}
tddmSingleThreadedLeave(dmRoot, DM_DEVICE_LOCK);
return RetDeviceData;
}
bit32
dmNewEXPorNot(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
dmSASSubID_t *dmSASSubID
)
{
// dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
// dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
dmExpander_t *oneExpander = agNULL;
dmList_t *ExpanderList;
bit32 ret = agTRUE;
dmDeviceData_t *oneDeviceData = agNULL;
DM_DBG3(("dmNewEXPorNot: start\n"));
/* find a device's existence */
ExpanderList = onePortContext->discovery.discoveringExpanderList.flink;
while (ExpanderList != &(onePortContext->discovery.discoveringExpanderList))
{
oneExpander = DMLIST_OBJECT_BASE(dmExpander_t, linkNode, ExpanderList);
if ( oneExpander == agNULL)
{
DM_DBG1(("dmNewEXPorNot: oneExpander is NULL!!!\n"));
return agFALSE;
}
oneDeviceData = oneExpander->dmDevice;
if ((oneDeviceData->SASAddressID.sasAddressHi == dmSASSubID->sasAddressHi) &&
(oneDeviceData->SASAddressID.sasAddressLo == dmSASSubID->sasAddressLo) &&
(oneDeviceData->dmPortContext == onePortContext)
)
{
DM_DBG3(("dmNewEXPorNot: Found pid %d did %d\n", onePortContext->id, oneDeviceData->id));
ret = agFALSE;
break;
}
ExpanderList = ExpanderList->flink;
}
return ret;
}
bit32
dmNewSASorNot(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
dmSASSubID_t *dmSASSubID
)
{
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
dmDeviceData_t *oneDeviceData = agNULL;
dmList_t *DeviceListList;
bit32 ret = agTRUE;
DM_DBG3(("dmNewSASorNot: start\n"));
/* find a device's existence */
DeviceListList = dmAllShared->MainDeviceList.flink;
while (DeviceListList != &(dmAllShared->MainDeviceList))
{
oneDeviceData = DMLIST_OBJECT_BASE(dmDeviceData_t, MainLink, DeviceListList);
if (oneDeviceData == agNULL)
{
DM_DBG1(("dmNewSASorNot: oneDeviceData is NULL!!!\n"));
return agFALSE;
}
if ((oneDeviceData->SASAddressID.sasAddressHi == dmSASSubID->sasAddressHi) &&
(oneDeviceData->SASAddressID.sasAddressLo == dmSASSubID->sasAddressLo) &&
(oneDeviceData->dmPortContext == onePortContext) &&
(oneDeviceData->registered == agTRUE)
)
{
DM_DBG3(("dmNewSASorNot: Found pid %d did %d\n", onePortContext->id, oneDeviceData->id));
ret = agFALSE;
break;
}
DeviceListList = DeviceListList->flink;
}
return ret;
}
/*
call
osGLOBAL bit32
tddmReportDevice(
dmRoot_t *dmRoot,
dmPortContext_t *dmPortContext,
dmDeviceInfo_t *dmDeviceInfo
)
if not reported, report Device to TDM
*/
osGLOBAL dmDeviceData_t *
dmPortSASDeviceAdd(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
agsaSASIdentify_t sasIdentify,
bit32 sasInitiator,
bit8 connectionRate,
bit32 itNexusTimeout,
bit32 firstBurstSize,
bit32 deviceType,
dmDeviceData_t *oneExpDeviceData,
dmExpander_t *dmExpander,
bit8 phyID
)
{
dmDeviceData_t *oneDeviceData = agNULL;
bit8 dev_s_rate = 0;
bit8 sasorsata = 1;
dmSASSubID_t dmSASSubID;
bit8 ExpanderConnectionRate = connectionRate;
dmDeviceData_t *oneAttachedExpDeviceData = agNULL;
bit16 extension = 0;
bit32 current_link_rate = 0;
DM_DBG3(("dmPortSASDeviceAdd: start\n"));
DM_DBG3(("dmPortSASDeviceAdd: connectionRate %d\n", connectionRate));
dmSASSubID.sasAddressHi = SA_IDFRM_GET_SAS_ADDRESSHI(&sasIdentify);
dmSASSubID.sasAddressLo = SA_IDFRM_GET_SAS_ADDRESSLO(&sasIdentify);
dmSASSubID.initiator_ssp_stp_smp = sasIdentify.initiator_ssp_stp_smp;
dmSASSubID.target_ssp_stp_smp = sasIdentify.target_ssp_stp_smp;
if (oneExpDeviceData != agNULL)
{
ExpanderConnectionRate = DEVINFO_GET_LINKRATE(&oneExpDeviceData->agDeviceInfo);
DM_DBG3(("dmPortSASDeviceAdd: ExpanderConnectionRate 0x%x\n", ExpanderConnectionRate));
}
if (oneExpDeviceData != agNULL)
{
if (oneExpDeviceData->SASAddressID.sasAddressHi == 0x0 &&
oneExpDeviceData->SASAddressID.sasAddressLo == 0x0)
{
DM_DBG1(("dmPortSASDeviceAdd: 1st Wrong expander!!!\n"));
}
}
/* old device and already reported to TDM */
if ( agFALSE == dmNewSASorNot(
dmRoot,
onePortContext,
&dmSASSubID
)
) /* old device */
{
DM_DBG3(("dmPortSASDeviceAdd: OLD qqqq initiator_ssp_stp_smp %d target_ssp_stp_smp %d\n", dmSASSubID.initiator_ssp_stp_smp, dmSASSubID.target_ssp_stp_smp));
/* allocate a new device and set the valid bit */
oneDeviceData = dmAddSASToSharedcontext(
dmRoot,
onePortContext,
&dmSASSubID,
oneExpDeviceData,
phyID
);
if (oneDeviceData == agNULL)
{
DM_DBG1(("dmPortSASDeviceAdd: no more device, oneDeviceData is null!!!\n"));
}
/* If a device is allocated */
if ( oneDeviceData != agNULL )
{
if (onePortContext->discovery.status == DISCOVERY_UP_STREAM)
{
DM_DBG3(("dmPortSASDeviceAdd: OLD, UP_STREAM\n"));
}
if (onePortContext->discovery.status == DISCOVERY_DOWN_STREAM)
{
DM_DBG3(("dmPortSASDeviceAdd: OLD, DOWN_STREAM\n"));
}
if (onePortContext->discovery.type == DM_DISCOVERY_OPTION_FULL_START)
{
DM_DBG3(("dmPortSASDeviceAdd: FULL_START\n"));
oneDeviceData->MCN++;
}
else
{
/* incremental */
DM_DBG3(("dmPortSASDeviceAdd: INCREMENTAL_START\n"));
if (oneDeviceData->MCN == 0 && oneDeviceData->directlyAttached == agFALSE)
{
oneDeviceData->MCN++;
}
}
DM_DBG3(("dmPortSASDeviceAdd: oneDeviceData MCN 0x%08x\n", oneDeviceData->MCN));
DM_DBG3(("dmPortSASDeviceAdd: oneDeviceData sasAddressHi 0x%08x sasAddressLo 0x%08x\n",
oneDeviceData->SASAddressID.sasAddressHi, oneDeviceData->SASAddressID.sasAddressLo));
DM_DBG3(("dmPortSASDeviceAdd: sasAddressHi 0x%08x\n", SA_IDFRM_GET_SAS_ADDRESSHI(&sasIdentify)));
DM_DBG3(("dmPortSASDeviceAdd: sasAddressLo 0x%08x\n", SA_IDFRM_GET_SAS_ADDRESSLO(&sasIdentify)));
// oneDeviceData->sasIdentify = sasIdentify;
dm_memcpy(&(oneDeviceData->sasIdentify), &sasIdentify, sizeof(agsaSASIdentify_t));
DM_DBG3(("dmPortSASDeviceAdd: sasAddressHi 0x%08x\n", SA_IDFRM_GET_SAS_ADDRESSHI(&oneDeviceData->sasIdentify)));
DM_DBG3(("dmPortSASDeviceAdd: sasAddressLo 0x%08x\n", SA_IDFRM_GET_SAS_ADDRESSLO(&oneDeviceData->sasIdentify)));
/* parse sasIDframe to fill in agDeviceInfo */
DEVINFO_PUT_SMPTO(&oneDeviceData->agDeviceInfo, DEFAULT_SMP_TIMEOUT);
DEVINFO_PUT_ITNEXUSTO(&oneDeviceData->agDeviceInfo, (bit16)itNexusTimeout);
DEVINFO_PUT_FBS(&oneDeviceData->agDeviceInfo, (bit16)firstBurstSize);
DEVINFO_PUT_FLAG(&oneDeviceData->agDeviceInfo, 1);
oneDeviceData->SASSpecDeviceType = SA_IDFRM_GET_DEVICETTYPE(&sasIdentify);
/* adjusting connectionRate */
oneAttachedExpDeviceData = oneDeviceData->ExpDevice;
if (oneAttachedExpDeviceData != agNULL)
{
connectionRate = MIN(connectionRate, DEVINFO_GET_LINKRATE(&oneAttachedExpDeviceData->agDeviceInfo));
DM_DBG3(("dmPortSASDeviceAdd: 1st connectionRate 0x%x DEVINFO_GET_LINKRATE(&oneAttachedExpDeviceData->agDeviceInfo) 0x%x\n",
connectionRate, DEVINFO_GET_LINKRATE(&oneAttachedExpDeviceData->agDeviceInfo)));
}
else
{
DM_DBG3(("dmPortSASDeviceAdd: 1st oneAttachedExpDeviceData is NULL\n"));
}
/* Device Type, SAS or SATA, connection rate; bit7 --- bit0 */
sasorsata = (bit8)deviceType;
/* sTSDK spec device typ */
dev_s_rate = dev_s_rate | (sasorsata << 4);
dev_s_rate = dev_s_rate | MIN(connectionRate, ExpanderConnectionRate);
/* detect link rate change */
current_link_rate = DEVINFO_GET_LINKRATE(&oneDeviceData->agDeviceInfo);
if (current_link_rate != (bit32)MIN(connectionRate, ExpanderConnectionRate))
{
DM_DBG1(("dmPortSASDeviceAdd: link rate changed current 0x%x new 0x%x\n", current_link_rate, MIN(connectionRate, ExpanderConnectionRate)));
DEVINFO_PUT_DEV_S_RATE(&oneDeviceData->dmDeviceInfo, dev_s_rate);
if (oneDeviceData->ExpDevice != agNULL)
{
oneAttachedExpDeviceData = oneDeviceData->ExpDevice;
tddmReportDevice(dmRoot, onePortContext->dmPortContext, &oneDeviceData->dmDeviceInfo, &oneAttachedExpDeviceData->dmDeviceInfo, dmDeviceRateChange);
}
else
{
tddmReportDevice(dmRoot, onePortContext->dmPortContext, &oneDeviceData->dmDeviceInfo, agNULL, dmDeviceArrival);
}
}
DEVINFO_PUT_DEV_S_RATE(&oneDeviceData->agDeviceInfo, dev_s_rate);
DEVINFO_PUT_SAS_ADDRESSLO(
&oneDeviceData->agDeviceInfo,
SA_IDFRM_GET_SAS_ADDRESSLO(&oneDeviceData->sasIdentify)
);
DEVINFO_PUT_SAS_ADDRESSHI(
&oneDeviceData->agDeviceInfo,
SA_IDFRM_GET_SAS_ADDRESSHI(&oneDeviceData->sasIdentify)
);
oneDeviceData->agContext.osData = oneDeviceData;
oneDeviceData->agContext.sdkData = agNULL;
}
return oneDeviceData;
} /* old device */
/* new device */
DM_DBG3(("dmPortSASDeviceAdd: NEW qqqq initiator_ssp_stp_smp %d target_ssp_stp_smp %d\n", dmSASSubID.initiator_ssp_stp_smp, dmSASSubID.target_ssp_stp_smp));
/* allocate a new device and set the valid bit */
oneDeviceData = dmAddSASToSharedcontext(
dmRoot,
onePortContext,
&dmSASSubID,
oneExpDeviceData,
phyID
);
if (oneDeviceData == agNULL)
{
DM_DBG1(("dmPortSASDeviceAdd: no more device, oneDeviceData is null !!!\n"));
}
/* If a device is allocated */
if ( oneDeviceData != agNULL )
{
// DM_DBG3(("dmPortSASDeviceAdd: sasAddressHi 0x%08x\n", SA_IDFRM_GET_SAS_ADDRESSHI(&sasIdentify)));
// DM_DBG3(("dmPortSASDeviceAdd: sasAddressLo 0x%08x\n", SA_IDFRM_GET_SAS_ADDRESSLO(&sasIdentify)));
// oneDeviceData->sasIdentify = sasIdentify;
dm_memcpy(&(oneDeviceData->sasIdentify), &sasIdentify, sizeof(agsaSASIdentify_t));
if (onePortContext->discovery.status == DISCOVERY_UP_STREAM)
{
DM_DBG3(("dmPortSASDeviceAdd: NEW, UP_STREAM\n"));
}
if (onePortContext->discovery.status == DISCOVERY_DOWN_STREAM)
{
DM_DBG3(("dmPortSASDeviceAdd: NEW, DOWN_STREAM\n"));
}
if (onePortContext->discovery.type == DM_DISCOVERY_OPTION_FULL_START)
{
DM_DBG3(("dmPortSASDeviceAdd: FULL_START\n"));
oneDeviceData->MCN++;
}
else
{
/* incremental */
DM_DBG3(("dmPortSASDeviceAdd: INCREMENTAL_START\n"));
if (oneDeviceData->MCN == 0 && oneDeviceData->directlyAttached == agFALSE)
{
oneDeviceData->MCN++;
}
}
DM_DBG3(("dmPortSASDeviceAdd: oneDeviceData MCN 0x%08x\n", oneDeviceData->MCN));
DM_DBG3(("dmPortSASDeviceAdd: oneDeviceData sasAddressHi 0x%08x sasAddressLo 0x%08x\n",
oneDeviceData->SASAddressID.sasAddressHi, oneDeviceData->SASAddressID.sasAddressLo));
DM_DBG3(("dmPortSASDeviceAdd: sasAddressHi 0x%08x\n", SA_IDFRM_GET_SAS_ADDRESSHI(&oneDeviceData->sasIdentify)));
DM_DBG3(("dmPortSASDeviceAdd: sasAddressLo 0x%08x\n", SA_IDFRM_GET_SAS_ADDRESSLO(&oneDeviceData->sasIdentify)));
/* parse sasIDframe to fill in agDeviceInfo */
DEVINFO_PUT_SMPTO(&oneDeviceData->agDeviceInfo, DEFAULT_SMP_TIMEOUT);
DEVINFO_PUT_ITNEXUSTO(&oneDeviceData->agDeviceInfo, (bit16)itNexusTimeout);
DEVINFO_PUT_FBS(&oneDeviceData->agDeviceInfo, (bit16)firstBurstSize);
DEVINFO_PUT_FLAG(&oneDeviceData->agDeviceInfo, 1);
oneDeviceData->SASSpecDeviceType = SA_IDFRM_GET_DEVICETTYPE(&sasIdentify);
/* adjusting connectionRate */
oneAttachedExpDeviceData = oneDeviceData->ExpDevice;
if (oneAttachedExpDeviceData != agNULL)
{
connectionRate = MIN(connectionRate, DEVINFO_GET_LINKRATE(&oneAttachedExpDeviceData->agDeviceInfo));
DM_DBG3(("dmPortSASDeviceAdd: 2nd connectionRate 0x%x DEVINFO_GET_LINKRATE(&oneAttachedExpDeviceData->agDeviceInfo) 0x%x\n",
connectionRate, DEVINFO_GET_LINKRATE(&oneAttachedExpDeviceData->agDeviceInfo)));
}
else
{
DM_DBG3(("dmPortSASDeviceAdd: 2nd oneAttachedExpDeviceData is NULL\n"));
}
/* Device Type, SAS or SATA, connection rate; bit7 --- bit0 */
sasorsata = (bit8)deviceType;
dev_s_rate = dev_s_rate | (sasorsata << 4);
dev_s_rate = dev_s_rate | MIN(connectionRate, ExpanderConnectionRate);
DEVINFO_PUT_DEV_S_RATE(&oneDeviceData->agDeviceInfo, dev_s_rate);
DEVINFO_PUT_SAS_ADDRESSLO(
&oneDeviceData->agDeviceInfo,
SA_IDFRM_GET_SAS_ADDRESSLO(&oneDeviceData->sasIdentify)
);
DEVINFO_PUT_SAS_ADDRESSHI(
&oneDeviceData->agDeviceInfo,
SA_IDFRM_GET_SAS_ADDRESSHI(&oneDeviceData->sasIdentify)
);
oneDeviceData->agContext.osData = oneDeviceData;
oneDeviceData->agContext.sdkData = agNULL;
DM_DBG3(("dmPortSASDeviceAdd: did %d\n", oneDeviceData->id));
/* reporting to TDM; setting dmDeviceInfo */
DEVINFO_PUT_SMPTO(&oneDeviceData->dmDeviceInfo, DEFAULT_SMP_TIMEOUT);
DEVINFO_PUT_ITNEXUSTO(&oneDeviceData->dmDeviceInfo, (bit16)itNexusTimeout);
DEVINFO_PUT_FBS(&oneDeviceData->dmDeviceInfo, (bit16)firstBurstSize);
DEVINFO_PUT_FLAG(&oneDeviceData->dmDeviceInfo, 1);
DEVINFO_PUT_INITIATOR_SSP_STP_SMP(&oneDeviceData->dmDeviceInfo, dmSASSubID.initiator_ssp_stp_smp);
DEVINFO_PUT_TARGET_SSP_STP_SMP(&oneDeviceData->dmDeviceInfo, dmSASSubID.target_ssp_stp_smp);
extension = phyID;
/* setting 6th bit of dev_s_rate */
if (oneDeviceData->SASSpecDeviceType == SAS_EDGE_EXPANDER_DEVICE ||
oneDeviceData->SASSpecDeviceType == SAS_FANOUT_EXPANDER_DEVICE )
{
extension = (bit16)(extension | (1 << 8));
}
DEVINFO_PUT_EXT(&oneDeviceData->dmDeviceInfo, extension);
DEVINFO_PUT_DEV_S_RATE(&oneDeviceData->dmDeviceInfo, dev_s_rate);
DEVINFO_PUT_SAS_ADDRESSLO(
&oneDeviceData->dmDeviceInfo,
SA_IDFRM_GET_SAS_ADDRESSLO(&oneDeviceData->sasIdentify)
);
DEVINFO_PUT_SAS_ADDRESSHI(
&oneDeviceData->dmDeviceInfo,
SA_IDFRM_GET_SAS_ADDRESSHI(&oneDeviceData->sasIdentify)
);
if (oneDeviceData->ExpDevice != agNULL)
{
DM_DBG3(("dmPortSASDeviceAdd: attached expander case\n"));
oneAttachedExpDeviceData = oneDeviceData->ExpDevice;
/*
Puts attached expander's SAS address into dmDeviceInfo
*/
DEVINFO_PUT_SAS_ADDRESSLO(
&oneAttachedExpDeviceData->dmDeviceInfo,
oneAttachedExpDeviceData->SASAddressID.sasAddressLo
);
DEVINFO_PUT_SAS_ADDRESSHI(
&oneAttachedExpDeviceData->dmDeviceInfo,
oneAttachedExpDeviceData->SASAddressID.sasAddressHi
);
DM_DBG3(("dmPortSASDeviceAdd: oneAttachedExpDeviceData addrHi 0x%08x addrLo 0x%08x PhyID 0x%x ext 0x%x\n",
DM_GET_SAS_ADDRESSHI(oneAttachedExpDeviceData->dmDeviceInfo.sasAddressHi),
DM_GET_SAS_ADDRESSLO(oneAttachedExpDeviceData->dmDeviceInfo.sasAddressLo),
phyID, extension));
if (oneAttachedExpDeviceData->SASAddressID.sasAddressHi == 0x0 &&
oneAttachedExpDeviceData->SASAddressID.sasAddressLo == 0x0)
{
DM_DBG1(("dmPortSASDeviceAdd: 2nd Wrong expander!!!\n"));
}
if (oneDeviceData->reported == agFALSE)
{
oneDeviceData->registered = agTRUE;
oneDeviceData->reported = agTRUE;
if (deviceType == STP_DEVICE_TYPE)
{
/*STP device, DM need send SMP Report Phy SATA to get the SATA device type */
oneAttachedExpDeviceData->dmExpander->dmDeviceToProcess = oneDeviceData;
dmReportPhySataSend(dmRoot, oneAttachedExpDeviceData, phyID);
}
else
{
/* SAS or SMP device */
tddmReportDevice(dmRoot, onePortContext->dmPortContext, &oneDeviceData->dmDeviceInfo, &oneAttachedExpDeviceData->dmDeviceInfo, dmDeviceArrival);
}
}
}
else
{
DM_DBG3(("dmPortSASDeviceAdd: NO attached expander case\n"));
if (oneDeviceData->reported == agFALSE)
{
oneDeviceData->registered = agTRUE;
oneDeviceData->reported = agTRUE;
tddmReportDevice(dmRoot, onePortContext->dmPortContext, &oneDeviceData->dmDeviceInfo, agNULL, dmDeviceArrival);
}
}
}
return oneDeviceData;
}
osGLOBAL dmDeviceData_t *
dmFindRegNValid(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
dmSASSubID_t *dmSASSubID
)
{
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
dmDeviceData_t *oneDeviceData = agNULL;
dmList_t *DeviceListList;
bit32 found = agFALSE;
DM_DBG3(("dmFindRegNValid: start\n"));
/* find a device's existence */
DeviceListList = dmAllShared->MainDeviceList.flink;
if (onePortContext->discovery.type == DM_DISCOVERY_OPTION_FULL_START)
{
DM_DBG3(("dmFindRegNValid: Full discovery\n"));
while (DeviceListList != &(dmAllShared->MainDeviceList))
{
oneDeviceData = DMLIST_OBJECT_BASE(dmDeviceData_t, MainLink, DeviceListList);
if (oneDeviceData == agNULL)
{
DM_DBG1(("dmFindRegNValid: oneDeviceData is NULL!!!\n"));
return agFALSE;
}
if ((oneDeviceData->SASAddressID.sasAddressHi == dmSASSubID->sasAddressHi) &&
(oneDeviceData->SASAddressID.sasAddressLo == dmSASSubID->sasAddressLo) &&
(oneDeviceData->valid == agTRUE) &&
(oneDeviceData->dmPortContext == onePortContext)
)
{
DM_DBG3(("dmFindRegNValid: Found pid %d did %d\n", onePortContext->id, oneDeviceData->id));
DM_DBG3(("dmFindRegNValid: sasAddressHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi));
DM_DBG3(("dmFindRegNValid: sasAddressLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo));
found = agTRUE;
break;
}
DeviceListList = DeviceListList->flink;
}
}
else
{
/* incremental discovery */
DM_DBG3(("dmFindRegNValid: Incremental discovery\n"));
while (DeviceListList != &(dmAllShared->MainDeviceList))
{
oneDeviceData = DMLIST_OBJECT_BASE(dmDeviceData_t, MainLink, DeviceListList);
if (oneDeviceData == agNULL)
{
DM_DBG1(("dmFindRegNValid: oneDeviceData is NULL!!!\n"));
return agFALSE;
}
if ((oneDeviceData->SASAddressID.sasAddressHi == dmSASSubID->sasAddressHi) &&
(oneDeviceData->SASAddressID.sasAddressLo == dmSASSubID->sasAddressLo) &&
(oneDeviceData->valid2 == agTRUE) &&
(oneDeviceData->dmPortContext == onePortContext)
)
{
DM_DBG3(("dmFindRegNValid: Found pid %d did %d\n", onePortContext->id, oneDeviceData->id));
DM_DBG3(("dmFindRegNValid: sasAddressHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi));
DM_DBG3(("dmFindRegNValid: sasAddressLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo));
found = agTRUE;
break;
}
DeviceListList = DeviceListList->flink;
}
}
if (found == agFALSE)
{
DM_DBG3(("dmFindRegNValid: end returning NULL\n"));
return agNULL;
}
else
{
DM_DBG3(("dmFindRegNValid: end returning NOT NULL\n"));
return oneDeviceData;
}
}
osGLOBAL void
dmNotifyBC(
dmRoot_t *dmRoot,
dmPortContext_t *dmPortContext,
bit32 type)
{
dmIntPortContext_t *onePortContext = agNULL;
onePortContext = (dmIntPortContext_t *)dmPortContext->dmData;
DM_DBG3(("dmNotifyBC: start\n"));
if (onePortContext == agNULL)
{
DM_DBG1(("dmNotifyBC: onePortContext is NULL, wrong!!!\n"));
return;
}
if (type == OSSA_HW_EVENT_BROADCAST_CHANGE)
{
if (onePortContext->DiscoveryAbortInProgress == agFALSE)
{
if (onePortContext->DiscoveryState == DM_DSTATE_COMPLETED)
{
DM_DBG3(("dmNotifyBC: BROADCAST_CHANGE\n"));
onePortContext->DiscoveryState = DM_DSTATE_NOT_STARTED;
onePortContext->discoveryOptions = DM_DISCOVERY_OPTION_INCREMENTAL_START;
/* processed broadcast change */
onePortContext->discovery.SeenBC = agFALSE;
}
else
{
DM_DBG3(("dmNotifyBC: pid %d BROADCAST_CHANGE; updating SeenBC. Do nothing.\n", onePortContext->id));
onePortContext->discovery.SeenBC = agTRUE;
}
}
}
else if (type == OSSA_HW_EVENT_BROADCAST_SES)
{
DM_DBG3(("dmNotifyBC: OSSA_HW_EVENT_BROADCAST_SES\n"));
}
else if (type == OSSA_HW_EVENT_BROADCAST_EXP)
{
DM_DBG3(("dmNotifyBC: OSSA_HW_EVENT_BROADCAST_EXP\n"));
}
else
{
DM_DBG3(("dmNotifyBC: unspecified broadcast type 0x%x\n", type));
}
return;
}
#ifdef WORKED
/* triggers incremental discovery */
osGLOBAL void
dmNotifyBC(
dmRoot_t *dmRoot,
dmPortContext_t *dmPortContext,
bit32 type)
{
dmIntPortContext_t *onePortContext = agNULL;
onePortContext = (dmIntPortContext_t *)dmPortContext->dmData;
DM_DBG3(("dmNotifyBC: start\n"));
if (type == OSSA_HW_EVENT_BROADCAST_CHANGE)
{
if (onePortContext->DiscoveryState == DM_DSTATE_COMPLETED)
{
DM_DBG3(("dmNotifyBC: BROADCAST_CHANGE; does incremental discovery\n"));
onePortContext->DiscoveryState = DM_DSTATE_NOT_STARTED;
onePortContext->discoveryOptions = DM_DISCOVERY_OPTION_INCREMENTAL_START;
/* processed broadcast change */
onePortContext->discovery.SeenBC = agFALSE;
if (onePortContext->discovery.ResetTriggerred == agTRUE)
{
DM_DBG3(("dmNotifyBC: tdsaBCTimer\n"));
dmBCTimer(dmRoot, onePortContext);
}
else
{
dmDiscover(
dmRoot,
dmPortContext,
DM_DISCOVERY_OPTION_INCREMENTAL_START
);
}
}
else
{
DM_DBG3(("dmNotifyBC: pid %d BROADCAST_CHANGE; updating SeenBC. Do nothing.\n", onePortContext->id));
onePortContext->discovery.SeenBC = agTRUE;
}
}
else if (type == OSSA_HW_EVENT_BROADCAST_SES)
{
DM_DBG3(("dmNotifyBC: OSSA_HW_EVENT_BROADCAST_SES\n"));
}
else if (type == OSSA_HW_EVENT_BROADCAST_EXP)
{
DM_DBG3(("dmNotifyBC: OSSA_HW_EVENT_BROADCAST_EXP\n"));
}
else
{
DM_DBG3(("dmNotifyBC: unspecified broadcast type 0x%x\n", type));
}
return;
}
#endif
osGLOBAL bit32
dmResetFailedDiscovery(
dmRoot_t *dmRoot,
dmPortContext_t *dmPortContext)
{
dmIntPortContext_t *onePortContext = agNULL;
DM_DBG1(("dmResetFailedDiscovery: start\n"));
onePortContext = (dmIntPortContext_t *)dmPortContext->dmData;
if (onePortContext == agNULL)
{
DM_DBG1(("dmResetFailedDiscovery: onePortContext is NULL, wrong!!!\n"));
return DM_RC_FAILURE;
}
if (onePortContext->DiscoveryState == DM_DSTATE_COMPLETED_WITH_FAILURE)
{
onePortContext->DiscoveryState = DM_DSTATE_COMPLETED;
}
else
{
DM_DBG1(("dmResetFailedDiscovery: discovery is NOT DM_DSTATE_COMPLETED_WITH_FAILURE. It is 0x%x\n", onePortContext->DiscoveryState));
return DM_RC_FAILURE;
}
return DM_RC_SUCCESS;
}
osGLOBAL bit32
dmQueryDiscovery(
dmRoot_t *dmRoot,
dmPortContext_t *dmPortContext)
{
dmIntPortContext_t *onePortContext = agNULL;
DM_DBG3(("dmQueryDiscovery: start\n"));
onePortContext = (dmIntPortContext_t *)dmPortContext->dmData;
if (onePortContext == agNULL)
{
DM_DBG1(("dmQueryDiscovery: onePortContext is NULL, wrong!!!\n"));
return DM_RC_FAILURE;
}
/* call tddmQueryDiscoveryCB() */
if (onePortContext->DiscoveryState == DM_DSTATE_COMPLETED)
{
tddmQueryDiscoveryCB(dmRoot, dmPortContext, onePortContext->discoveryOptions, dmDiscCompleted);
}
else if (onePortContext->DiscoveryState == DM_DSTATE_COMPLETED_WITH_FAILURE)
{
tddmQueryDiscoveryCB(dmRoot, dmPortContext, onePortContext->discoveryOptions, dmDiscFailed);
}
else
{
tddmQueryDiscoveryCB(dmRoot, dmPortContext, onePortContext->discoveryOptions, dmDiscInProgress);
}
return DM_RC_SUCCESS;
}
/*
should only for an expander
*/
osGLOBAL bit32
dmRegisterDevice(
dmRoot_t *dmRoot,
dmPortContext_t *dmPortContext,
dmDeviceInfo_t *dmDeviceInfo,
agsaDevHandle_t *agDevHandle
)
{
dmIntPortContext_t *onePortContext = agNULL;
dmExpander_t *oneExpander = agNULL;
bit32 sasAddressHi, sasAddressLo;
dmDeviceData_t *oneDeviceData = agNULL;
dmSASSubID_t dmSASSubID;
DM_DBG3(("dmRegisterDevice: start\n"));
onePortContext = (dmIntPortContext_t *)dmPortContext->dmData;
if (onePortContext == agNULL)
{
DM_DBG1(("dmRegisterDevice: onePortContext is NULL!!!\n"));
return DM_RC_FAILURE;
}
if (onePortContext->valid == agFALSE)
{
DM_DBG1(("dmRegisterDevice: invalid port!!!\n"));
return DM_RC_FAILURE;
}
onePortContext->RegFailed = agFALSE;
/* tdssAddSASToSharedcontext() from ossaHwCB()
osGLOBAL void
tdssAddSASToSharedcontext(
tdsaPortContext_t *tdsaPortContext_Instance,
agsaRoot_t *agRoot,
agsaDevHandle_t *agDevHandle,
tdsaSASSubID_t *agSASSubID,
bit32 registered,
bit8 phyID,
bit32 flag
);
from discovery
osGLOBAL tdsaDeviceData_t *
tdssNewAddSASToSharedcontext(
agsaRoot_t *agRoot,
tdsaPortContext_t *onePortContext,
tdsaSASSubID_t *agSASSubID,
tdsaDeviceData_t *oneExpDeviceData,
bit8 phyID
);
*/
/* start here */
dmSASSubID.sasAddressHi = DM_GET_SAS_ADDRESSHI(dmDeviceInfo->sasAddressHi);
dmSASSubID.sasAddressLo = DM_GET_SAS_ADDRESSHI(dmDeviceInfo->sasAddressLo);
dmSASSubID.initiator_ssp_stp_smp = dmDeviceInfo->initiator_ssp_stp_smp;
dmSASSubID.target_ssp_stp_smp = dmDeviceInfo->target_ssp_stp_smp;
oneDeviceData = dmAddSASToSharedcontext(dmRoot, onePortContext, &dmSASSubID, agNULL, 0xFF);
if (oneDeviceData == agNULL)
{
DM_DBG1(("dmRegisterDevice: oneDeviceData is NULL!!!\n"));
return DM_RC_FAILURE;
}
oneDeviceData->agDeviceInfo.devType_S_Rate = dmDeviceInfo->devType_S_Rate;
dm_memcpy(oneDeviceData->agDeviceInfo.sasAddressHi, dmDeviceInfo->sasAddressHi, 4);
dm_memcpy(oneDeviceData->agDeviceInfo.sasAddressLo, dmDeviceInfo->sasAddressLo, 4);
/* finds the type of expanders */
if (DEVINFO_GET_EXT_SMP(dmDeviceInfo))
{
if (DEVINFO_GET_EXT_EXPANDER_TYPE(dmDeviceInfo) == SAS_EDGE_EXPANDER_DEVICE)
{
oneDeviceData->SASSpecDeviceType = SAS_EDGE_EXPANDER_DEVICE;
}
else if (DEVINFO_GET_EXT_EXPANDER_TYPE(dmDeviceInfo) == SAS_FANOUT_EXPANDER_DEVICE)
{
oneDeviceData->SASSpecDeviceType = SAS_FANOUT_EXPANDER_DEVICE;
}
else
{
/* default */
DM_DBG4(("dmRegisterDevice: no expander type. default to edge expander\n"));
oneDeviceData->SASSpecDeviceType = SAS_EDGE_EXPANDER_DEVICE;
}
}
if (DEVINFO_GET_EXT_MCN(dmDeviceInfo) == 0xF)
{
DM_DBG1(("dmRegisterDevice: directly attached expander\n"));
oneDeviceData->directlyAttached = agTRUE;
oneDeviceData->dmDeviceInfo.ext = (bit16)(oneDeviceData->dmDeviceInfo.ext | (0xF << 11));
}
else
{
DM_DBG1(("dmRegisterDevice: NOT directly attached expander\n"));
oneDeviceData->directlyAttached = agFALSE;
}
if (onePortContext->DiscoveryState == DM_DSTATE_NOT_STARTED)
{
DM_DBG3(("dmRegisterDevice: DM_DSTATE_NOT_STARTED\n"));
/* before the discovery is started */
oneExpander = dmDiscoveringExpanderAlloc(dmRoot, onePortContext, oneDeviceData);
if ( oneExpander != agNULL)
{
oneExpander->agDevHandle = agDevHandle;
/* update SAS address field */
oneExpander->dmDevice->SASAddressID.sasAddressHi = DM_GET_SAS_ADDRESSHI(dmDeviceInfo->sasAddressHi);
oneExpander->dmDevice->SASAddressID.sasAddressLo = DM_GET_SAS_ADDRESSLO(dmDeviceInfo->sasAddressLo);
DM_DBG3(("dmRegisterDevice: AddrHi 0x%08x AddrLo 0x%08x\n", oneExpander->dmDevice->SASAddressID.sasAddressHi, oneExpander->dmDevice->SASAddressID.sasAddressLo));
dmDiscoveringExpanderAdd(dmRoot, onePortContext, oneExpander);
}
else
{
DM_DBG1(("dmRegisterDevice: failed to allocate expander !!!\n"));
/* remember that the registration failed so that a discovery can't be started */
onePortContext->RegFailed = agTRUE;
return DM_RC_FAILURE;
}
}
else
{
/*
the discovery has started. Alloc and add have been done.
find an expander using dmDeviceInfo, and update the expander's agDevHandle
call dmExpFind()
*/
DM_DBG3(("dmRegisterDevice: NOT DM_DSTATE_NOT_STARTED\n"));
sasAddressHi = DM_GET_SAS_ADDRESSHI(dmDeviceInfo->sasAddressHi);
sasAddressLo = DM_GET_SAS_ADDRESSLO(dmDeviceInfo->sasAddressLo);
DM_DBG3(("dmRegisterDevice: AddrHi 0x%08x AddrLo 0x%08x\n", sasAddressHi, sasAddressLo));
oneExpander = dmExpFind(dmRoot, onePortContext, sasAddressHi, sasAddressLo);
if ( oneExpander != agNULL)
{
oneExpander->agDevHandle = agDevHandle;
}
else
{
DM_DBG1(("dmRegisterDevice: not allowed case, wrong !!!\n"));
return DM_RC_FAILURE;
}
}
return DM_RC_SUCCESS;
}
osGLOBAL dmExpander_t *
dmDiscoveringExpanderAlloc(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
dmDeviceData_t *oneDeviceData
)
{
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
dmExpander_t *oneExpander = agNULL;
dmList_t *ExpanderList;
DM_DBG3(("dmDiscoveringExpanderAlloc: start\n"));
DM_DBG3(("dmDiscoveringExpanderAlloc: did %d\n", oneDeviceData->id));
DM_DBG3(("dmDiscoveringExpanderAlloc: sasAddressHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi));
DM_DBG3(("dmDiscoveringExpanderAlloc: sasAddressLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo));
if (onePortContext->valid == agFALSE)
{
DM_DBG1(("dmDiscoveringExpanderAlloc: invalid port!!!\n"));
return agNULL;
}
/* check exitence in dmAllShared->mainExpanderList */
oneExpander = dmExpMainListFind(dmRoot,
onePortContext,
oneDeviceData->SASAddressID.sasAddressHi,
oneDeviceData->SASAddressID.sasAddressLo);
if (oneExpander == agNULL)
{
tddmSingleThreadedEnter(dmRoot, DM_EXPANDER_LOCK);
if (DMLIST_EMPTY(&(dmAllShared->freeExpanderList)))
{
DM_DBG1(("dmDiscoveringExpanderAlloc: no free expanders pid %d!!!\n", onePortContext->id));
tddmSingleThreadedLeave(dmRoot, DM_EXPANDER_LOCK);
return agNULL;
}
else
{
tddmSingleThreadedLeave(dmRoot, DM_EXPANDER_LOCK);
}
tddmSingleThreadedEnter(dmRoot, DM_EXPANDER_LOCK);
DMLIST_DEQUEUE_FROM_HEAD(&ExpanderList, &(dmAllShared->freeExpanderList));
tddmSingleThreadedLeave(dmRoot, DM_EXPANDER_LOCK);
oneExpander = DMLIST_OBJECT_BASE(dmExpander_t, linkNode, ExpanderList);
}
if (oneExpander != agNULL)
{
DM_DBG1(("dmDiscoveringExpanderAlloc: pid %d exp id %d \n", onePortContext->id, oneExpander->id));
tddmSingleThreadedEnter(dmRoot, DM_EXPANDER_LOCK);
DMLIST_DEQUEUE_THIS(&(oneExpander->linkNode));
tddmSingleThreadedLeave(dmRoot, DM_EXPANDER_LOCK);
oneExpander->dmDevice = oneDeviceData;
oneExpander->dmUpStreamExpander = agNULL;
oneExpander->dmCurrentDownStreamExpander = agNULL;
oneExpander->dmReturnginExpander = agNULL;
oneExpander->hasUpStreamDevice = agFALSE;
oneExpander->numOfUpStreamPhys = 0;
oneExpander->currentUpStreamPhyIndex = 0;
oneExpander->discoveringPhyId = 0;
oneExpander->underDiscovering = agFALSE;
dm_memset( &(oneExpander->currentIndex), 0, sizeof(oneExpander->currentIndex));
oneDeviceData->dmExpander = oneExpander;
DM_DBG3(("dmDiscoveringExpanderAlloc: oneDeviceData %p did %d\n", oneDeviceData, oneDeviceData->id));
DM_DBG3(("dmDiscoveringExpanderAlloc: oneExpander %p did %d\n", oneDeviceData->dmExpander, oneDeviceData->dmExpander->id));
}
return oneExpander;
}
osGLOBAL void
dmDiscoveringExpanderAdd(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
dmExpander_t *oneExpander
)
{
DM_DBG3(("dmDiscoveringExpanderAdd: start\n"));
DM_DBG3(("dmDiscoveringExpanderAdd: expander id %d\n", oneExpander->id));
DM_DBG3(("dmDiscoveringExpanderAdd: exp addrHi 0x%08x\n", oneExpander->dmDevice->SASAddressID.sasAddressHi));
DM_DBG3(("dmDiscoveringExpanderAdd: exp addrLo 0x%08x\n", oneExpander->dmDevice->SASAddressID.sasAddressLo));
if (onePortContext->valid == agFALSE)
{
DM_DBG1(("dmDiscoveringExpanderAdd: invalid port!!!\n"));
return;
}
if (onePortContext->discovery.status == DISCOVERY_UP_STREAM)
{
DM_DBG3(("dmDiscoveringExpanderAdd: UPSTREAM\n"));
}
else if (onePortContext->discovery.status == DISCOVERY_DOWN_STREAM)
{
DM_DBG3(("dmDiscoveringExpanderAdd: DOWNSTREAM\n"));
}
else
{
DM_DBG3(("dmDiscoveringExpanderAdd: status %d\n", onePortContext->discovery.status));
}
if ( oneExpander->underDiscovering == agFALSE)
{
DM_DBG3(("dmDiscoveringExpanderAdd: ADDED \n"));
oneExpander->underDiscovering = agTRUE;
tddmSingleThreadedEnter(dmRoot, DM_EXPANDER_LOCK);
DMLIST_ENQUEUE_AT_TAIL(&(oneExpander->linkNode), &(onePortContext->discovery.discoveringExpanderList));
tddmSingleThreadedLeave(dmRoot, DM_EXPANDER_LOCK);
}
return;
}
osGLOBAL dmExpander_t *
dmFindConfigurableExp(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
dmExpander_t *oneExpander
)
{
dmExpander_t *tempExpander;
dmIntPortContext_t *tmpOnePortContext = onePortContext;
dmExpander_t *ret = agNULL;
DM_DBG3(("dmFindConfigurableExp: start\n"));
if (oneExpander == agNULL)
{
DM_DBG3(("dmFindConfigurableExp: NULL expander\n"));
return agNULL;
}
DM_DBG3(("dmFindConfigurableExp: exp addrHi 0x%08x\n", oneExpander->dmDevice->SASAddressID.sasAddressHi));
DM_DBG3(("dmFindConfigurableExp: exp addrLo 0x%08x\n", oneExpander->dmDevice->SASAddressID.sasAddressLo));
tddmSingleThreadedEnter(dmRoot, DM_EXPANDER_LOCK);
if (DMLIST_EMPTY(&(tmpOnePortContext->discovery.discoveringExpanderList)))
{
tddmSingleThreadedLeave(dmRoot, DM_EXPANDER_LOCK);
DM_DBG3(("dmFindConfigurableExp: empty UpdiscoveringExpanderList\n"));
return agNULL;
}
else
{
tddmSingleThreadedLeave(dmRoot, DM_EXPANDER_LOCK);
}
tempExpander = oneExpander->dmUpStreamExpander;
while (tempExpander)
{
DM_DBG3(("dmFindConfigurableExp: loop exp addrHi 0x%08x\n", tempExpander->dmDevice->SASAddressID.sasAddressHi));
DM_DBG3(("dmFindConfigurableExp: loop exp addrLo 0x%08x\n", tempExpander->dmDevice->SASAddressID.sasAddressLo));
if (tempExpander->configRouteTable)
{
DM_DBG3(("dmFindConfigurableExp: found configurable expander\n"));
ret = tempExpander;
break;
}
tempExpander = tempExpander->dmUpStreamExpander;
}
return ret;
}
osGLOBAL bit32
dmDuplicateConfigSASAddr(
dmRoot_t *dmRoot,
dmExpander_t *oneExpander,
bit32 configSASAddressHi,
bit32 configSASAddressLo
)
{
bit32 i;
bit32 ret = agFALSE;
DM_DBG3(("dmDuplicateConfigSASAddr: start\n"));
if (oneExpander == agNULL)
{
DM_DBG3(("dmDuplicateConfigSASAddr: NULL expander\n"));
return agTRUE;
}
if (oneExpander->dmDevice->SASAddressID.sasAddressHi == configSASAddressHi &&
oneExpander->dmDevice->SASAddressID.sasAddressLo == configSASAddressLo
)
{
DM_DBG3(("dmDuplicateConfigSASAddr: unnecessary\n"));
return agTRUE;
}
DM_DBG3(("dmDuplicateConfigSASAddr: exp addrHi 0x%08x\n", oneExpander->dmDevice->SASAddressID.sasAddressHi));
DM_DBG3(("dmDuplicateConfigSASAddr: exp addrLo 0x%08x\n", oneExpander->dmDevice->SASAddressID.sasAddressLo));
DM_DBG3(("dmDuplicateConfigSASAddr: configsasAddressHi 0x%08x\n", configSASAddressHi));
DM_DBG3(("dmDuplicateConfigSASAddr: configsasAddressLo 0x%08x\n", configSASAddressLo));
DM_DBG3(("dmDuplicateConfigSASAddr: configSASAddrTableIndex %d\n", oneExpander->configSASAddrTableIndex));
for(i=0;i<oneExpander->configSASAddrTableIndex;i++)
{
if (oneExpander->configSASAddressHiTable[i] == configSASAddressHi &&
oneExpander->configSASAddressLoTable[i] == configSASAddressLo
)
{
DM_DBG3(("dmDuplicateConfigSASAddr: FOUND\n"));
ret = agTRUE;
break;
}
}
/* new one; let's add it */
if (ret == agFALSE)
{
DM_DBG3(("dmDuplicateConfigSASAddr: adding configSAS Addr\n"));
DM_DBG3(("dmDuplicateConfigSASAddr: configSASAddrTableIndex %d\n", oneExpander->configSASAddrTableIndex));
oneExpander->configSASAddressHiTable[oneExpander->configSASAddrTableIndex] = configSASAddressHi;
oneExpander->configSASAddressLoTable[oneExpander->configSASAddrTableIndex] = configSASAddressLo;
oneExpander->configSASAddrTableIndex++;
}
return ret;
}
osGLOBAL bit16
dmFindCurrentDownStreamPhyIndex(
dmRoot_t *dmRoot,
dmExpander_t *oneExpander
)
{
dmExpander_t *DownStreamExpander;
bit16 index = 0;
bit16 i;
bit8 phyId = 0;
DM_DBG3(("dmFindCurrentDownStreamPhyIndex: start\n"));
if (oneExpander == agNULL)
{
DM_DBG1(("dmFindCurrentDownStreamPhyIndex: wrong, oneExpander is NULL!!!\n"));
return 0;
}
DownStreamExpander = oneExpander->dmCurrentDownStreamExpander;
if (DownStreamExpander == agNULL)
{
DM_DBG1(("dmFindCurrentDownStreamPhyIndex: wrong, DownStreamExpander is NULL!!!\n"));
return 0;
}
DM_DBG3(("dmFindCurrentDownStreamPhyIndex: exp addrHi 0x%08x\n", oneExpander->dmDevice->SASAddressID.sasAddressHi));
DM_DBG3(("dmFindCurrentDownStreamPhyIndex: exp addrLo 0x%08x\n", oneExpander->dmDevice->SASAddressID.sasAddressLo));
DM_DBG3(("dmFindCurrentDownStreamPhyIndex: downstream exp addrHi 0x%08x\n", DownStreamExpander->dmDevice->SASAddressID.sasAddressHi));
DM_DBG3(("dmFindCurrentDownStreamPhyIndex: downstream exp addrLo 0x%08x\n", DownStreamExpander->dmDevice->SASAddressID.sasAddressLo));
DM_DBG3(("dmFindCurrentDownStreamPhyIndex: numOfDownStreamPhys %d\n", oneExpander->numOfDownStreamPhys));
phyId = DownStreamExpander->upStreamPhys[0];
DM_DBG3(("dmFindCurrentDownStreamPhyIndex: phyId %d\n", phyId));
for (i=0; i<oneExpander->numOfDownStreamPhys;i++)
{
if (oneExpander->downStreamPhys[i] == phyId)
{
index = i;
break;
}
}
DM_DBG3(("dmFindCurrentDownStreamPhyIndex: index %d\n", index));
return index;
}
osGLOBAL bit32
dmFindDiscoveringExpander(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
dmExpander_t *oneExpander
)
{
dmList_t *ExpanderList;
dmExpander_t *tempExpander;
dmIntPortContext_t *tmpOnePortContext = onePortContext;
bit32 ret = agFALSE;
DM_DBG3(("dmFindDiscoveringExpander: start\n"));
DM_DBG3(("dmFindDiscoveringExpander: exp addrHi 0x%08x\n", oneExpander->dmDevice->SASAddressID.sasAddressHi));
DM_DBG3(("dmFindDiscoveringExpander: exp addrLo 0x%08x\n", oneExpander->dmDevice->SASAddressID.sasAddressLo));
if (DMLIST_EMPTY(&(tmpOnePortContext->discovery.discoveringExpanderList)))
{
DM_DBG3(("dmFindDiscoveringExpander: empty discoveringExpanderList\n"));
return ret;
}
ExpanderList = tmpOnePortContext->discovery.discoveringExpanderList.flink;
while (ExpanderList != &(tmpOnePortContext->discovery.discoveringExpanderList))
{
tempExpander = DMLIST_OBJECT_BASE(dmExpander_t, linkNode, ExpanderList);
if (tempExpander == oneExpander)
{
if (tempExpander != agNULL)
{
DM_DBG3(("dmFindDiscoveringExpander: match, expander id %d\n", tempExpander->id));
DM_DBG3(("dmFindDiscoveringExpander: exp addrHi 0x%08x\n", tempExpander->dmDevice->SASAddressID.sasAddressHi));
DM_DBG3(("dmFindDiscoveringExpander: exp addrLo 0x%08x\n", tempExpander->dmDevice->SASAddressID.sasAddressLo));
}
ret = agTRUE;
break;
}
ExpanderList = ExpanderList->flink;
}
return ret;
}
osGLOBAL void
dmDiscoveringExpanderRemove(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
dmExpander_t *oneExpander
)
{
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
DM_DBG3(("dmDiscoveringExpanderRemove: start\n"));
DM_DBG3(("dmDiscoveringExpanderRemove: expander id %d\n", oneExpander->id));
DM_DBG3(("dmDiscoveringExpanderRemove: exp addrHi 0x%08x\n", oneExpander->dmDevice->SASAddressID.sasAddressHi));
DM_DBG3(("dmDiscoveringExpanderRemove: exp addrLo 0x%08x\n", oneExpander->dmDevice->SASAddressID.sasAddressLo));
DM_DBG3(("dmDiscoveringExpanderRemove: BEFORE\n"));
dmDumpAllExp(dmRoot, onePortContext, oneExpander);
dmDumpAllUpExp(dmRoot, onePortContext, oneExpander);
dmDumpAllFreeExp(dmRoot);
// if is temporary till smp problem is fixed
if (dmFindDiscoveringExpander(dmRoot, onePortContext, oneExpander) == agTRUE)
{
DM_DBG3(("dmDiscoveringExpanderRemove: oneDeviceData %p did %d\n", oneExpander->dmDevice, oneExpander->dmDevice->id));
DM_DBG3(("dmDiscoveringExpanderRemove: oneExpander %p did %d\n", oneExpander, oneExpander->id));
if (oneExpander != oneExpander->dmDevice->dmExpander)
{
DM_DBG3(("dmDiscoveringExpanderRemove: before !!! wrong !!!\n"));
}
oneExpander->underDiscovering = agFALSE;
oneExpander->discoveringPhyId = 0;
tddmSingleThreadedEnter(dmRoot, DM_EXPANDER_LOCK);
DMLIST_DEQUEUE_THIS(&(oneExpander->linkNode));
tddmSingleThreadedLeave(dmRoot, DM_EXPANDER_LOCK);
if (onePortContext->discovery.status == DISCOVERY_UP_STREAM)
{
DM_DBG3(("dmDiscoveringExpanderRemove: DISCOVERY_UP_STREAM\n"));
tddmSingleThreadedEnter(dmRoot, DM_EXPANDER_LOCK);
DMLIST_ENQUEUE_AT_TAIL(&(oneExpander->upNode), &(onePortContext->discovery.UpdiscoveringExpanderList));
tddmSingleThreadedLeave(dmRoot, DM_EXPANDER_LOCK);
onePortContext->discovery.NumOfUpExp++;
}
else
{
DM_DBG3(("dmDiscoveringExpanderRemove: Status %d\n", onePortContext->discovery.status));
tddmSingleThreadedEnter(dmRoot, DM_EXPANDER_LOCK);
DMLIST_ENQUEUE_AT_TAIL(&(oneExpander->linkNode), &(dmAllShared->mainExpanderList));
// DMLIST_ENQUEUE_AT_TAIL(&(oneExpander->linkNode), &(dmAllShared->freeExpanderList));
tddmSingleThreadedLeave(dmRoot, DM_EXPANDER_LOCK);
}
// error checking
if (oneExpander != oneExpander->dmDevice->dmExpander)
{
DM_DBG3(("dmDiscoveringExpanderRemove: after !!! wrong !!!\n"));
}
} //end temp if
else
{
DM_DBG1(("dmDiscoveringExpanderRemove: !!! problem !!!\n"));
}
DM_DBG3(("dmDiscoveringExpanderRemove: AFTER\n"));
dmDumpAllExp(dmRoot, onePortContext, oneExpander);
dmDumpAllUpExp(dmRoot, onePortContext, oneExpander);
dmDumpAllFreeExp(dmRoot);
return;
}
/*
returns an expander with sasAddrLo, sasAddrHi from dmAllShared->mainExpanderList
*/
osGLOBAL dmExpander_t *
dmExpMainListFind(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
bit32 sasAddrHi,
bit32 sasAddrLo
)
{
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
dmList_t *ExpanderList;
dmExpander_t *tempExpander;
DM_DBG3(("dmExpMainListFind: start\n"));
tddmSingleThreadedEnter(dmRoot, DM_EXPANDER_LOCK);
if (DMLIST_EMPTY(&(dmAllShared->mainExpanderList)))
{
DM_DBG1(("dmExpMainListFind: empty mainExpanderList\n"));
tddmSingleThreadedLeave(dmRoot, DM_EXPANDER_LOCK);
return agNULL;
}
else
{
tddmSingleThreadedLeave(dmRoot, DM_EXPANDER_LOCK);
}
ExpanderList = dmAllShared->mainExpanderList.flink;
while (ExpanderList != &(dmAllShared->mainExpanderList))
{
tempExpander = DMLIST_OBJECT_BASE(dmExpander_t, linkNode, ExpanderList);
if (tempExpander == agNULL)
{
DM_DBG1(("dmExpMainListFind: tempExpander is NULL!!!\n"));
return agNULL;
}
DM_DBG3(("dmExpMainListFind: expander id %d\n", tempExpander->id));
DM_DBG3(("dmExpMainListFind: exp addrHi 0x%08x\n", tempExpander->dmDevice->SASAddressID.sasAddressHi));
DM_DBG3(("dmExpMainListFind: exp addrLo 0x%08x\n", tempExpander->dmDevice->SASAddressID.sasAddressLo));
if ((tempExpander->dmDevice->SASAddressID.sasAddressHi == sasAddrHi) &&
(tempExpander->dmDevice->SASAddressID.sasAddressLo == sasAddrLo) &&
(tempExpander->dmDevice->dmPortContext == onePortContext)
)
{
DM_DBG3(("dmExpMainListFind: found expander id %d\n", tempExpander->id));
DM_DBG3(("dmExpMainListFind: found exp addrHi 0x%08x\n", tempExpander->dmDevice->SASAddressID.sasAddressHi));
DM_DBG3(("dmExpMainListFind: found exp addrLo 0x%08x\n", tempExpander->dmDevice->SASAddressID.sasAddressLo));
return tempExpander;
}
ExpanderList = ExpanderList->flink;
}
return agNULL;
}
/*
returns an expander with sasAddrLo, sasAddrHi from discoveringExpanderList
*/
osGLOBAL dmExpander_t *
dmExpFind(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
bit32 sasAddrHi,
bit32 sasAddrLo
)
{
dmList_t *ExpanderList;
dmExpander_t *tempExpander;
dmIntPortContext_t *tmpOnePortContext = onePortContext;
DM_DBG3(("dmExpFind: start\n"));
tddmSingleThreadedEnter(dmRoot, DM_EXPANDER_LOCK);
if (DMLIST_EMPTY(&(tmpOnePortContext->discovery.discoveringExpanderList)))
{
DM_DBG3(("dmExpFind tdsaDumpAllExp: empty discoveringExpanderList\n"));
tddmSingleThreadedLeave(dmRoot, DM_EXPANDER_LOCK);
return agNULL;
}
else
{
tddmSingleThreadedLeave(dmRoot, DM_EXPANDER_LOCK);
}
ExpanderList = tmpOnePortContext->discovery.discoveringExpanderList.flink;
while (ExpanderList != &(tmpOnePortContext->discovery.discoveringExpanderList))
{
tempExpander = DMLIST_OBJECT_BASE(dmExpander_t, linkNode, ExpanderList);
if (tempExpander == agNULL)
{
DM_DBG1(("dmExpFind: tempExpander is NULL!!!\n"));
return agNULL;
}
DM_DBG3(("dmExpFind: expander id %d\n", tempExpander->id));
DM_DBG3(("dmExpFind: exp addrHi 0x%08x\n", tempExpander->dmDevice->SASAddressID.sasAddressHi));
DM_DBG3(("dmExpFind: exp addrLo 0x%08x\n", tempExpander->dmDevice->SASAddressID.sasAddressLo));
if ((tempExpander->dmDevice->SASAddressID.sasAddressHi == sasAddrHi) &&
(tempExpander->dmDevice->SASAddressID.sasAddressLo == sasAddrLo) &&
(tempExpander->dmDevice->dmPortContext == onePortContext)
)
{
DM_DBG3(("dmExpFind: found\n"));
return tempExpander;
}
ExpanderList = ExpanderList->flink;
}
return agNULL;
}
osGLOBAL bit32
dmDiscoverCheck(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext
)
{
DM_DBG3(("dmDiscoverCheck: start\n"));
if (onePortContext == agNULL)
{
DM_DBG1(("dmDiscoverCheck: onePortContext is NULL!!!\n"));
return agTRUE;
}
if (onePortContext->valid == agFALSE)
{
DM_DBG1(("dmDiscoverCheck: invalid port!!!\n"));
return agTRUE;
}
if (onePortContext->DiscoveryState == DM_DSTATE_COMPLETED ||
onePortContext->discovery.status == DISCOVERY_SAS_DONE
)
{
DM_DBG1(("dmDiscoverCheck: aborted discovery!!!\n"));
tddmDiscoverCB(
dmRoot,
onePortContext->dmPortContext,
dmDiscAborted
);
return agTRUE;
}
return agFALSE;
}
/* ??? needs to handle pending SMPs
move from dmAllShared->discoveringExpanderList to dmAllShared->mainExpanderList
*/
osGLOBAL void
dmDiscoverAbort(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext
)
{
DM_DBG1(("dmDiscoverAbort: start\n"));
if (onePortContext->DiscoveryState == DM_DSTATE_COMPLETED ||
onePortContext->discovery.status == DISCOVERY_SAS_DONE)
{
DM_DBG1(("dmDiscoverAbort: not allowed case!!! onePortContext->DiscoveryState 0x%x onePortContext->discovery.status 0x%x\n",
onePortContext->DiscoveryState, onePortContext->discovery.status));
return;
}
onePortContext->DiscoveryState = DM_DSTATE_COMPLETED;
onePortContext->discovery.status = DISCOVERY_SAS_DONE;
/* move from dmAllShared->discoveringExpanderList to dmAllShared->mainExpanderList */
dmCleanAllExp(dmRoot, onePortContext);
return;
}
/* move from dmAllShared->discoveringExpanderList to dmAllShared->mainExpanderList */
osGLOBAL void
dmCleanAllExp(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext
)
{
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
dmList_t *ExpanderList;
dmExpander_t *tempExpander;
dmExpander_t *oneExpander = agNULL;
dmIntPortContext_t *tmpOnePortContext = onePortContext;
DM_DBG3(("dmCleanAllExp: start\n"));
DM_DBG3(("dmCleanAllExp: pid %d\n", onePortContext->id));
DM_DBG3(("dmCleanAllExp: before all clean up\n"));
dmDumpAllFreeExp(dmRoot);
/* clean up UpdiscoveringExpanderList*/
DM_DBG3(("dmCleanAllExp: clean discoveringExpanderList\n"));
if (!DMLIST_EMPTY(&(tmpOnePortContext->discovery.discoveringExpanderList)))
{
ExpanderList = tmpOnePortContext->discovery.discoveringExpanderList.flink;
while (ExpanderList != &(tmpOnePortContext->discovery.discoveringExpanderList))
{
tempExpander = DMLIST_OBJECT_BASE(dmExpander_t, linkNode, ExpanderList);
if (tempExpander == agNULL)
{
DM_DBG1(("dmCleanAllExp: tempExpander is NULL!!!\n"));
return;
}
DM_DBG3(("dmCleanAllExp: exp addrHi 0x%08x\n", tempExpander->dmDevice->SASAddressID.sasAddressHi));
DM_DBG3(("dmCleanAllExp: exp addrLo 0x%08x\n", tempExpander->dmDevice->SASAddressID.sasAddressLo));
DM_DBG3(("dmCleanAllExp: exp id %d\n", tempExpander->id));
oneExpander = dmExpMainListFind(dmRoot,
tmpOnePortContext,
tempExpander->dmDevice->SASAddressID.sasAddressHi,
tempExpander->dmDevice->SASAddressID.sasAddressLo);
if (oneExpander == agNULL)
{
DM_DBG3(("dmCleanAllExp: moving\n"));
DM_DBG3(("dmCleanAllExp: moving, exp id %d\n", tempExpander->id));
/* putting back to the free pool */
tddmSingleThreadedEnter(dmRoot, DM_EXPANDER_LOCK);
DMLIST_DEQUEUE_THIS(&(tempExpander->linkNode));
// DMLIST_ENQUEUE_AT_TAIL(&(tempExpander->linkNode), &(dmAllShared->freeExpanderList));
DMLIST_ENQUEUE_AT_TAIL(&(tempExpander->linkNode), &(dmAllShared->mainExpanderList));
if (DMLIST_EMPTY(&(tmpOnePortContext->discovery.discoveringExpanderList)))
{
tddmSingleThreadedLeave(dmRoot, DM_EXPANDER_LOCK);
break;
}
else
{
tddmSingleThreadedLeave(dmRoot, DM_EXPANDER_LOCK);
}
ExpanderList = tmpOnePortContext->discovery.discoveringExpanderList.flink;
}
else
{
DM_DBG3(("dmCleanAllExp: in mainExpanderList; skippig\n"));
ExpanderList = ExpanderList->flink;
}
}
}
else
{
DM_DBG3(("dmCleanAllExp: empty discoveringExpanderList\n"));
}
/* reset discoveringExpanderList */
DMLIST_INIT_HDR(&(tmpOnePortContext->discovery.discoveringExpanderList));
/* clean up UpdiscoveringExpanderList*/
DM_DBG3(("dmCleanAllExp: clean UpdiscoveringExpanderList\n"));
if (DMLIST_EMPTY(&(tmpOnePortContext->discovery.UpdiscoveringExpanderList)))
{
DM_DBG3(("dmCleanAllExp: empty UpdiscoveringExpanderList\n"));
return;
}
ExpanderList = tmpOnePortContext->discovery.UpdiscoveringExpanderList.flink;
while (ExpanderList != &(tmpOnePortContext->discovery.UpdiscoveringExpanderList))
{
tempExpander = DMLIST_OBJECT_BASE(dmExpander_t, upNode, ExpanderList);
if (tempExpander == agNULL)
{
DM_DBG1(("dmCleanAllExp: tempExpander is NULL!!!\n"));
return;
}
DM_DBG3(("dmCleanAllExp: exp addrHi 0x%08x\n", tempExpander->dmDevice->SASAddressID.sasAddressHi));
DM_DBG3(("dmCleanAllExp: exp addrLo 0x%08x\n", tempExpander->dmDevice->SASAddressID.sasAddressLo));
DM_DBG3(("dmCleanAllExp: exp id %d\n", tempExpander->id));
oneExpander = dmExpMainListFind(dmRoot,
tmpOnePortContext,
tempExpander->dmDevice->SASAddressID.sasAddressHi,
tempExpander->dmDevice->SASAddressID.sasAddressLo);
if (oneExpander == agNULL)
{
DM_DBG3(("dmCleanAllExp: moving\n"));
DM_DBG3(("dmCleanAllExp: moving exp id %d\n", tempExpander->id));
tddmSingleThreadedEnter(dmRoot, DM_EXPANDER_LOCK);
DMLIST_DEQUEUE_THIS(&(tempExpander->upNode));
DMLIST_ENQUEUE_AT_TAIL(&(tempExpander->linkNode), &(dmAllShared->mainExpanderList));
if (DMLIST_EMPTY(&(tmpOnePortContext->discovery.UpdiscoveringExpanderList)))
{
tddmSingleThreadedLeave(dmRoot, DM_EXPANDER_LOCK);
break;
}
else
{
tddmSingleThreadedLeave(dmRoot, DM_EXPANDER_LOCK);
}
ExpanderList = tmpOnePortContext->discovery.UpdiscoveringExpanderList.flink;
}
else
{
DM_DBG3(("dmCleanAllExp: in mainExpanderList; skippig\n"));
ExpanderList = ExpanderList->flink;
}
}
/* reset UpdiscoveringExpanderList */
DMLIST_INIT_HDR(&(tmpOnePortContext->discovery.UpdiscoveringExpanderList));
DM_DBG3(("dmCleanAllExp: after all clean up\n"));
dmDumpAllFreeExp(dmRoot);
return;
}
osGLOBAL void
dmInternalRemovals(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext
)
{
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
dmDeviceData_t *oneDeviceData = agNULL;
dmList_t *DeviceListList;
DM_DBG3(("dmInternalRemovals: start\n"));
tddmSingleThreadedEnter(dmRoot, DM_DEVICE_LOCK);
if (DMLIST_EMPTY(&(dmAllShared->MainDeviceList)))
{
tddmSingleThreadedLeave(dmRoot, DM_DEVICE_LOCK);
DM_DBG3(("dmInternalRemovals: empty device list\n"));
return;
}
else
{
tddmSingleThreadedLeave(dmRoot, DM_DEVICE_LOCK);
}
DeviceListList = dmAllShared->MainDeviceList.flink;
while (DeviceListList != &(dmAllShared->MainDeviceList))
{
oneDeviceData = DMLIST_OBJECT_BASE(dmDeviceData_t, MainLink, DeviceListList);
if (oneDeviceData == agNULL)
{
DM_DBG1(("dmInternalRemovals: oneDeviceData is NULL!!!\n"));
return;
}
DM_DBG3(("dmInternalRemovals: loop did %d\n", oneDeviceData->id));
DM_DBG3(("dmInternalRemovals: sasAddrHi 0x%08x \n", oneDeviceData->SASAddressID.sasAddressHi));
DM_DBG3(("dmInternalRemovals: sasAddrLo 0x%08x \n", oneDeviceData->SASAddressID.sasAddressLo));
DM_DBG3(("dmInternalRemovals: valid %d\n", oneDeviceData->valid));
DM_DBG3(("dmInternalRemovals: valid2 %d\n", oneDeviceData->valid2));
DM_DBG3(("dmInternalRemovals: directlyAttached %d\n", oneDeviceData->directlyAttached));
if ( oneDeviceData->dmPortContext == onePortContext)
{
DM_DBG3(("dmInternalRemovals: right portcontext pid %d\n", onePortContext->id));
if (onePortContext->discovery.type == DM_DISCOVERY_OPTION_INCREMENTAL_START)
{
DM_DBG3(("dmInternalRemovals: incremental discovery\n"));
oneDeviceData->valid2 = agFALSE;
}
else
{
DM_DBG3(("dmInternalRemovals: full discovery\n"));
oneDeviceData->valid = agFALSE;
}
DeviceListList = DeviceListList->flink;
}
else
{
if (oneDeviceData->dmPortContext != agNULL)
{
DM_DBG3(("dmInternalRemovals: different portcontext; oneDeviceData->dmPortContext pid %d oneportcontext pid %d\n", oneDeviceData->dmPortContext->id, onePortContext->id));
}
else
{
DM_DBG3(("dmInternalRemovals: different portcontext; oneDeviceData->dmPortContext pid NULL oneportcontext pid %d\n", onePortContext->id));
}
DeviceListList = DeviceListList->flink;
}
}
return;
}
osGLOBAL void
dmDiscoveryResetProcessed(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext
)
{
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
dmDeviceData_t *oneDeviceData = agNULL;
dmList_t *DeviceListList;
DM_DBG3(("dmDiscoveryResetProcessed: start\n"));
/* reinitialize the device data belonging to this portcontext */
DeviceListList = dmAllShared->MainDeviceList.flink;
while (DeviceListList != &(dmAllShared->MainDeviceList))
{
oneDeviceData = DMLIST_OBJECT_BASE(dmDeviceData_t, MainLink, DeviceListList);
if (oneDeviceData == agNULL)
{
DM_DBG1(("dmDiscoveryResetProcessed: oneDeviceData is NULL!!!\n"));
return;
}
DM_DBG3(("dmDiscoveryResetProcessed: loop did %d\n", oneDeviceData->id));
if (oneDeviceData->dmPortContext == onePortContext)
{
DM_DBG3(("dmDiscoveryResetProcessed: resetting procssed flag\n"));
oneDeviceData->processed = agFALSE;
}
DeviceListList = DeviceListList->flink;
}
return;
}
/*
calls
osGLOBAL void
tddmDiscoverCB(
dmRoot_t *dmRoot,
dmPortContext_t *dmPortContext,
bit32 eventStatus
)
*/
osGLOBAL void
dmDiscoverDone(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
bit32 flag
)
{
DM_DBG3(("dmDiscoverDone: start\n"));
DM_DBG3(("dmDiscoverDone: pid %d\n", onePortContext->id));
/* Set discovery status */
onePortContext->discovery.status = DISCOVERY_SAS_DONE;
/* clean up expanders data strucures; move to free exp when device is cleaned */
dmCleanAllExp(dmRoot, onePortContext);
dmDumpAllMainExp(dmRoot, onePortContext);
dmDiscoveryResetProcessed(dmRoot, onePortContext);
dmDiscoveryDumpMCN(dmRoot, onePortContext);
if (onePortContext->discovery.SeenBC == agTRUE)
{
DM_DBG3(("dmDiscoverDone: broadcast change; discover again\n"));
dmDiscoveryResetMCN(dmRoot, onePortContext);
dmInternalRemovals(dmRoot, onePortContext);
/* processed broadcast change */
onePortContext->discovery.SeenBC = agFALSE;
if (onePortContext->discovery.ResetTriggerred == agTRUE)
{
DM_DBG3(("dmDiscoverDone: dmBCTimer\n"));
dmBCTimer(dmRoot, onePortContext);
}
else
{
dmIncrementalDiscover(dmRoot, onePortContext, agTRUE);
}
}
else
{
onePortContext->DiscoveryState = DM_DSTATE_COMPLETED;
if (onePortContext->discovery.type == DM_DISCOVERY_OPTION_FULL_START)
{
if (flag == DM_RC_SUCCESS)
{
dmResetReported(dmRoot,
onePortContext
);
dmDiscoveryReportMCN(dmRoot,
onePortContext
);
/* call tddmDiscoverCB() */
tddmDiscoverCB(
dmRoot,
onePortContext->dmPortContext,
dmDiscCompleted
);
}
else if (flag != DM_RC_SUCCESS || onePortContext->discovery.DeferredError == agTRUE)
{
onePortContext->DiscoveryState = DM_DSTATE_COMPLETED_WITH_FAILURE;
DM_DBG1(("dmDiscoverDone: Error; clean up!!!\n"));
dmDiscoveryInvalidateDevices(dmRoot,
onePortContext
);
tddmDiscoverCB(
dmRoot,
onePortContext->dmPortContext,
dmDiscFailed
);
}
}
else
{
if (flag == DM_RC_SUCCESS)
{
dmReportChanges(dmRoot,
onePortContext
);
dmDiscoveryReportMCN(dmRoot,
onePortContext
);
tddmDiscoverCB(
dmRoot,
onePortContext->dmPortContext,
dmDiscCompleted
);
}
else if (flag != DM_RC_SUCCESS || onePortContext->discovery.DeferredError == agTRUE)
{
onePortContext->DiscoveryState = DM_DSTATE_COMPLETED_WITH_FAILURE;
dmDiscoveryInvalidateDevices(dmRoot,
onePortContext
);
tddmDiscoverCB(
dmRoot,
onePortContext->dmPortContext,
dmDiscFailed
);
}
}
}
return;
}
/* called by dmDiscoveryErrorRemovals() or dmReportRemovals() on discovery failure */
osGLOBAL void
dmSubReportRemovals(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
dmDeviceData_t *oneDeviceData,
bit32 flag
)
{
dmDeviceData_t *oneAttachedExpDeviceData = agNULL;
DM_DBG3(("dmSubReportRemovals: start\n"));
DM_DBG3(("dmSubReportRemovals: flag 0x%x\n", flag));
if (flag == dmDeviceRemoval)
{
oneDeviceData->registered = agFALSE;
}
if (oneDeviceData->ExpDevice != agNULL)
{
DM_DBG3(("dmSubReportRemovals: attached expander case\n"));
oneAttachedExpDeviceData = oneDeviceData->ExpDevice;
tddmReportDevice(dmRoot, onePortContext->dmPortContext, &oneDeviceData->dmDeviceInfo, &oneAttachedExpDeviceData->dmDeviceInfo, flag);
}
else
{
DM_DBG3(("dmSubReportRemovals: NO attached expander case\n"));
tddmReportDevice(dmRoot, onePortContext->dmPortContext, &oneDeviceData->dmDeviceInfo, agNULL, flag);
}
/* this function is called at the end of discovery; reinitializes oneDeviceData->reported */
oneDeviceData->reported = agFALSE;
return;
}
/* called by dmReportChanges() on discovery success */
osGLOBAL void
dmSubReportChanges(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
dmDeviceData_t *oneDeviceData,
bit32 flag
)
{
dmDeviceData_t *oneAttachedExpDeviceData = agNULL;
DM_DBG3(("dmSubReportChanges: start\n"));
DM_DBG3(("dmSubReportChanges: flag 0x%x\n", flag));
if (flag == dmDeviceRemoval)
{
oneDeviceData->registered = agFALSE;
}
if (oneDeviceData->reported == agFALSE)
{
if (oneDeviceData->ExpDevice != agNULL)
{
DM_DBG3(("dmSubReportChanges: attached expander case\n"));
oneAttachedExpDeviceData = oneDeviceData->ExpDevice;
tddmReportDevice(dmRoot, onePortContext->dmPortContext, &oneDeviceData->dmDeviceInfo, &oneAttachedExpDeviceData->dmDeviceInfo, flag);
}
else
{
DM_DBG3(("dmSubReportChanges: NO attached expander case\n"));
tddmReportDevice(dmRoot, onePortContext->dmPortContext, &oneDeviceData->dmDeviceInfo, agNULL, flag);
}
}
else
{
DM_DBG3(("dmSubReportChanges: skip; been reported\n"));
}
/* this function is called at the end of discovery; reinitializes oneDeviceData->reported */
oneDeviceData->reported = agFALSE;
return;
}
/*
should add or remove be reported per device???
*/
osGLOBAL void
dmReportChanges(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext
)
{
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
dmDeviceData_t *oneDeviceData = agNULL;
dmList_t *DeviceListList;
bit32 added = agFALSE, removed = agFALSE;
// dmDeviceData_t *oneAttachedExpDeviceData = agNULL;
DM_DBG3(("dmReportChanges: start\n"));
tddmSingleThreadedEnter(dmRoot, DM_DEVICE_LOCK);
if (DMLIST_EMPTY(&(dmAllShared->MainDeviceList)))
{
tddmSingleThreadedLeave(dmRoot, DM_DEVICE_LOCK);
DM_DBG3(("dmReportChanges: empty device list\n"));
return;
}
else
{
tddmSingleThreadedLeave(dmRoot, DM_DEVICE_LOCK);
}
DeviceListList = dmAllShared->MainDeviceList.flink;
while (DeviceListList != &(dmAllShared->MainDeviceList))
{
oneDeviceData = DMLIST_OBJECT_BASE(dmDeviceData_t, MainLink, DeviceListList);
if (oneDeviceData == agNULL)
{
DM_DBG1(("dmReportChanges: oneDeviceData is NULL!!!\n"));
return;
}
DM_DBG3(("dmReportChanges: sasAddrHi 0x%08x \n", oneDeviceData->SASAddressID.sasAddressHi));
DM_DBG3(("dmReportChanges: sasAddrLo 0x%08x \n", oneDeviceData->SASAddressID.sasAddressLo));
if ( oneDeviceData->dmPortContext == onePortContext)
{
DM_DBG3(("dmReportChanges: right portcontext\n"));
if (oneDeviceData->SASAddressID.sasAddressHi == onePortContext->sasRemoteAddressHi &&
oneDeviceData->SASAddressID.sasAddressLo == onePortContext->sasRemoteAddressLo
)
{
DM_DBG1(("dmReportChanges: keep, not reporting did 0x%x\n", oneDeviceData->id));
oneDeviceData->valid = agTRUE;
oneDeviceData->valid2 = agFALSE;
}
else if ( (oneDeviceData->valid == agTRUE) && (oneDeviceData->valid2 == agTRUE) )
{
DM_DBG3(("dmReportChanges: same\n"));
/* reset valid bit */
oneDeviceData->valid = oneDeviceData->valid2;
oneDeviceData->valid2 = agFALSE;
dmSubReportChanges(dmRoot, onePortContext, oneDeviceData, dmDeviceNoChange);
}
else if ( (oneDeviceData->valid == agTRUE) && (oneDeviceData->valid2 == agFALSE) )
{
DM_DBG3(("dmReportChanges: removed\n"));
removed = agTRUE;
/* reset valid bit */
oneDeviceData->valid = oneDeviceData->valid2;
oneDeviceData->valid2 = agFALSE;
onePortContext->RegisteredDevNums--;
dmSubReportChanges(dmRoot, onePortContext, oneDeviceData, dmDeviceRemoval);
}
else if ( (oneDeviceData->valid == agFALSE) && (oneDeviceData->valid2 == agTRUE) )
{
DM_DBG3(("dmReportChanges: added\n"));
added = agTRUE;
/* reset valid bit */
oneDeviceData->valid = oneDeviceData->valid2;
oneDeviceData->valid2 = agFALSE;
dmSubReportChanges(dmRoot, onePortContext, oneDeviceData, dmDeviceArrival);
}
else
{
DM_DBG3(("dmReportChanges: else\n"));
}
}
else
{
DM_DBG3(("dmReportChanges: different portcontext\n"));
}
DeviceListList = DeviceListList->flink;
}
/*
osGLOBAL void
tddmReportDevice(
dmRoot_t *dmRoot,
dmPortContext_t *dmPortContext,
dmDeviceInfo_t *dmDeviceInfo,
dmDeviceInfo_t *dmExpDeviceInfo,
bit32 flag
)
*/
/* arrival or removal at once */
if (added == agTRUE)
{
DM_DBG3(("dmReportChanges: added at the end\n"));
#if 0 /* TBD */
ostiInitiatorEvent(
tiRoot,
onePortContext->tiPortalContext,
agNULL,
tiIntrEventTypeDeviceChange,
tiDeviceArrival,
agNULL
);
#endif
}
if (removed == agTRUE)
{
DM_DBG3(("dmReportChanges: removed at the end\n"));
#if 0 /* TBD */
ostiInitiatorEvent(
tiRoot,
onePortContext->tiPortalContext,
agNULL,
tiIntrEventTypeDeviceChange,
tiDeviceRemoval,
agNULL
);
#endif
}
if (onePortContext->discovery.forcedOK == agTRUE && added == agFALSE && removed == agFALSE)
{
DM_DBG3(("dmReportChanges: missed chance to report. forced to report OK\n"));
onePortContext->discovery.forcedOK = agFALSE;
#if 0 /* TBD */
ostiInitiatorEvent(
tiRoot,
onePortContext->tiPortalContext,
agNULL,
tiIntrEventTypeDiscovery,
tiDiscOK,
agNULL
);
#endif
}
if (added == agFALSE && removed == agFALSE)
{
DM_DBG3(("dmReportChanges: the same\n"));
}
return;
}
osGLOBAL void
dmReportRemovals(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
bit32 flag
)
{
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
dmDeviceData_t *oneDeviceData = agNULL;
dmList_t *DeviceListList;
bit32 removed = agFALSE;
DM_DBG1(("dmReportRemovals: start\n"));
tddmSingleThreadedEnter(dmRoot, DM_DEVICE_LOCK);
if (DMLIST_EMPTY(&(dmAllShared->MainDeviceList)))
{
tddmSingleThreadedLeave(dmRoot, DM_DEVICE_LOCK);
DM_DBG3(("dmReportRemovals: empty device list\n"));
return;
}
else
{
tddmSingleThreadedLeave(dmRoot, DM_DEVICE_LOCK);
}
DeviceListList = dmAllShared->MainDeviceList.flink;
while (DeviceListList != &(dmAllShared->MainDeviceList))
{
oneDeviceData = DMLIST_OBJECT_BASE(dmDeviceData_t, MainLink, DeviceListList);
if (oneDeviceData == agNULL)
{
DM_DBG1(("dmReportRemovals: oneDeviceData is NULL!!!\n"));
return;
}
DM_DBG3(("dmReportRemovals: loop did %d\n", oneDeviceData->id));
DM_DBG3(("dmReportRemovals: sasAddrHi 0x%08x \n", oneDeviceData->SASAddressID.sasAddressHi));
DM_DBG3(("dmReportRemovals: sasAddrLo 0x%08x \n", oneDeviceData->SASAddressID.sasAddressLo));
DM_DBG3(("dmReportRemovals: valid %d\n", oneDeviceData->valid));
DM_DBG3(("dmReportRemovals: valid2 %d\n", oneDeviceData->valid2));
DM_DBG3(("dmReportRemovals: directlyAttached %d\n", oneDeviceData->directlyAttached));
if ( oneDeviceData->dmPortContext == onePortContext)
{
DM_DBG3(("dmReportRemovals: right portcontext pid %d\n", onePortContext->id));
if (oneDeviceData->SASAddressID.sasAddressHi == onePortContext->sasRemoteAddressHi &&
oneDeviceData->SASAddressID.sasAddressLo == onePortContext->sasRemoteAddressLo
)
{
DM_DBG1(("dmReportRemovals: keeping\n"));
oneDeviceData->valid = agTRUE;
oneDeviceData->valid2 = agFALSE;
}
else if (oneDeviceData->valid == agTRUE)
{
DM_DBG3(("dmReportRemovals: removing\n"));
/* notify only reported devices to OS layer*/
if ( DEVICE_IS_SSP_TARGET(oneDeviceData) ||
DEVICE_IS_STP_TARGET(oneDeviceData) ||
DEVICE_IS_SATA_DEVICE(oneDeviceData)
)
{
removed = agTRUE;
}
/* all targets except expanders */
DM_DBG3(("dmReportRemovals: did %d\n", oneDeviceData->id));
DM_DBG3(("dmReportRemovals: sasAddrHi 0x%08x \n", oneDeviceData->SASAddressID.sasAddressHi));
DM_DBG3(("dmReportRemovals: sasAddrLo 0x%08x \n", oneDeviceData->SASAddressID.sasAddressLo));
onePortContext->RegisteredDevNums--;
dmSubReportRemovals(dmRoot, onePortContext, oneDeviceData, dmDeviceRemoval);
/* reset valid bit */
oneDeviceData->valid = agFALSE;
oneDeviceData->valid2 = agFALSE;
}
/* called by port invalid case */
if (flag == agTRUE)
{
oneDeviceData->dmPortContext = agNULL;
}
DeviceListList = DeviceListList->flink;
}
else
{
if (oneDeviceData->dmPortContext != agNULL)
{
DM_DBG3(("dmReportRemovals: different portcontext; oneDeviceData->dmPortContext pid %d oneportcontext pid %d\n", oneDeviceData->dmPortContext->id, onePortContext->id));
}
else
{
DM_DBG3(("dmReportRemovals: different portcontext; oneDeviceData->dmPortContext pid NULL oneportcontext pid %d\n", onePortContext->id));
}
DeviceListList = DeviceListList->flink;
}
}
if (removed == agTRUE)
{
DM_DBG3(("dmReportRemovals: removed at the end\n"));
#if 0 /* TBD */
ostiInitiatorEvent(
tiRoot,
onePortContext->tiPortalContext,
agNULL,
tiIntrEventTypeDeviceChange,
tiDeviceRemoval,
agNULL
);
#endif
}
return;
}
osGLOBAL void
dmResetReported(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext
)
{
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
dmDeviceData_t *oneDeviceData = agNULL;
dmList_t *DeviceListList;
DM_DBG3(("dmResetReported: start\n"));
tddmSingleThreadedEnter(dmRoot, DM_DEVICE_LOCK);
if (DMLIST_EMPTY(&(dmAllShared->MainDeviceList)))
{
tddmSingleThreadedLeave(dmRoot, DM_DEVICE_LOCK);
DM_DBG3(("dmResetReported: empty device list\n"));
return;
}
else
{
tddmSingleThreadedLeave(dmRoot, DM_DEVICE_LOCK);
}
DeviceListList = dmAllShared->MainDeviceList.flink;
while (DeviceListList != &(dmAllShared->MainDeviceList))
{
oneDeviceData = DMLIST_OBJECT_BASE(dmDeviceData_t, MainLink, DeviceListList);
if (oneDeviceData == agNULL)
{
DM_DBG1(("dmResetReported: oneDeviceData is NULL!!!\n"));
return;
}
DM_DBG3(("dmResetReported: loop did %d\n", oneDeviceData->id));
DM_DBG3(("dmResetReported: sasAddrHi 0x%08x \n", oneDeviceData->SASAddressID.sasAddressHi));
DM_DBG3(("dmResetReported: sasAddrLo 0x%08x \n", oneDeviceData->SASAddressID.sasAddressLo));
DM_DBG3(("dmResetReported: valid %d\n", oneDeviceData->valid));
DM_DBG3(("dmResetReported: valid2 %d\n", oneDeviceData->valid2));
DM_DBG3(("dmResetReported: directlyAttached %d\n", oneDeviceData->directlyAttached));
if ( oneDeviceData->dmPortContext == onePortContext)
{
DM_DBG3(("dmResetReported: right portcontext pid %d\n", onePortContext->id));
oneDeviceData->reported = agFALSE;
DeviceListList = DeviceListList->flink;
}
else
{
if (oneDeviceData->dmPortContext != agNULL)
{
DM_DBG3(("dmResetReported: different portcontext; oneDeviceData->dmPortContext pid %d oneportcontext pid %d\n", oneDeviceData->dmPortContext->id, onePortContext->id));
}
else
{
DM_DBG3(("dmResetReported: different portcontext; oneDeviceData->dmPortContext pid NULL oneportcontext pid %d\n", onePortContext->id));
}
DeviceListList = DeviceListList->flink;
}
}
return;
}
/* called on discover failure */
osGLOBAL void
dmDiscoveryInvalidateDevices(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext
)
{
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
dmDeviceData_t *oneDeviceData = agNULL;
dmList_t *DeviceListList;
DM_DBG1(("dmDiscoveryInvalidateDevices: start\n"));
tddmSingleThreadedEnter(dmRoot, DM_DEVICE_LOCK);
if (DMLIST_EMPTY(&(dmAllShared->MainDeviceList)))
{
tddmSingleThreadedLeave(dmRoot, DM_DEVICE_LOCK);
DM_DBG3(("dmDiscoveryInvalidateDevices: empty device list\n"));
return;
}
else
{
tddmSingleThreadedLeave(dmRoot, DM_DEVICE_LOCK);
}
DeviceListList = dmAllShared->MainDeviceList.flink;
while (DeviceListList != &(dmAllShared->MainDeviceList))
{
oneDeviceData = DMLIST_OBJECT_BASE(dmDeviceData_t, MainLink, DeviceListList);
if (oneDeviceData == agNULL)
{
DM_DBG1(("dmDiscoveryInvalidateDevices: oneDeviceData is NULL!!!\n"));
return;
}
DM_DBG3(("dmDiscoveryInvalidateDevices: loop did %d\n", oneDeviceData->id));
DM_DBG3(("dmDiscoveryInvalidateDevices: sasAddrHi 0x%08x \n", oneDeviceData->SASAddressID.sasAddressHi));
DM_DBG3(("dmDiscoveryInvalidateDevices: sasAddrLo 0x%08x \n", oneDeviceData->SASAddressID.sasAddressLo));
DM_DBG3(("dmDiscoveryInvalidateDevices: valid %d\n", oneDeviceData->valid));
DM_DBG3(("dmDiscoveryInvalidateDevices: valid2 %d\n", oneDeviceData->valid2));
DM_DBG3(("dmDiscoveryInvalidateDevices: directlyAttached %d\n", oneDeviceData->directlyAttached));
if ( oneDeviceData->dmPortContext == onePortContext)
{
DM_DBG3(("dmDiscoveryInvalidateDevices: right portcontext pid %d\n", onePortContext->id));
if (oneDeviceData->SASAddressID.sasAddressHi == onePortContext->sasRemoteAddressHi &&
oneDeviceData->SASAddressID.sasAddressLo == onePortContext->sasRemoteAddressLo
)
{
DM_DBG1(("dmDiscoveryInvalidateDevices: keeping\n"));
oneDeviceData->valid = agTRUE;
oneDeviceData->valid2 = agFALSE;
}
else
{
oneDeviceData->valid = agFALSE;
oneDeviceData->valid2 = agFALSE;
oneDeviceData->registered = agFALSE;
oneDeviceData->reported = agFALSE;
/* all targets other than expanders */
DM_DBG3(("dmDiscoveryInvalidateDevices: did %d\n", oneDeviceData->id));
DM_DBG3(("dmDiscoveryInvalidateDevices: sasAddrHi 0x%08x \n", oneDeviceData->SASAddressID.sasAddressHi));
DM_DBG3(("dmDiscoveryInvalidateDevices: sasAddrLo 0x%08x \n", oneDeviceData->SASAddressID.sasAddressLo));
onePortContext->RegisteredDevNums--;
}
DeviceListList = DeviceListList->flink;
}
else
{
if (oneDeviceData->dmPortContext != agNULL)
{
DM_DBG3(("dmDiscoveryInvalidateDevices: different portcontext; oneDeviceData->dmPortContext pid %d oneportcontext pid %d\n", oneDeviceData->dmPortContext->id, onePortContext->id));
}
else
{
DM_DBG3(("dmDiscoveryInvalidateDevices: different portcontext; oneDeviceData->dmPortContext pid NULL oneportcontext pid %d\n", onePortContext->id));
}
DeviceListList = DeviceListList->flink;
}
}
return;
}
/*
should DM report the device removal to TDM on an error case?
or
DM simply removes the devices
For now, the second option.
*/
osGLOBAL void
dmDiscoveryErrorRemovals(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext
)
{
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
dmDeviceData_t *oneDeviceData = agNULL;
dmList_t *DeviceListList;
DM_DBG1(("dmDiscoveryErrorRemovals: start\n"));
tddmSingleThreadedEnter(dmRoot, DM_DEVICE_LOCK);
if (DMLIST_EMPTY(&(dmAllShared->MainDeviceList)))
{
tddmSingleThreadedLeave(dmRoot, DM_DEVICE_LOCK);
DM_DBG3(("dmDiscoveryErrorRemovals: empty device list\n"));
return;
}
else
{
tddmSingleThreadedLeave(dmRoot, DM_DEVICE_LOCK);
}
DeviceListList = dmAllShared->MainDeviceList.flink;
while (DeviceListList != &(dmAllShared->MainDeviceList))
{
oneDeviceData = DMLIST_OBJECT_BASE(dmDeviceData_t, MainLink, DeviceListList);
if (oneDeviceData == agNULL)
{
DM_DBG1(("dmDiscoveryErrorRemovals: oneDeviceData is NULL!!!\n"));
return;
}
DM_DBG3(("dmDiscoveryErrorRemovals: loop did %d\n", oneDeviceData->id));
DM_DBG3(("dmDiscoveryErrorRemovals: sasAddrHi 0x%08x \n", oneDeviceData->SASAddressID.sasAddressHi));
DM_DBG3(("dmDiscoveryErrorRemovals: sasAddrLo 0x%08x \n", oneDeviceData->SASAddressID.sasAddressLo));
DM_DBG3(("dmDiscoveryErrorRemovals: valid %d\n", oneDeviceData->valid));
DM_DBG3(("dmDiscoveryErrorRemovals: valid2 %d\n", oneDeviceData->valid2));
DM_DBG3(("dmDiscoveryErrorRemovals: directlyAttached %d\n", oneDeviceData->directlyAttached));
if ( oneDeviceData->dmPortContext == onePortContext)
{
DM_DBG3(("dmDiscoveryErrorRemovals: right portcontext pid %d\n", onePortContext->id));
if (oneDeviceData->SASAddressID.sasAddressHi == onePortContext->sasRemoteAddressHi &&
oneDeviceData->SASAddressID.sasAddressLo == onePortContext->sasRemoteAddressLo
)
{
DM_DBG1(("dmDiscoveryErrorRemovals: keeping\n"));
oneDeviceData->valid = agTRUE;
oneDeviceData->valid2 = agFALSE;
}
else
{
oneDeviceData->valid = agFALSE;
oneDeviceData->valid2 = agFALSE;
/* all targets other than expanders */
DM_DBG3(("dmDiscoveryErrorRemovals: did %d\n", oneDeviceData->id));
DM_DBG3(("dmDiscoveryErrorRemovals: sasAddrHi 0x%08x \n", oneDeviceData->SASAddressID.sasAddressHi));
DM_DBG3(("dmDiscoveryErrorRemovals: sasAddrLo 0x%08x \n", oneDeviceData->SASAddressID.sasAddressLo));
onePortContext->RegisteredDevNums--;
dmSubReportRemovals(dmRoot, onePortContext, oneDeviceData, dmDeviceRemoval);
}
DeviceListList = DeviceListList->flink;
}
else
{
if (oneDeviceData->dmPortContext != agNULL)
{
DM_DBG3(("dmDiscoveryErrorRemovals: different portcontext; oneDeviceData->dmPortContext pid %d oneportcontext pid %d\n", oneDeviceData->dmPortContext->id, onePortContext->id));
}
else
{
DM_DBG3(("dmDiscoveryErrorRemovals: different portcontext; oneDeviceData->dmPortContext pid NULL oneportcontext pid %d\n", onePortContext->id));
}
DeviceListList = DeviceListList->flink;
}
}
return;
}
/* move from dmAllShared->mainExpanderList to dmAllShared->freeExpanderList */
osGLOBAL void
dmDiscoveryExpanderCleanUp(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext
)
{
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
dmExpander_t *oneExpander = agNULL;
dmList_t *ExpanderList = agNULL;
dmDeviceData_t *oneDeviceData = agNULL;
DM_DBG3(("dmDiscoveryExpanderCleanUp: start\n"));
/*
be sure to call
osGLOBAL void
dmExpanderDeviceDataReInit(
dmRoot_t *dmRoot,
dmExpander_t *oneExpander
);
*/
tddmSingleThreadedEnter(dmRoot, DM_EXPANDER_LOCK);
if (!DMLIST_EMPTY(&(dmAllShared->mainExpanderList)))
{
tddmSingleThreadedLeave(dmRoot, DM_EXPANDER_LOCK);
ExpanderList = dmAllShared->mainExpanderList.flink;
while (ExpanderList != &(dmAllShared->mainExpanderList))
{
oneExpander = DMLIST_OBJECT_BASE(dmExpander_t, linkNode, ExpanderList);
if (oneExpander == agNULL)
{
DM_DBG1(("dmDiscoveryExpanderCleanUp: oneExpander is NULL!!!\n"));
return;
}
oneDeviceData = oneExpander->dmDevice;
DM_DBG3(("dmDiscoveryExpanderCleanUp: sasAddrHi 0x%08x \n", oneDeviceData->SASAddressID.sasAddressHi));
DM_DBG3(("dmDiscoveryExpanderCleanUp: sasAddrLo 0x%08x \n", oneDeviceData->SASAddressID.sasAddressLo));
if ( oneDeviceData->dmPortContext == onePortContext)
{
dmExpanderDeviceDataReInit(dmRoot, oneExpander);
tddmSingleThreadedEnter(dmRoot, DM_EXPANDER_LOCK);
DMLIST_DEQUEUE_THIS(&(oneExpander->linkNode));
DMLIST_ENQUEUE_AT_TAIL(&(oneExpander->linkNode), &(dmAllShared->freeExpanderList));
if (DMLIST_EMPTY(&(dmAllShared->mainExpanderList)))
{
tddmSingleThreadedLeave(dmRoot, DM_EXPANDER_LOCK);
break;
}
else
{
tddmSingleThreadedLeave(dmRoot, DM_EXPANDER_LOCK);
}
ExpanderList = dmAllShared->mainExpanderList.flink;
}
else
{
ExpanderList = ExpanderList->flink;
}
}
}
else
{
tddmSingleThreadedLeave(dmRoot, DM_EXPANDER_LOCK);
DM_DBG3(("dmDiscoveryExpanderCleanUp: empty mainExpanderList\n"));
}
return;
}
/* moves all devices from dmAllShared->MainDeviceList to dmAllShared->FreeDeviceList */
osGLOBAL void
dmDiscoveryDeviceCleanUp(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext
)
{
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
dmDeviceData_t *oneDeviceData = agNULL;
dmList_t *DeviceListList;
DM_DBG3(("dmDiscoveryDeviceCleanUp: start\n"));
tddmSingleThreadedEnter(dmRoot, DM_DEVICE_LOCK);
if (!DMLIST_EMPTY(&(dmAllShared->MainDeviceList)))
{
tddmSingleThreadedLeave(dmRoot, DM_DEVICE_LOCK);
DeviceListList = dmAllShared->MainDeviceList.flink;
while (DeviceListList != &(dmAllShared->MainDeviceList))
{
oneDeviceData = DMLIST_OBJECT_BASE(dmDeviceData_t, MainLink, DeviceListList);
if (oneDeviceData == agNULL)
{
DM_DBG1(("dmDiscoveryDeviceCleanUp: oneDeviceData is NULL!!!\n"));
return;
}
DM_DBG3(("dmDiscoveryDeviceCleanUp: sasAddrHi 0x%08x \n", oneDeviceData->SASAddressID.sasAddressHi));
DM_DBG3(("dmDiscoveryDeviceCleanUp: sasAddrLo 0x%08x \n", oneDeviceData->SASAddressID.sasAddressLo));
if ( oneDeviceData->dmPortContext == onePortContext)
{
dmDeviceDataReInit(dmRoot, oneDeviceData);
tddmSingleThreadedEnter(dmRoot, DM_DEVICE_LOCK);
DMLIST_DEQUEUE_THIS(&(oneDeviceData->MainLink));
DMLIST_ENQUEUE_AT_TAIL(&(oneDeviceData->FreeLink), &(dmAllShared->FreeDeviceList));
if (DMLIST_EMPTY(&(dmAllShared->MainDeviceList)))
{
tddmSingleThreadedLeave(dmRoot, DM_DEVICE_LOCK);
break;
}
else
{
tddmSingleThreadedLeave(dmRoot, DM_DEVICE_LOCK);
}
onePortContext->RegisteredDevNums--;
DeviceListList = dmAllShared->MainDeviceList.flink;
}
else
{
DeviceListList = DeviceListList->flink;
}
}
}
else
{
tddmSingleThreadedLeave(dmRoot, DM_DEVICE_LOCK);
DM_DBG3(("dmDiscoveryDeviceCleanUp: empty MainDeviceList\n"));
}
return;
}
osGLOBAL void
dmDumpAllExp(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
dmExpander_t *oneExpander
)
{
DM_DBG3(("dmDumpAllExp: start\n"));
return;
}
osGLOBAL void
dmDumpAllUpExp(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
dmExpander_t *oneExpander
)
{
DM_DBG3(("dmDumpAllUpExp: start\n"));
return;
}
osGLOBAL void
dmDumpAllFreeExp(
dmRoot_t *dmRoot
)
{
DM_DBG3(("dmDumpAllFreeExp: start\n"));
return;
}
osGLOBAL void
dmDumpAllMainExp(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext
)
{
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
dmList_t *ExpanderList;
dmExpander_t *tempExpander;
DM_DBG3(("dmDumpAllMainExp: start\n"));
tddmSingleThreadedEnter(dmRoot, DM_EXPANDER_LOCK);
if (DMLIST_EMPTY(&(dmAllShared->mainExpanderList)))
{
DM_DBG3(("dmDumpAllMainExp: empty discoveringExpanderList\n"));
tddmSingleThreadedLeave(dmRoot, DM_EXPANDER_LOCK);
return;
}
else
{
tddmSingleThreadedLeave(dmRoot, DM_EXPANDER_LOCK);
}
ExpanderList = dmAllShared->mainExpanderList.flink;
while (ExpanderList != &(dmAllShared->mainExpanderList))
{
tempExpander = DMLIST_OBJECT_BASE(dmExpander_t, linkNode, ExpanderList);
if (tempExpander == agNULL)
{
DM_DBG1(("dmDumpAllMainExp: tempExpander is NULL!!!\n"));
return;
}
DM_DBG3(("dmDumpAllMainExp: expander id %d\n", tempExpander->id));
DM_DBG3(("dmDumpAllMainExp: exp addrHi 0x%08x\n", tempExpander->dmDevice->SASAddressID.sasAddressHi));
DM_DBG3(("dmDumpAllMainExp: exp addrLo 0x%08x\n", tempExpander->dmDevice->SASAddressID.sasAddressLo));
if ((tempExpander->dmDevice->dmPortContext == onePortContext)
)
{
DM_DBG3(("dmDumpAllMainExp: found expander id %d\n", tempExpander->id));
DM_DBG3(("dmDumpAllMainExp: found exp addrHi 0x%08x\n", tempExpander->dmDevice->SASAddressID.sasAddressHi));
DM_DBG3(("dmDumpAllMainExp: found exp addrLo 0x%08x\n", tempExpander->dmDevice->SASAddressID.sasAddressLo));
}
ExpanderList = ExpanderList->flink;
}
return;
}
osGLOBAL void
dmDumpAllMainDevice(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext
)
{
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
dmDeviceData_t *oneDeviceData = agNULL;
dmList_t *DeviceListList;
bit32 total = 0, port_total = 0;
DM_DBG3(("dmDumpAllMainDevice: start\n"));
tddmSingleThreadedEnter(dmRoot, DM_DEVICE_LOCK);
if (DMLIST_EMPTY(&(dmAllShared->MainDeviceList)))
{
DM_DBG3(("dmDumpAllMainDevice: empty discoveringExpanderList\n"));
tddmSingleThreadedLeave(dmRoot, DM_DEVICE_LOCK);
return;
}
else
{
tddmSingleThreadedLeave(dmRoot, DM_DEVICE_LOCK);
}
DeviceListList = dmAllShared->MainDeviceList.flink;
while (DeviceListList != &(dmAllShared->MainDeviceList))
{
oneDeviceData = DMLIST_OBJECT_BASE(dmDeviceData_t, MainLink, DeviceListList);
if (oneDeviceData == agNULL)
{
DM_DBG3(("dmDumpAllMainDevice: oneDeviceData is NULL!!!\n"));
return;
}
DM_DBG3(("dmDumpAllMainDevice: oneDeviceData id %d\n", oneDeviceData->id));
DM_DBG3(("dmDumpAllMainDevice: addrHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi));
DM_DBG3(("dmDumpAllMainDevice: addrLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo));
total++;
if ((oneDeviceData->dmPortContext == onePortContext)
)
{
DM_DBG3(("dmDumpAllMainDevice: found oneDeviceData id %d\n", oneDeviceData->id));
DM_DBG3(("dmDumpAllMainDevice: found addrHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi));
DM_DBG3(("dmDumpAllMainDevice: found addrLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo));
port_total++;
}
DeviceListList = DeviceListList->flink;
}
DM_DBG3(("dmDumpAllMainDevice: total %d port_totaol %d\n", total, port_total));
return;
}
osGLOBAL dmDeviceData_t *
dmAddSASToSharedcontext(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
dmSASSubID_t *dmSASSubID,
dmDeviceData_t *oneExpDeviceData,
bit8 phyID
)
{
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
dmDeviceData_t *oneDeviceData = agNULL;
dmList_t *DeviceListList;
bit32 new_device = agTRUE;
DM_DBG3(("dmAddSASToSharedcontext: start\n"));
DM_DBG3(("dmAddSASToSharedcontext: oneportContext ID %d\n", onePortContext->id));
if (oneExpDeviceData != agNULL)
{
DM_DBG3(("dmAddSASToSharedcontext: oneExpDeviceData sasAddressHi 0x%08x sasAddressLo 0x%08x\n",
oneExpDeviceData->SASAddressID.sasAddressHi, oneExpDeviceData->SASAddressID.sasAddressLo));
}
else
{
DM_DBG3(("dmAddSASToSharedcontext: oneExpDeviceData is NULL\n"));
}
/* find a device's existence */
DeviceListList = dmAllShared->MainDeviceList.flink;
while (DeviceListList != &(dmAllShared->MainDeviceList))
{
oneDeviceData = DMLIST_OBJECT_BASE(dmDeviceData_t, MainLink, DeviceListList);
if (oneDeviceData == agNULL)
{
DM_DBG1(("dmAddSASToSharedcontext: oneDeviceData is NULL!!!\n"));
return agNULL;
}
if ((oneDeviceData->SASAddressID.sasAddressHi == dmSASSubID->sasAddressHi) &&
(oneDeviceData->SASAddressID.sasAddressLo == dmSASSubID->sasAddressLo) &&
(oneDeviceData->dmPortContext == onePortContext)
)
{
DM_DBG3(("dmAddSASToSharedcontext: pid %d did %d\n", onePortContext->id, oneDeviceData->id));
new_device = agFALSE;
break;
}
DeviceListList = DeviceListList->flink;
}
/* new device */
if (new_device == agTRUE)
{
DM_DBG3(("dmAddSASToSharedcontext: new device\n"));
DM_DBG3(("dmAddSASToSharedcontext: sasAddressHi 0x%08x sasAddressLo 0x%08x\n",
dmSASSubID->sasAddressHi, dmSASSubID->sasAddressLo));
tddmSingleThreadedEnter(dmRoot, DM_DEVICE_LOCK);
if (!DMLIST_NOT_EMPTY(&(dmAllShared->FreeDeviceList)))
{
tddmSingleThreadedLeave(dmRoot, DM_DEVICE_LOCK);
DM_DBG1(("dmAddSASToSharedcontext: empty DeviceData FreeLink\n"));
dmDumpAllMainDevice(dmRoot, onePortContext);
return agNULL;
}
DMLIST_DEQUEUE_FROM_HEAD(&DeviceListList, &(dmAllShared->FreeDeviceList));
tddmSingleThreadedLeave(dmRoot, DM_DEVICE_LOCK);
oneDeviceData = DMLIST_OBJECT_BASE(dmDeviceData_t, FreeLink, DeviceListList);
if (oneDeviceData != agNULL)
{
DM_DBG3(("dmAddSASToSharedcontext: oneDeviceData %p pid %d did %d\n", oneDeviceData, onePortContext->id, oneDeviceData->id));
onePortContext->Count++;
oneDeviceData->dmRoot = dmRoot;
/* saving sas address */
oneDeviceData->SASAddressID.sasAddressLo = dmSASSubID->sasAddressLo;
oneDeviceData->SASAddressID.sasAddressHi = dmSASSubID->sasAddressHi;
oneDeviceData->initiator_ssp_stp_smp = dmSASSubID->initiator_ssp_stp_smp;
oneDeviceData->target_ssp_stp_smp = dmSASSubID->target_ssp_stp_smp;
oneDeviceData->dmPortContext = onePortContext;
/* handles both SAS target and STP-target, SATA-device */
if (!DEVICE_IS_SATA_DEVICE(oneDeviceData) && !DEVICE_IS_STP_TARGET(oneDeviceData))
{
oneDeviceData->DeviceType = DM_SAS_DEVICE;
}
else
{
oneDeviceData->DeviceType = DM_SATA_DEVICE;
}
if (oneExpDeviceData != agNULL)
{
oneDeviceData->ExpDevice = oneExpDeviceData;
}
/* set phyID only when it has initial value of 0xFF */
if (oneDeviceData->phyID == 0xFF)
{
oneDeviceData->phyID = phyID;
}
/* incremental discovery */
/* add device to incremental-related link. Report using this link
when incremental discovery is done */
if (onePortContext->DiscoveryState == DM_DSTATE_NOT_STARTED)
{
DM_DBG3(("dmAddSASToSharedcontext: DM_DSTATE_NOT_STARTED\n"));
DM_DBG3(("dmAddSASToSharedcontext: sasAddrHi 0x%08x \n", oneDeviceData->SASAddressID.sasAddressHi));
DM_DBG3(("dmAddSASToSharedcontext: sasAddrLo 0x%08x \n", oneDeviceData->SASAddressID.sasAddressLo));
oneDeviceData->valid = agTRUE;
}
else
{
if (onePortContext->discovery.type == DM_DISCOVERY_OPTION_INCREMENTAL_START)
{
DM_DBG3(("dmAddSASToSharedcontext: incremental discovery\n"));
DM_DBG3(("dmAddSASToSharedcontext: sasAddrHi 0x%08x \n", oneDeviceData->SASAddressID.sasAddressHi));
DM_DBG3(("dmAddSASToSharedcontext: sasAddrLo 0x%08x \n", oneDeviceData->SASAddressID.sasAddressLo));
oneDeviceData->valid2 = agTRUE;
}
else
{
DM_DBG3(("dmAddSASToSharedcontext: full discovery\n"));
DM_DBG3(("dmAddSASToSharedcontext: sasAddrHi 0x%08x \n", oneDeviceData->SASAddressID.sasAddressHi));
DM_DBG3(("dmAddSASToSharedcontext: sasAddrLo 0x%08x \n", oneDeviceData->SASAddressID.sasAddressLo));
oneDeviceData->valid = agTRUE;
}
}
/* add the devicedata to the portcontext */
tddmSingleThreadedEnter(dmRoot, DM_DEVICE_LOCK);
DMLIST_ENQUEUE_AT_TAIL(&(oneDeviceData->MainLink), &(dmAllShared->MainDeviceList));
tddmSingleThreadedLeave(dmRoot, DM_DEVICE_LOCK);
DM_DBG3(("dmAddSASToSharedcontext: one case pid %d did %d \n", onePortContext->id, oneDeviceData->id));
DM_DBG3(("dmAddSASToSharedcontext: new case pid %d did %d phyID %d\n", onePortContext->id, oneDeviceData->id, oneDeviceData->phyID));
}
}
else /* old device */
{
DM_DBG3(("dmAddSASToSharedcontext: old device\n"));
DM_DBG3(("dmAddSASToSharedcontext: oneDeviceData %p did %d\n", oneDeviceData, oneDeviceData->id));
DM_DBG3(("dmAddSASToSharedcontext: sasAddressHi 0x%08x sasAddressLo 0x%08x\n",
dmSASSubID->sasAddressHi, dmSASSubID->sasAddressLo));
oneDeviceData->dmRoot = dmRoot;
/* saving sas address */
oneDeviceData->SASAddressID.sasAddressLo = dmSASSubID->sasAddressLo;
oneDeviceData->SASAddressID.sasAddressHi = dmSASSubID->sasAddressHi;
oneDeviceData->initiator_ssp_stp_smp = dmSASSubID->initiator_ssp_stp_smp;
oneDeviceData->target_ssp_stp_smp = dmSASSubID->target_ssp_stp_smp;
oneDeviceData->dmPortContext = onePortContext;
/* handles both SAS target and STP-target, SATA-device */
if (!DEVICE_IS_SATA_DEVICE(oneDeviceData) && !DEVICE_IS_STP_TARGET(oneDeviceData))
{
oneDeviceData->DeviceType = DM_SAS_DEVICE;
}
else
{
oneDeviceData->DeviceType = DM_SATA_DEVICE;
}
if (oneExpDeviceData != agNULL)
{
oneDeviceData->ExpDevice = oneExpDeviceData;
}
/* set phyID only when it has initial value of 0xFF */
if (oneDeviceData->phyID == 0xFF)
{
oneDeviceData->phyID = phyID;
}
if (onePortContext->DiscoveryState == DM_DSTATE_NOT_STARTED)
{
DM_DBG3(("dmAddSASToSharedcontext: DM_DSTATE_NOT_STARTED\n"));
DM_DBG3(("dmAddSASToSharedcontext: sasAddrHi 0x%08x \n", oneDeviceData->SASAddressID.sasAddressHi));
DM_DBG3(("dmAddSASToSharedcontext: sasAddrLo 0x%08x \n", oneDeviceData->SASAddressID.sasAddressLo));
oneDeviceData->valid = agTRUE;
}
else
{
if (onePortContext->discovery.type == DM_DISCOVERY_OPTION_INCREMENTAL_START)
{
DM_DBG3(("dmAddSASToSharedcontext: incremental discovery\n"));
DM_DBG3(("dmAddSASToSharedcontext: sasAddrHi 0x%08x \n", oneDeviceData->SASAddressID.sasAddressHi));
DM_DBG3(("dmAddSASToSharedcontext: sasAddrLo 0x%08x \n", oneDeviceData->SASAddressID.sasAddressLo));
oneDeviceData->valid2 = agTRUE;
}
else
{
DM_DBG3(("dmAddSASToSharedcontext: full discovery\n"));
DM_DBG3(("dmAddSASToSharedcontext: sasAddrHi 0x%08x \n", oneDeviceData->SASAddressID.sasAddressHi));
DM_DBG3(("dmAddSASToSharedcontext: sasAddrLo 0x%08x \n", oneDeviceData->SASAddressID.sasAddressLo));
oneDeviceData->valid = agTRUE;
}
}
DM_DBG3(("dmAddSASToSharedcontext: old case pid %d did %d phyID %d\n", onePortContext->id, oneDeviceData->id, oneDeviceData->phyID));
}
return oneDeviceData;
}
/* no checking of valid and valid2 */
osGLOBAL dmDeviceData_t *
dmDeviceFind(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
bit32 sasAddrHi,
bit32 sasAddrLo
)
{
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
dmDeviceData_t *oneDeviceData = agNULL;
dmList_t *DeviceListList;
bit32 found = agFALSE;
DM_DBG3(("dmDeviceFind: start\n"));
/* find a device's existence */
DeviceListList = dmAllShared->MainDeviceList.flink;
while (DeviceListList != &(dmAllShared->MainDeviceList))
{
oneDeviceData = DMLIST_OBJECT_BASE(dmDeviceData_t, MainLink, DeviceListList);
if (oneDeviceData == agNULL)
{
DM_DBG1(("dmDeviceFind: oneDeviceData is NULL!!!\n"));
return agNULL;
}
if ((oneDeviceData->SASAddressID.sasAddressHi == sasAddrHi) &&
(oneDeviceData->SASAddressID.sasAddressLo == sasAddrLo) &&
// (oneDeviceData->valid == agTRUE) &&
(oneDeviceData->dmPortContext == onePortContext)
)
{
DM_DBG3(("dmDeviceFind: Found pid %d did %d\n", onePortContext->id, oneDeviceData->id));
DM_DBG3(("dmDeviceFind: sasAddressHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi));
DM_DBG3(("dmDeviceFind: sasAddressLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo));
found = agTRUE;
break;
}
DeviceListList = DeviceListList->flink;
}
if (found == agFALSE)
{
DM_DBG3(("dmDeviceFind: end returning NULL\n"));
return agNULL;
}
else
{
DM_DBG3(("dmDeviceFind: end returning NOT NULL\n"));
return oneDeviceData;
}
}
osGLOBAL void
dmBCTimer(
dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext
)
{
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
dmDiscovery_t *discovery;
DM_DBG3(("dmBCTimer: start\n"));
discovery = &(onePortContext->discovery);
tddmSingleThreadedEnter(dmRoot, DM_TIMER_LOCK);
if (discovery->BCTimer.timerRunning == agTRUE)
{
tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
dmKillTimer(
dmRoot,
&discovery->BCTimer
);
}
else
{
tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
}
if (onePortContext->valid == agTRUE)
{
dmSetTimerRequest(
dmRoot,
&discovery->BCTimer,
BC_TIMER_VALUE/dmAllShared->usecsPerTick,
dmBCTimerCB,
onePortContext,
agNULL,
agNULL
);
dmAddTimer(
dmRoot,
&dmAllShared->timerlist,
&discovery->BCTimer
);
}
return;
}
osGLOBAL void
dmBCTimerCB(
dmRoot_t * dmRoot,
void * timerData1,
void * timerData2,
void * timerData3
)
{
dmIntPortContext_t *onePortContext;
dmDiscovery_t *discovery;
DM_DBG3(("dmBCTimerCB: start\n"));
onePortContext = (dmIntPortContext_t *)timerData1;
discovery = &(onePortContext->discovery);
tddmSingleThreadedEnter(dmRoot, DM_TIMER_LOCK);
if (discovery->BCTimer.timerRunning == agTRUE)
{
tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
dmKillTimer(
dmRoot,
&discovery->BCTimer
);
}
else
{
tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
}
discovery->ResetTriggerred = agFALSE;
if (onePortContext->valid == agTRUE)
{
dmDiscover(dmRoot,
onePortContext->dmPortContext,
DM_DISCOVERY_OPTION_INCREMENTAL_START
);
}
return;
}
/* discovery related SMP timers */
osGLOBAL void
dmDiscoverySMPTimer(dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
bit32 functionCode,
dmSMPRequestBody_t *dmSMPRequestBody
)
{
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
dmDiscovery_t *discovery;
DM_DBG3(("dmDiscoverySMPTimer: start\n"));
DM_DBG3(("dmDiscoverySMPTimer: pid %d SMPFn 0x%x\n", onePortContext->id, functionCode));
/* start the SMP timer which works as SMP application timer */
discovery = &(onePortContext->discovery);
tddmSingleThreadedEnter(dmRoot, DM_TIMER_LOCK);
if (discovery->DiscoverySMPTimer.timerRunning == agTRUE)
{
tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
dmKillTimer(
dmRoot,
&discovery->DiscoverySMPTimer
);
}
else
{
tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
}
dmSetTimerRequest(
dmRoot,
&discovery->DiscoverySMPTimer,
SMP_TIMER_VALUE/dmAllShared->usecsPerTick,
dmDiscoverySMPTimerCB,
onePortContext,
dmSMPRequestBody,
agNULL
);
dmAddTimer (
dmRoot,
&dmAllShared->timerlist,
&discovery->DiscoverySMPTimer
);
return;
}
osGLOBAL void
dmDiscoverySMPTimerCB(
dmRoot_t * dmRoot,
void * timerData1,
void * timerData2,
void * timerData3
)
{
agsaRoot_t *agRoot;
dmIntPortContext_t *onePortContext;
bit8 SMPFunction;
#ifndef DIRECT_SMP
dmSMPFrameHeader_t *dmSMPFrameHeader;
bit8 smpHeader[4];
#endif
dmSMPRequestBody_t *dmSMPRequestBody;
dmDiscovery_t *discovery;
dmDeviceData_t *oneDeviceData;
agsaIORequest_t *agAbortIORequest = agNULL;
agsaIORequest_t *agToBeAbortIORequest = agNULL;
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
dmExpander_t *oneExpander = agNULL;
dmSMPRequestBody_t *dmAbortSMPRequestBody = agNULL;
dmList_t *SMPList;
DM_DBG1(("dmDiscoverySMPTimerCB: start!!!\n"));
onePortContext = (dmIntPortContext_t *)timerData1;
dmSMPRequestBody = (dmSMPRequestBody_t *)timerData2;
discovery = &(onePortContext->discovery);
oneDeviceData = dmSMPRequestBody->dmDevice;
agToBeAbortIORequest = &(dmSMPRequestBody->agIORequest);
agRoot = dmAllShared->agRoot;
#ifdef DIRECT_SMP
SMPFunction = dmSMPRequestBody->smpPayload[1];
#else
saFrameReadBlock(agRoot, dmSMPRequestBody->IndirectSMP, 0, smpHeader, 4);
dmSMPFrameHeader = (dmSMPFrameHeader_t *)smpHeader;
SMPFunction = dmSMPFrameHeader->smpFunction;
#endif
DM_DBG3(("dmDiscoverySMPTimerCB: SMP function 0x%x\n", SMPFunction));
tddmSingleThreadedEnter(dmRoot, DM_TIMER_LOCK);
if (discovery->DiscoverySMPTimer.timerRunning == agTRUE)
{
tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
dmKillTimer(
dmRoot,
&discovery->DiscoverySMPTimer
);
}
else
{
tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
}
//for debugging
// saGetPendingPICI(agRoot);
switch (SMPFunction)
{
case SMP_REPORT_GENERAL: /* fall through */
case SMP_DISCOVER: /* fall through */
case SMP_CONFIGURE_ROUTING_INFORMATION: /* fall through */
DM_DBG1(("dmDiscoverySMPTimerCB: failing discovery, SMP function 0x%x !!!\n", SMPFunction));
dmDiscoverDone(dmRoot, onePortContext, DM_RC_FAILURE);
return; /* no more things to do */
case SMP_REPORT_PHY_SATA:
DM_DBG1(("dmDiscoverySMPTimerCB: failing discovery, SMP function SMP_REPORT_PHY_SATA !!!\n"));
dmDiscoverDone(dmRoot, onePortContext, DM_RC_FAILURE);
break;
default:
/* do nothing */
DM_DBG1(("dmDiscoverySMPTimerCB: Error, not allowed case!!!\n"));
break;
}
if (oneDeviceData->registered == agTRUE && (oneDeviceData->valid == agTRUE || oneDeviceData->valid2 == agTRUE) )
{
/* call to saSMPAbort(one) */
/* get an smp REQUEST from the free list */
tddmSingleThreadedEnter(dmRoot, DM_SMP_LOCK);
if (DMLIST_EMPTY(&(dmAllShared->freeSMPList)))
{
DM_DBG1(("dmDiscoverySMPTimerCB: no free SMP, can't abort SMP!!!\n"));
tddmSingleThreadedLeave(dmRoot, DM_SMP_LOCK);
return;
}
else
{
DMLIST_DEQUEUE_FROM_HEAD(&SMPList, &(dmAllShared->freeSMPList));
tddmSingleThreadedLeave(dmRoot, DM_SMP_LOCK);
dmAbortSMPRequestBody = DMLIST_OBJECT_BASE(dmSMPRequestBody_t, Link, SMPList);
if (dmAbortSMPRequestBody == agNULL)
{
DM_DBG1(("dmDiscoverySMPTimerCB: dmAbortSMPRequestBody is NULL!!!\n"));
return;
}
DM_DBG5(("dmDiscoverySMPTimerCB: SMP id %d\n", dmAbortSMPRequestBody->id));
}
dmAbortSMPRequestBody->dmRoot = dmRoot;
agAbortIORequest = &(dmAbortSMPRequestBody->agIORequest);
agAbortIORequest->osData = (void *) dmAbortSMPRequestBody;
agAbortIORequest->sdkData = agNULL; /* SALL takes care of this */
oneExpander = oneDeviceData->dmExpander;
DM_DBG1(("dmDiscoverySMPTimerCB: calling saSMPAbort!!!\n"));
saSMPAbort(agRoot,
agAbortIORequest,
0,
oneExpander->agDevHandle,
0, /* abort one */
agToBeAbortIORequest,
dmSMPAbortCB
);
}
return;
}
osGLOBAL void
dmSMPBusyTimer(dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
dmDeviceData_t *oneDeviceData,
dmSMPRequestBody_t *dmSMPRequestBody
)
{
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
dmDiscovery_t *discovery;
DM_DBG3(("dmSMPBusyTimer: start\n"));
DM_DBG3(("dmSMPBusyTimer: pid %d\n", onePortContext->id));
discovery = &(onePortContext->discovery);
tddmSingleThreadedEnter(dmRoot, DM_TIMER_LOCK);
if (discovery->SMPBusyTimer.timerRunning == agTRUE)
{
tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
dmKillTimer(
dmRoot,
&discovery->SMPBusyTimer
);
}
else
{
tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
}
dmSetTimerRequest(
dmRoot,
&discovery->SMPBusyTimer,
SMP_BUSY_TIMER_VALUE/dmAllShared->usecsPerTick,
dmSMPBusyTimerCB,
onePortContext,
oneDeviceData,
dmSMPRequestBody
);
dmAddTimer (
dmRoot,
&dmAllShared->timerlist,
&discovery->SMPBusyTimer
);
return;
}
osGLOBAL void
dmSMPBusyTimerCB(
dmRoot_t * dmRoot,
void * timerData1,
void * timerData2,
void * timerData3
)
{
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
agsaRoot_t *agRoot;
dmIntPortContext_t *onePortContext;
dmDeviceData_t *oneDeviceData;
dmSMPRequestBody_t *dmSMPRequestBody;
agsaSASRequestBody_t *agSASRequestBody;
agsaIORequest_t *agIORequest;
agsaDevHandle_t *agDevHandle;
dmDiscovery_t *discovery;
bit32 status = AGSA_RC_FAILURE;
dmExpander_t *oneExpander = agNULL;
DM_DBG3(("dmSMPBusyTimerCB: start\n"));
onePortContext = (dmIntPortContext_t *)timerData1;
oneDeviceData = (dmDeviceData_t *)timerData2;
dmSMPRequestBody = (dmSMPRequestBody_t *)timerData3;
agRoot = dmAllShared->agRoot;
agIORequest = &(dmSMPRequestBody->agIORequest);
oneExpander = oneDeviceData->dmExpander;
agDevHandle = oneExpander->agDevHandle;
agSASRequestBody = &(dmSMPRequestBody->agSASRequestBody);
discovery = &(onePortContext->discovery);
discovery->SMPRetries++;
if (discovery->SMPRetries < SMP_BUSY_RETRIES)
{
status = saSMPStart(
agRoot,
agIORequest,
0,
agDevHandle,
AGSA_SMP_INIT_REQ,
agSASRequestBody,
&dmsaSMPCompleted
);
}
if (status == AGSA_RC_SUCCESS)
{
discovery->SMPRetries = 0;
tddmSingleThreadedEnter(dmRoot, DM_TIMER_LOCK);
if (discovery->SMPBusyTimer.timerRunning == agTRUE)
{
tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
dmKillTimer(
dmRoot,
&discovery->SMPBusyTimer
);
}
else
{
tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
}
}
else if (status == AGSA_RC_FAILURE)
{
tddmSingleThreadedEnter(dmRoot, DM_TIMER_LOCK);
if (discovery->SMPBusyTimer.timerRunning == agTRUE)
{
tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
dmKillTimer(
dmRoot,
&discovery->SMPBusyTimer
);
}
else
{
tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
}
discovery->SMPRetries = 0;
dmDiscoverDone(dmRoot, onePortContext, DM_RC_FAILURE);
}
else /* AGSA_RC_BUSY */
{
if (discovery->SMPRetries >= SMP_BUSY_RETRIES)
{
/* done with retris; give up */
DM_DBG3(("dmSMPBusyTimerCB: retries are over\n"));
tddmSingleThreadedEnter(dmRoot, DM_TIMER_LOCK);
if (discovery->SMPBusyTimer.timerRunning == agTRUE)
{
tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
dmKillTimer(
dmRoot,
&discovery->SMPBusyTimer
);
}
else
{
tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
}
discovery->SMPRetries = 0;
dmDiscoverDone(dmRoot, onePortContext, DM_RC_FAILURE);
}
else
{
/* keep retrying */
dmSMPBusyTimer(dmRoot, onePortContext, oneDeviceData, dmSMPRequestBody);
}
}
return;
}
/* expander configuring timer */
osGLOBAL void
dmDiscoveryConfiguringTimer(dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
dmDeviceData_t *oneDeviceData
)
{
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
dmDiscovery_t *discovery;
DM_DBG3(("dmDiscoveryConfiguringTimer: start\n"));
DM_DBG3(("dmDiscoveryConfiguringTimer: pid %d\n", onePortContext->id));
discovery = &(onePortContext->discovery);
tddmSingleThreadedEnter(dmRoot, DM_TIMER_LOCK);
if (discovery->discoveryTimer.timerRunning == agTRUE)
{
tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
dmKillTimer(
dmRoot,
&discovery->discoveryTimer
);
}
else
{
tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
}
DM_DBG3(("dmDiscoveryConfiguringTimer: UsecsPerTick %d\n", dmAllShared->usecsPerTick));
DM_DBG3(("dmDiscoveryConfiguringTimer: Timervalue %d\n", DISCOVERY_CONFIGURING_TIMER_VALUE/dmAllShared->usecsPerTick));
dmSetTimerRequest(
dmRoot,
&discovery->discoveryTimer,
DISCOVERY_CONFIGURING_TIMER_VALUE/dmAllShared->usecsPerTick,
dmDiscoveryConfiguringTimerCB,
onePortContext,
oneDeviceData,
agNULL
);
dmAddTimer (
dmRoot,
&dmAllShared->timerlist,
&discovery->discoveryTimer
);
return;
}
osGLOBAL void
dmDiscoveryConfiguringTimerCB(
dmRoot_t * dmRoot,
void * timerData1,
void * timerData2,
void * timerData3
)
{
dmIntPortContext_t *onePortContext = agNULL;
dmDiscovery_t *discovery = agNULL;
dmDeviceData_t *oneDeviceData = agNULL;
onePortContext = (dmIntPortContext_t *)timerData1;
oneDeviceData = (dmDeviceData_t *)timerData2;
discovery = &(onePortContext->discovery);
DM_DBG3(("dmDiscoveryConfiguringTimerCB: start\n"));
tddmSingleThreadedEnter(dmRoot, DM_TIMER_LOCK);
if (discovery->discoveryTimer.timerRunning == agTRUE)
{
tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
dmKillTimer(
dmRoot,
&discovery->discoveryTimer
);
}
else
{
tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
}
if (oneDeviceData->valid == agTRUE || oneDeviceData->valid2 == agTRUE)
{
dmReportGeneralSend(dmRoot, oneDeviceData);
}
return;
}
osGLOBAL void
dmConfigureRouteTimer(dmRoot_t *dmRoot,
dmIntPortContext_t *onePortContext,
dmExpander_t *oneExpander,
smpRespDiscover_t *pdmSMPDiscoverResp,
smpRespDiscover2_t *pdmSMPDiscover2Resp
)
{
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
dmDiscovery_t *discovery;
DM_DBG3(("dmConfigureRouteTimer: start\n"));
DM_DBG3(("dmConfigureRouteTimer: pid %d\n", onePortContext->id));
discovery = &(onePortContext->discovery);
DM_DBG3(("dmConfigureRouteTimer: onePortContext %p oneExpander %p pdmSMPDiscoverResp %p\n", onePortContext, oneExpander, pdmSMPDiscoverResp));
DM_DBG3(("dmConfigureRouteTimer: discovery %p \n", discovery));
DM_DBG3(("dmConfigureRouteTimer: pid %d configureRouteRetries %d\n", onePortContext->id, discovery->configureRouteRetries));
DM_DBG3(("dmConfigureRouteTimer: discovery->status %d\n", discovery->status));
tddmSingleThreadedEnter(dmRoot, DM_TIMER_LOCK);
if (discovery->configureRouteTimer.timerRunning == agTRUE)
{
tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
dmKillTimer(
dmRoot,
&discovery->configureRouteTimer
);
}
else
{
tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
}
DM_DBG3(("dmConfigureRouteTimer: UsecsPerTick %d\n", dmAllShared->usecsPerTick));
DM_DBG3(("dmConfigureRouteTimer: Timervalue %d\n", CONFIGURE_ROUTE_TIMER_VALUE/dmAllShared->usecsPerTick));
if (oneExpander->SAS2 == 0)
{
/* SAS 1.1 */
dmSetTimerRequest(
dmRoot,
&discovery->configureRouteTimer,
CONFIGURE_ROUTE_TIMER_VALUE/dmAllShared->usecsPerTick,
dmConfigureRouteTimerCB,
(void *)onePortContext,
(void *)oneExpander,
(void *)pdmSMPDiscoverResp
);
}
else
{
/* SAS 2 */
dmSetTimerRequest(
dmRoot,
&discovery->configureRouteTimer,
CONFIGURE_ROUTE_TIMER_VALUE/dmAllShared->usecsPerTick,
dmConfigureRouteTimerCB,
(void *)onePortContext,
(void *)oneExpander,
(void *)pdmSMPDiscover2Resp
);
}
dmAddTimer (
dmRoot,
&dmAllShared->timerlist,
&discovery->configureRouteTimer
);
return;
}
osGLOBAL void
dmConfigureRouteTimerCB(
dmRoot_t * dmRoot,
void * timerData1,
void * timerData2,
void * timerData3
)
{
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
dmIntPortContext_t *onePortContext;
dmExpander_t *oneExpander;
smpRespDiscover_t *pdmSMPDiscoverResp = agNULL;
smpRespDiscover2_t *pdmSMPDiscover2Resp = agNULL;
dmDiscovery_t *discovery;
DM_DBG3(("dmConfigureRouteTimerCB: start\n"));
onePortContext = (dmIntPortContext_t *)timerData1;
oneExpander = (dmExpander_t *)timerData2;
if (oneExpander->SAS2 == 0)
{
pdmSMPDiscoverResp = (smpRespDiscover_t *)timerData3;
}
else
{
pdmSMPDiscover2Resp = (smpRespDiscover2_t *)timerData3;
}
discovery = &(onePortContext->discovery);
DM_DBG3(("dmConfigureRouteTimerCB: onePortContext %p oneExpander %p pdmSMPDiscoverResp %p\n", onePortContext, oneExpander, pdmSMPDiscoverResp));
DM_DBG3(("dmConfigureRouteTimerCB: discovery %p\n", discovery));
DM_DBG3(("dmConfigureRouteTimerCB: pid %d configureRouteRetries %d\n", onePortContext->id, discovery->configureRouteRetries));
DM_DBG3(("dmConfigureRouteTimerCB: discovery.status %d\n", discovery->status));
discovery->configureRouteRetries++;
if (discovery->configureRouteRetries >= dmAllShared->MaxRetryDiscovery)
{
DM_DBG3(("dmConfigureRouteTimerCB: retries are over\n"));
tddmSingleThreadedEnter(dmRoot, DM_TIMER_LOCK);
if (discovery->configureRouteTimer.timerRunning == agTRUE)
{
tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
dmKillTimer(
dmRoot,
&discovery->configureRouteTimer
);
}
else
{
tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
}
discovery->configureRouteRetries = 0;
/* failed the discovery */
dmDiscoverDone(dmRoot, onePortContext, DM_RC_FAILURE);
return;
}
if (oneExpander->SAS2 == 0)
{
if (onePortContext->discovery.status == DISCOVERY_DOWN_STREAM)
{
DM_DBG3(("dmConfigureRouteTimerCB: proceed by calling dmDownStreamDiscoverExpanderPhy\n"));
dmhexdump("dmConfigureRouteTimerCB", (bit8*)pdmSMPDiscoverResp, sizeof(smpRespDiscover_t));
discovery->configureRouteRetries = 0;
dmDownStreamDiscoverExpanderPhy(dmRoot, onePortContext, oneExpander, pdmSMPDiscoverResp);
}
else
{
DM_DBG3(("dmConfigureRouteTimerCB: setting timer again\n"));
/* set the timer again */
dmSetTimerRequest(
dmRoot,
&discovery->configureRouteTimer,
CONFIGURE_ROUTE_TIMER_VALUE/dmAllShared->usecsPerTick,
dmConfigureRouteTimerCB,
(void *)onePortContext,
(void *)oneExpander,
(void *)pdmSMPDiscoverResp
);
dmAddTimer (
dmRoot,
&dmAllShared->timerlist,
&discovery->configureRouteTimer
);
}
} /* SAS 1.1 */
else
{
/* SAS 2 */
if (onePortContext->discovery.status == DISCOVERY_DOWN_STREAM)
{
DM_DBG2(("dmConfigureRouteTimerCB: proceed by calling dmDownStreamDiscover2ExpanderPhy\n"));
dmhexdump("dmConfigureRouteTimerCB", (bit8*)pdmSMPDiscover2Resp, sizeof(smpRespDiscover2_t));
dmDownStreamDiscover2ExpanderPhy(dmRoot, onePortContext, oneExpander, pdmSMPDiscover2Resp);
}
else
{
DM_DBG2(("dmConfigureRouteTimerCB: setting timer again\n"));
/* set the timer again */
dmSetTimerRequest(
dmRoot,
&discovery->configureRouteTimer,
CONFIGURE_ROUTE_TIMER_VALUE/dmAllShared->usecsPerTick,
dmConfigureRouteTimerCB,
(void *)onePortContext,
(void *)oneExpander,
(void *)pdmSMPDiscover2Resp
);
dmAddTimer (
dmRoot,
&dmAllShared->timerlist,
&discovery->configureRouteTimer
);
}
}
return;
}
#endif /* FDS_ DM */