#include <sys/cdefs.h>
#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>
#include <dev/pms/RefTisa/tisa/api/titypes.h>
#include <dev/pms/RefTisa/tisa/api/ostiapi.h>
#include <dev/pms/RefTisa/tisa/api/tiapi.h>
#include <dev/pms/RefTisa/tisa/api/tiglobal.h>
#ifdef FDS_SM
#include <dev/pms/RefTisa/sat/api/sm.h>
#include <dev/pms/RefTisa/sat/api/smapi.h>
#include <dev/pms/RefTisa/sat/api/tdsmapi.h>
#endif
#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>
#endif
#include <dev/pms/RefTisa/tisa/sassata/sas/common/tdtypes.h>
#include <dev/pms/freebsd/driver/common/osstring.h>
#include <dev/pms/RefTisa/tisa/sassata/common/tdutil.h>
#ifdef INITIATOR_DRIVER
#include <dev/pms/RefTisa/tisa/sassata/sas/ini/itdtypes.h>
#include <dev/pms/RefTisa/tisa/sassata/sas/ini/itddefs.h>
#include <dev/pms/RefTisa/tisa/sassata/sas/ini/itdglobl.h>
#endif
#ifdef TARGET_DRIVER
#include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdglobl.h>
#include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdxchg.h>
#include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdtypes.h>
#endif
#include <dev/pms/RefTisa/tisa/sassata/common/tdsatypes.h>
#include <dev/pms/RefTisa/tisa/sassata/common/tdproto.h>
#ifdef ECHO_TESTING
extern bit8 gEcho;
#endif
#if defined(SALLSDK_DEBUG)
extern bit32 gLLDebugLevel;
#endif
#include <dev/pms/RefTisa/sallsdk/spc/mpidebug.h>
#ifdef SA_ENABLE_TRACE_FUNCTIONS
#ifdef siTraceFileID
#undef siTraceFileID
#endif
#define siTraceFileID 'R'
#endif
FORCEINLINE
void ossaCacheInvalidate(
agsaRoot_t *agRoot,
void *osMemHandle,
void *virtPtr,
bit32 length
)
{
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
TI_DBG6(("ossaCacheInvalidate: start\n"));
ostiCacheInvalidate(tiRoot, osMemHandle, virtPtr, length);
return;
}
FORCEINLINE
void ossaCacheFlush(
agsaRoot_t *agRoot,
void *osMemHandle,
void *virtPtr,
bit32 length
)
{
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
TI_DBG6(("ossaCacheFlush: start\n"));
ostiCacheFlush(tiRoot, osMemHandle, virtPtr, length);
return;
}
FORCEINLINE
void ossaCachePreFlush(
agsaRoot_t *agRoot,
void *osMemHandle,
void *virtPtr,
bit32 length
)
{
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
TI_DBG6(("ossaCachePreFlush: start\n"));
ostiCachePreFlush(tiRoot, osMemHandle, virtPtr, length);
return;
}
osGLOBAL bit32 ossaDeviceHandleAccept(
agsaRoot_t *agRoot,
agsaDevHandle_t *agDevHandle,
agsaSASDeviceInfo_t *agDevInfo,
agsaPortContext_t *agPortContext,
bit32 *hostAssignedDeviceId
)
{
#ifdef TARGET_DRIVER
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
tdsaPortContext_t *onePortContext = agNULL;
tiPortalContext_t *tiPortalContext = agNULL;
tdsaDeviceData_t *oneDeviceData = agNULL;
tiDeviceHandle_t *tiDeviceHandle = agNULL;
tdsaSASSubID_t agSASSubID;
bit32 option;
bit32 param;
smTraceFuncEnter(hpDBG_VERY_LOUD, "Y0");
TI_DBG1(("ossaDeviceHandleAccept: start hostAssignedDeviceId 0x%X\n",*hostAssignedDeviceId));
if (agPortContext == agNULL)
{
TI_DBG1(("ossaDeviceHandleAccept: NULL agsaPortContext; wrong\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Y0");
return OSSA_RC_REJECT;
}
onePortContext = (tdsaPortContext_t *)agPortContext->osData;
if (onePortContext == agNULL)
{
TI_DBG1(("ossaDeviceHandleAccept: NULL oneportcontext; wrong\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "Y0");
return OSSA_RC_REJECT;
}
tiPortalContext = (tiPortalContext_t *)onePortContext->tiPortalContext;
if (tiPortalContext == agNULL)
{
TI_DBG1(("ossaDeviceHandleAccept: NULL tiPortalContext; wrong\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "Y0");
return OSSA_RC_REJECT;
}
TI_DBG4(("ossaDeviceHandleAccept: sasAddressHi 0x%08x\n", SA_DEVINFO_GET_SAS_ADDRESSHI(&agDevInfo->commonDevInfo)));
TI_DBG4(("ossaDeviceHandleAccept: sasAddressLo 0x%08x\n", SA_DEVINFO_GET_SAS_ADDRESSLO(&agDevInfo->commonDevInfo)));
TI_DBG4(("ossaDeviceHandleAccept: device type 0x%x\n", DEVINFO_GET_DEVICETTYPE(&agDevInfo->commonDevInfo)));
TI_DBG4(("ossaDeviceHandleAccept: phys %d\n", agDevInfo->numOfPhys));
TI_DBG4(("ossaDeviceHandleAccept: pid %d\n", onePortContext->id));
if (DEVINFO_GET_DEVICETTYPE(&agDevInfo->commonDevInfo) == SAS_END_DEVICE)
{
TI_DBG4(("ossaDeviceHandleAccept: SAS_END_DEVICE\n"));
}
else if (DEVINFO_GET_DEVICETTYPE(&agDevInfo->commonDevInfo) == SAS_EDGE_EXPANDER_DEVICE)
{
TI_DBG4(("ossaDeviceHandleAccept: SAS_EDGE_EXPANDER_DEVICE\n"));
}
else
{
TI_DBG4(("ossaDeviceHandleAccept: SAS_FANOUT_EXPANDER_DEVICE\n"));
}
agSASSubID.sasAddressHi = SA_DEVINFO_GET_SAS_ADDRESSHI(&agDevInfo->commonDevInfo);
agSASSubID.sasAddressLo = SA_DEVINFO_GET_SAS_ADDRESSLO(&agDevInfo->commonDevInfo);
agSASSubID.initiator_ssp_stp_smp = agDevInfo->initiator_ssp_stp_smp;
agSASSubID.target_ssp_stp_smp = agDevInfo->target_ssp_stp_smp;
tdssAddSASToSharedcontext(
onePortContext,
agRoot,
agDevHandle,
&agSASSubID,
agTRUE,
0xFF,
TD_OPERATION_TARGET
);
oneDeviceData = (tdsaDeviceData_t *)agDevHandle->osData;
if (oneDeviceData == agNULL)
{
TI_DBG1(("ossaDeviceHandleAccept: NULL oneDeviceData; wrong\n"));
return OSSA_RC_REJECT;
}
oneDeviceData->registered = agTRUE;
tiDeviceHandle = &(oneDeviceData->tiDeviceHandle);
if (tiDeviceHandle == agNULL)
{
TI_DBG1(("ossaDeviceHandleAccept: NULL tiDeviceHandle; wrong\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'd', "Y0");
return OSSA_RC_REJECT;
}
agDevInfo->commonDevInfo.flag = agDevInfo->commonDevInfo.flag | (tdsaAllShared->MCN << 16);
onePortContext->RegisteredDevNums++;
*hostAssignedDeviceId |= 0xBEEF0000;
TI_DBG1(("ossaDeviceHandleAccept: Now hostAssignedDeviceId 0x%X\n", *hostAssignedDeviceId));
ostiTargetEvent(
tiRoot,
tiPortalContext,
tiDeviceHandle,
tiTgtEventTypeDeviceChange,
tiDeviceArrival,
agNULL
);
option = 24;
param = (1 << 18) | (tdsaAllShared->MCN << 24);
TI_DBG1(("ossaDeviceHandleAccept: option 0x%x param 0x%x MCN 0x%x\n", option, param, tdsaAllShared->MCN));
saSetDeviceInfo(agRoot, agNULL, 0, agDevHandle, option, param, ossaSetDeviceInfoCB);
smTraceFuncExit(hpDBG_VERY_LOUD, 'e', "Y0");
return OSSA_RC_ACCEPT;
#endif
#ifdef INITIATOR_DRIVER
return OSSA_RC_ACCEPT;
#endif
}
#ifdef INITIATOR_DRIVER
osGLOBAL void ossaDiscoverSasCB(agsaRoot_t *agRoot,
agsaPortContext_t *agPortContext,
bit32 event,
void *pParm1,
void *pParm2
)
{
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
tdsaContext_t *tdsaAllShared = (tdsaContext_t *)osData->tdsaAllShared;
tdsaPortContext_t *onePortContext = agNULL;
tdsaDeviceData_t *oneDeviceData = agNULL;
agsaDevHandle_t *agDevHandle = agNULL;
agsaSASDeviceInfo_t *agDeviceInfo = agNULL;
tiPortalContext_t *tiPortalContext = agNULL;
tdList_t *DeviceListList;
tdsaSASSubID_t agSASSubID;
smTraceFuncEnter(hpDBG_VERY_LOUD,"Y1");
TI_DBG2(("ossaDiscoverSasCB: start\n"));
if (agPortContext == agNULL)
{
TI_DBG1(("ossaDiscoverSasCB: NULL agsaPortContext; wrong\n"));
return;
}
onePortContext = (tdsaPortContext_t *)agPortContext->osData;
tiPortalContext = (tiPortalContext_t *)onePortContext->tiPortalContext;
switch ( event )
{
case OSSA_DISCOVER_STARTED:
{
TI_DBG3(("ossaDiscoverSasCB: STARTED pid %d\n", onePortContext->id));
DeviceListList = tdsaAllShared->MainDeviceList.flink;
while (DeviceListList != &(tdsaAllShared->MainDeviceList))
{
oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
TI_DBG3(("ossaDiscoverSasCB: loop did %d\n", oneDeviceData->id));
TI_DBG3(("ossaDiscoverSasCB: loop sasAddressHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi));
TI_DBG6(("ossaDiscoverSasCB: loop sasAddressLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo));
if (oneDeviceData->tdPortContext == onePortContext)
{
TI_DBG3(("ossaDiscoverSasCB: did %d is invalidated \n", oneDeviceData->id));
}
DeviceListList = DeviceListList->flink;
}
onePortContext->DiscoveryState = ITD_DSTATE_STARTED;
break;
}
case OSSA_DISCOVER_FOUND_DEVICE:
{
TI_DBG4(("ossaDiscoverSasCB: $$$$$ FOUND_DEVICE pid %d\n", onePortContext->id));
agDevHandle = (agsaDevHandle_t *)pParm1;
agDeviceInfo = (agsaSASDeviceInfo_t *)pParm2;
TI_DBG5(("ossaDiscoverSasCB: sasAddressHi 0x%08x\n", SA_DEVINFO_GET_SAS_ADDRESSHI(&agDeviceInfo->commonDevInfo)));
TI_DBG5(("ossaDiscoverSasCB: sasAddressLo 0x%08x\n", SA_DEVINFO_GET_SAS_ADDRESSLO(&agDeviceInfo->commonDevInfo)));
TI_DBG5(("ossaDiscoverSasCB: device type 0x%x\n", DEVINFO_GET_DEVICETTYPE(&agDeviceInfo->commonDevInfo)));
TI_DBG6(("ossaDiscoverSasCB: phys %d\n", agDeviceInfo->numOfPhys));
TI_DBG4(("ossaDiscoverSasCB: pid %d\n", onePortContext->id));
if (DEVINFO_GET_DEVICETTYPE(&agDeviceInfo->commonDevInfo) == SAS_END_DEVICE)
{
agSASSubID.sasAddressHi = SA_DEVINFO_GET_SAS_ADDRESSHI(&agDeviceInfo->commonDevInfo);
agSASSubID.sasAddressLo = SA_DEVINFO_GET_SAS_ADDRESSLO(&agDeviceInfo->commonDevInfo);
agSASSubID.initiator_ssp_stp_smp = agDeviceInfo->initiator_ssp_stp_smp;
agSASSubID.target_ssp_stp_smp = agDeviceInfo->target_ssp_stp_smp;
TI_DBG2(("ossaDiscoverSasCB: adding ....\n"));
tdssAddSASToSharedcontext(
onePortContext,
agRoot,
agDevHandle,
&agSASSubID,
agTRUE,
agDeviceInfo->phyIdentifier,
TD_OPERATION_INITIATOR
);
ostiInitiatorEvent(
tiRoot,
tiPortalContext,
agNULL,
tiIntrEventTypeDeviceChange,
tiDeviceArrival,
agNULL
);
}
else
{
TI_DBG5(("ossaDiscoverSasCB: $$$$$ not end device. not adding....\n"));
}
break;
}
case OSSA_DISCOVER_REMOVED_DEVICE:
{
TI_DBG3(("ossaDiscoverSasCB: REMOVED_DEVICE\n"));
agDevHandle = (agsaDevHandle_t *)pParm1;
agDeviceInfo = (agsaSASDeviceInfo_t *)pParm2;
oneDeviceData = (tdsaDeviceData_t *) agDevHandle->osData;
TI_DBG6(("ossaDiscoverSasCB: sasAddressHi 0x%08x\n",
SA_DEVINFO_GET_SAS_ADDRESSHI(&agDeviceInfo->commonDevInfo)));
TI_DBG6(("ossaDiscoverSasCB: sasAddressLo 0x%08x\n",
SA_DEVINFO_GET_SAS_ADDRESSLO(&agDeviceInfo->commonDevInfo)));
TI_DBG6(("ossaDiscoverSasCB: phys %d\n", agDeviceInfo->numOfPhys));
TI_DBG6(("ossaDiscoverSasCB: onePortContext->id %d\n", onePortContext->id));
if (oneDeviceData == agNULL)
{
TI_DBG1(("ossaDiscoverSasCB: Wrong. DevHandle->osData is NULL but is being removed\n"));
}
else
{
tdssRemoveSASFromSharedcontext(onePortContext,
oneDeviceData,
agRoot);
agDevHandle->osData = agNULL;
ostiInitiatorEvent(
tiRoot,
tiPortalContext,
agNULL,
tiIntrEventTypeDeviceChange,
tiDeviceRemoval,
agNULL
);
}
break;
}
case OSSA_DISCOVER_COMPLETE:
{
TI_DBG2(("ossaDiscoverSasCB: SAS COMPLETE pid %d\n", onePortContext->id));
#ifndef SATA_ENABLE
onePortContext->DiscoveryState = ITD_DSTATE_COMPLETED;
TI_DBG6(("ossaDiscoverSasCB: COMPLETE pid %d\n", onePortContext->id));
#endif
#ifdef SATA_ENABLE
TI_DBG2(("ossaDiscoverSasCB: calling SATA discovery\n"));
saDiscover(agRoot, agPortContext, AG_SA_DISCOVERY_TYPE_SATA,
onePortContext->discoveryOptions);
#else
#ifdef TD_INTERNAL_DEBUG
DeviceListList = tdsaAllShared->MainPortContextList.flink;
while (DeviceListList != &(tdsaAllShared->MainPortContextList))
{
oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
TI_DBG2(("ossaDiscoverSasCB: did %d valid %d\n", oneDeviceData->id, oneDeviceData->valid));
TI_DBG2(("ossaDiscoverSasCB: device AddrHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi));
TI_DBG2(("ossaDiscoverSasCB: device AddrLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo));
DeviceListList = DeviceListList->flink;
}
#endif
ostiInitiatorEvent(
tiRoot,
tiPortalContext,
agNULL,
tiIntrEventTypeDiscovery,
tiDiscOK,
agNULL
);
#endif
break;
}
case OSSA_DISCOVER_ABORT:
{
TI_DBG3(("ossaDiscoverSasCB: ABORT\n"));
ostiInitiatorEvent(
tiRoot,
tiPortalContext,
agNULL,
tiIntrEventTypeDiscovery,
tiDiscFailed,
agNULL
);
break;
}
case OSSA_DISCOVER_ABORT_ERROR_1:
{
TI_DBG3(("ossaDiscoverSasCB: ERROR 1\n"));
ostiInitiatorEvent(
tiRoot,
tiPortalContext,
agNULL,
tiIntrEventTypeDiscovery,
tiDiscFailed,
agNULL
);
break;
}
case OSSA_DISCOVER_ABORT_ERROR_2:
{
TI_DBG3(("ossaDiscoverSasCB: ERROR 2\n"));
ostiInitiatorEvent(
tiRoot,
tiPortalContext,
agNULL,
tiIntrEventTypeDiscovery,
tiDiscFailed,
agNULL
);
break;
}
case OSSA_DISCOVER_ABORT_ERROR_3:
{
TI_DBG3(("ossaDiscoverSasCB: ERROR 3\n"));
ostiInitiatorEvent(
tiRoot,
tiPortalContext,
agNULL,
tiIntrEventTypeDiscovery,
tiDiscFailed,
agNULL
);
break;
}
case OSSA_DISCOVER_ABORT_ERROR_4:
{
TI_DBG3(("ossaDiscoverSasCB: ERROR 4\n"));
ostiInitiatorEvent(
tiRoot,
tiPortalContext,
agNULL,
tiIntrEventTypeDiscovery,
tiDiscFailed,
agNULL
);
break;
}
case OSSA_DISCOVER_ABORT_ERROR_5:
{
TI_DBG3(("ossaDiscoverSasCB: ERROR 5\n"));
ostiInitiatorEvent(
tiRoot,
tiPortalContext,
agNULL,
tiIntrEventTypeDiscovery,
tiDiscFailed,
agNULL
);
break;
}
case OSSA_DISCOVER_ABORT_ERROR_6:
{
TI_DBG3(("ossaDiscoverSasCB: ERROR 6\n"));
ostiInitiatorEvent(
tiRoot,
tiPortalContext,
agNULL,
tiIntrEventTypeDiscovery,
tiDiscFailed,
agNULL
);
break;
}
case OSSA_DISCOVER_ABORT_ERROR_7:
{
TI_DBG3(("ossaDiscoverSasCB: ERROR 7\n"));
ostiInitiatorEvent(
tiRoot,
tiPortalContext,
agNULL,
tiIntrEventTypeDiscovery,
tiDiscFailed,
agNULL
);
break;
}
case OSSA_DISCOVER_ABORT_ERROR_8:
{
TI_DBG3(("ossaDiscoverSasCB: ERROR 8\n"));
ostiInitiatorEvent(
tiRoot,
tiPortalContext,
agNULL,
tiIntrEventTypeDiscovery,
tiDiscFailed,
agNULL
);
break;
}
case OSSA_DISCOVER_ABORT_ERROR_9:
{
TI_DBG3(("ossaDiscoverSasCB: ERROR 9\n"));
ostiInitiatorEvent(
tiRoot,
tiPortalContext,
agNULL,
tiIntrEventTypeDiscovery,
tiDiscFailed,
agNULL
);
break;
}
default:
TI_DBG3(("ossaDiscoverSasCB: ERROR default event 0x%x\n", event));
ostiInitiatorEvent(
tiRoot,
tiPortalContext,
agNULL,
tiIntrEventTypeDiscovery,
tiDiscFailed,
agNULL
);
break;
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Y1");
return;
}
#endif
osGLOBAL void ossaLogTrace0(
agsaRoot_t *agRoot,
bit32 traceCode
)
{
return;
}
osGLOBAL void ossaLogTrace1(
agsaRoot_t *agRoot,
bit32 traceCode,
bit32 value1
)
{
return;
}
osGLOBAL void ossaLogTrace2(
agsaRoot_t *agRoot,
bit32 traceCode,
bit32 value1,
bit32 value2
)
{
return;
}
osGLOBAL void ossaLogTrace3(
agsaRoot_t *agRoot,
bit32 traceCode,
bit32 value1,
bit32 value2,
bit32 value3
)
{
return;
}
osGLOBAL void
ossaLogTrace4(
agsaRoot_t *agRoot,
bit32 traceCode,
bit32 value1,
bit32 value2,
bit32 value3,
bit32 value4
)
{
return;
}
osGLOBAL void ossaHwCB(
agsaRoot_t *agRoot,
agsaPortContext_t *agPortContext,
bit32 event,
bit32 eventParm1,
void *eventParm2,
void *eventParm3
)
{
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
tdsaContext_t *tdsaAllShared = (tdsaContext_t *)osData->tdsaAllShared;
tdList_t *PortContextList = agNULL;
tdsaPortContext_t *onePortContext = agNULL;
agsaDevHandle_t *agDevHandle = agNULL;
agsaSASIdentify_t *IDframe = agNULL;
int i = 0;
#ifdef INITIATOR_DRIVER
tdsaSASSubID_t agSASSubID;
#endif
bit32 PhyID;
bit32 PhyStatus;
bit32 LinkRate;
bit32 PortState;
bit32 HwAckSatus = AGSA_RC_SUCCESS;
#ifdef INITIATOR_DRIVER
agsaFisRegDeviceToHost_t *RegD2H = agNULL;
tdsaDeviceData_t *oneDeviceData = agNULL;
tdList_t *DeviceListList;
#endif
#ifdef REMOVED
bit32 found = agFALSE;
#endif
agsaHWEventEncrypt_t *pEncryptCBData;
agsaEncryptInfo_t *pEncryptInfo;
agsaHWEventMode_t *pModeEvent;
tiEncryptPort_t encryptEventData;
tiEncryptInfo_t encryptInfo;
bit32 *pModePage;
bit32 securityMode;
bit32 cipherMode;
bit32 encryptStatus;
bit32 securitySetModeStatus;
bit32 securityModeStatus;
agsaPhyErrCountersPage_t *agPhyErrCountersPage;
agsaEventSource_t eventSource;
#ifdef FDS_DM
dmRoot_t *dmRoot = &(tdsaAllShared->dmRoot);
dmPortContext_t *dmPortContext = agNULL;
bit32 status = DM_RC_FAILURE;
dmPortInfo_t dmPortInfo;
#endif
smTraceFuncEnter(hpDBG_VERY_LOUD,"Y2");
TI_DBG2(("ossaHwCB: agPortContext %p event 0x%x eventParm1 0x%x eventParm2 %p eventParm3 %p\n",
agPortContext,event,eventParm1,eventParm2,eventParm3 ));
switch ( event )
{
case OSSA_HW_EVENT_SAS_PHY_UP:
{
PhyID = TD_GET_PHY_ID(eventParm1);
LinkRate = TD_GET_LINK_RATE(eventParm1);
PortState = TD_GET_PORT_STATE(eventParm1);
agDevHandle = agNULL;
IDframe = (agsaSASIdentify_t *)eventParm3;
TI_DBG2(("ossaHwCB: Phy%d SAS link Up\n", PhyID));
if (agPortContext == agNULL)
{
TI_DBG1(("ossaHwCB: agPortContext null, wrong\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Y2");
return;
}
if (agDevHandle == agNULL)
{
TI_DBG3(("ossaHwCB: agDevHandle null by design change\n"));
}
if (IDframe == agNULL)
{
TI_DBG1(("ossaHwCB: IDframe null, wrong\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "Y2");
return;
}
if (LinkRate == 0x01)
{
TI_DBG1(("ossaHwCB: SAS Link Rate is 1.5 Gbps PhyID %d\n",PhyID));
}
if (LinkRate == 0x02)
{
TI_DBG1(("ossaHwCB: SAS Link Rate is 3.0 Gbps PhyID %d\n",PhyID));
}
if (LinkRate == 0x04)
{
TI_DBG1(("ossaHwCB: SAS Link Rate is 6.0 Gbps PhyID %d\n",PhyID));
}
if (LinkRate == 0x08)
{
TI_DBG1(("ossaHwCB: SAS Link Rate is 12.0 Gbps PhyID %d\n",PhyID));
}
if (PortState == OSSA_PORT_INVALID)
{
TI_DBG1(("ossaHwCB: Wrong port state with SAS link up\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "Y2");
return;
}
if ( agPortContext->osData == agNULL)
{
TI_DBG6 (("ossaHwCB: PhyID %d tdsaAllShared %p\n", PhyID, tdsaAllShared));
if (tdsaAllShared->Ports[PhyID].tiPortalContext == agNULL)
{
TI_DBG6(("ossaHwCB: NULL portalcontext\n"));
}
else
{
TI_DBG6(("ossaHwCB: NOT NULL portalcontext\n"));
}
if (IDframe == agNULL)
{
TI_DBG1(("ossaHwCB: IDFrame is NULL; SATA !!!!\n"));
}
else
{
TI_DBG3(("ossaHwCB: IDframe->sasAddressHi 0x%08x \n",
SA_IDFRM_GET_SAS_ADDRESSHI(IDframe)));
TI_DBG3(("ossaHwCB: IDframe->sasAddressLo 0x%08x \n",
SA_IDFRM_GET_SAS_ADDRESSLO(IDframe)));
}
tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK);
if (TDLIST_NOT_EMPTY(&(tdsaAllShared->FreePortContextList)))
{
TDLIST_DEQUEUE_FROM_HEAD(&PortContextList, &(tdsaAllShared->FreePortContextList));
tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
onePortContext = TDLIST_OBJECT_BASE(tdsaPortContext_t, FreeLink, PortContextList);
TI_DBG2(("ossaHwCB: pid %d\n", onePortContext->id));
TI_DBG6(("ossaHwCB: onePortContext %p\n", onePortContext));
if (onePortContext == agNULL)
{
TI_DBG1(("ossaHwCB: onePortContext is NULL in allocation, wrong!\n"));
return;
}
#ifdef INITIATOR_DRIVER
onePortContext->DiscoveryState = ITD_DSTATE_NOT_STARTED;
onePortContext->discoveryOptions = AG_SA_DISCOVERY_OPTION_FULL_START;
#endif
onePortContext->PhyIDList[PhyID] = agTRUE;
if (IDframe == agNULL)
{
onePortContext->sasRemoteAddressHi = 0xFFFFFFFF;
onePortContext->sasRemoteAddressLo = 0xFFFFFFFF;
onePortContext->directAttatchedSAS = agTRUE;
}
else
{
onePortContext->sasRemoteAddressHi = SA_IDFRM_GET_SAS_ADDRESSHI(IDframe);
onePortContext->sasRemoteAddressLo = SA_IDFRM_GET_SAS_ADDRESSLO(IDframe);
osti_memcpy(&onePortContext->sasIDframe, IDframe, sizeof(agsaSASIdentify_t));
tdhexdump("ossaHWCB: sasIDframe", (bit8 *)(&onePortContext->sasIDframe), sizeof(agsaSASIdentify_t));
if (SA_IDFRM_GET_DEVICETTYPE(IDframe) == SAS_END_DEVICE)
{
onePortContext->directAttatchedSAS = agTRUE;
}
#ifdef FDS_DM
if (SA_IDFRM_GET_DEVICETTYPE(IDframe) == SAS_EDGE_EXPANDER_DEVICE ||
SA_IDFRM_GET_DEVICETTYPE(IDframe) == SAS_FANOUT_EXPANDER_DEVICE
)
{
onePortContext->UseDM = agTRUE;
}
#endif
}
onePortContext->sasLocalAddressHi = SA_IDFRM_GET_SAS_ADDRESSHI(&tdsaAllShared->Ports[PhyID].SASID);
onePortContext->sasLocalAddressLo = SA_IDFRM_GET_SAS_ADDRESSLO(&tdsaAllShared->Ports[PhyID].SASID);
onePortContext->tiPortalContext = tdsaAllShared->Ports[PhyID].tiPortalContext;
onePortContext->agRoot = agRoot;
onePortContext->agPortContext = agPortContext;
tdsaAllShared->Ports[PhyID].portContext = onePortContext;
agPortContext->osData = onePortContext;
onePortContext->valid = agTRUE;
if (LinkRate == 0x01)
{
onePortContext->LinkRate = SAS_CONNECTION_RATE_1_5G;
}
else if (LinkRate == 0x02)
{
onePortContext->LinkRate = SAS_CONNECTION_RATE_3_0G;
}
else if (LinkRate == 0x04)
{
onePortContext->LinkRate = SAS_CONNECTION_RATE_6_0G;
}
else
{
onePortContext->LinkRate = SAS_CONNECTION_RATE_12_0G;
}
tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK);
TDLIST_ENQUEUE_AT_TAIL(&(onePortContext->MainLink), &(tdsaAllShared->MainPortContextList));
tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
#ifdef FDS_DM
dmPortContext = &(onePortContext->dmPortContext);
dmPortContext->tdData = onePortContext;
PORTINFO_PUT_SAS_REMOTE_ADDRESSLO(&dmPortInfo, onePortContext->sasRemoteAddressLo);
PORTINFO_PUT_SAS_REMOTE_ADDRESSHI(&dmPortInfo, onePortContext->sasRemoteAddressHi);
PORTINFO_PUT_SAS_LOCAL_ADDRESSLO(&dmPortInfo, onePortContext->sasLocalAddressLo);
PORTINFO_PUT_SAS_LOCAL_ADDRESSHI(&dmPortInfo, onePortContext->sasLocalAddressHi);
TI_DBG2(("ossaHwCB: phy %d hi 0x%x lo 0x%x\n", PhyID,
SA_IDFRM_GET_SAS_ADDRESSHI(&(tdsaAllShared->Ports[PhyID].SASID)),
SA_IDFRM_GET_SAS_ADDRESSLO(&(tdsaAllShared->Ports[PhyID].SASID))));
TI_DBG2(("ossaHwCB: LocalAddrHi 0x%08x LocaAddrLo 0x%08x\n", onePortContext->sasLocalAddressHi, onePortContext->sasLocalAddressLo));
dmPortInfo.flag = onePortContext->LinkRate;
if (onePortContext->UseDM == agTRUE)
{
TI_DBG1(("ossaHwCB: calling dmCreatePort\n"));
status = dmCreatePort(dmRoot, dmPortContext, &dmPortInfo);
if (status != DM_RC_SUCCESS)
{
TI_DBG1(("ossaHwCB: dmCreatePort failed!!! 0x%x\n", status));
}
}
#endif
}
else
{
tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
TI_DBG1(("\nossaHwCB: Attention!!! no more free PortContext.\n"));
}
#ifdef TD_INTERNAL_DEBUG
print_tdlist_flink(&(tdsaPortContext->FreeLink), 1, 1);
print_tdlist_flink(&(tdsaPortContext->MainLink), 1, 2);
print_tdlist_flink(&(tdsaDeviceData->FreeLink), 2, 1);
print_tdlist_flink(&(tdsaDeviceData->MainLink), 2, 2);
#endif
#ifdef TD_INTERNAL_DEBUG
PortContextList = tdsaPortContext->MainLink.flink;
while (PortContextList != &(tdsaPortContext->MainLink))
{
twoPortContext = TDLIST_OBJECT_BASE(tdsaPortContext_t, MainLink, PortContextList);
TI_DBG6(("ossaHwCB: in while portContext ID %d\n", twoPortContext->id));
TI_DBG6(("ossaHwCB: in while PortContext %p\n", twoPortContext));
PortContextList = PortContextList->flink;
}
#endif
if (SA_IDFRM_GET_DEVICETTYPE(IDframe) != SAS_NO_DEVICE)
{
#ifdef INITIATOR_DRIVER
agSASSubID.sasAddressHi = SA_IDFRM_GET_SAS_ADDRESSHI(IDframe);
agSASSubID.sasAddressLo = SA_IDFRM_GET_SAS_ADDRESSLO(IDframe);
agSASSubID.initiator_ssp_stp_smp = IDframe->initiator_ssp_stp_smp;
agSASSubID.target_ssp_stp_smp = IDframe->target_ssp_stp_smp;
#endif
TI_DBG2(("ossaHwCB: adding ....\n"));
#ifdef INITIATOR_DRIVER
tdssAddSASToSharedcontext(
onePortContext,
agRoot,
agDevHandle,
&agSASSubID,
agTRUE,
(bit8)PhyID,
TD_OPERATION_INITIATOR
);
#endif
#ifdef FDS_DM
if (SA_IDFRM_GET_DEVICETTYPE(IDframe) == SAS_END_DEVICE &&
SA_IDFRM_IS_SSP_TARGET(IDframe) )
{
TI_DBG2(("ossaHwCB: NOTIFY_ENABLE_SPINUP PhyID %d \n", PhyID));
for (i=0;i<TD_MAX_NUM_NOTIFY_SPINUP;i++)
{
saLocalPhyControl(agRoot, agNULL, 0, PhyID, AGSA_PHY_NOTIFY_ENABLE_SPINUP, agNULL);
}
}
tdsaUpdateMCN(dmRoot, onePortContext);
#endif
#ifdef TARGET_DRIVER
TI_DBG1(("ossaHwCB: target, link up PhyID 0x%x\n",PhyID));
ostiPortEvent (
tiRoot,
tiPortLinkUp,
tiSuccess,
(void *)tdsaAllShared->Ports[PhyID].tiPortalContext
);
#endif
}
else
{
TI_DBG5(("ossaHwCB: $$$$$ not end device. not adding....\n"));
}
saPortControl(agRoot,
agNULL,
0,
agPortContext,
AGSA_PORT_SET_PORT_RECOVERY_TIME,
tdsaAllShared->portTMO,
0
);
if (tIsSPCV12G(agRoot))
{
saPortControl(agRoot,
agNULL,
0,
agPortContext,
AGSA_PORT_SET_PORT_RESET_TIME,
SAS_12G_PORT_RESET_TMO,
0
);
}
else
{
saPortControl(agRoot,
agNULL,
0,
agPortContext,
AGSA_PORT_SET_PORT_RESET_TIME,
SAS_PORT_RESET_TMO,
0
);
}
}
else
{
TI_DBG2(("ossaHwCB: SAS existing portcontext returned\n"));
onePortContext = (tdsaPortContext_t *)agPortContext->osData;
if (onePortContext == agNULL)
{
TI_DBG1(("ossaHwCB: onePortContext is NULL, wrong!\n"));
return;
}
if (onePortContext->valid == agFALSE)
{
TI_DBG2(("ossaHwCB: SAS allocating port context\n"));
tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK);
if (TDLIST_NOT_EMPTY(&(tdsaAllShared->FreePortContextList)))
{
TDLIST_DEQUEUE_FROM_HEAD(&PortContextList, &(tdsaAllShared->FreePortContextList));
tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
onePortContext = TDLIST_OBJECT_BASE(tdsaPortContext_t, FreeLink, PortContextList);
TI_DBG2(("ossaHwCB: allocating pid %d\n", onePortContext->id));
TI_DBG6(("ossaHwCB: allocating onePortContext %p\n", onePortContext));
if (onePortContext == agNULL)
{
TI_DBG1(("ossaHwCB: onePortContext is NULL in allocation, wrong!\n"));
return;
}
#ifdef INITIATOR_DRIVER
onePortContext->DiscoveryState = ITD_DSTATE_NOT_STARTED;
onePortContext->discoveryOptions = AG_SA_DISCOVERY_OPTION_FULL_START;
#endif
onePortContext->PhyIDList[PhyID] = agTRUE;
if (IDframe == agNULL)
{
onePortContext->sasRemoteAddressHi = 0xFFFFFFFF;
onePortContext->sasRemoteAddressLo = 0xFFFFFFFF;
onePortContext->directAttatchedSAS = agTRUE;
}
else
{
onePortContext->sasRemoteAddressHi = SA_IDFRM_GET_SAS_ADDRESSHI(IDframe);
onePortContext->sasRemoteAddressLo = SA_IDFRM_GET_SAS_ADDRESSLO(IDframe);
osti_memcpy(&onePortContext->sasIDframe, IDframe, sizeof(agsaSASIdentify_t));
tdhexdump("ossaHWCB: sasIDframe", (bit8 *)(&onePortContext->sasIDframe), sizeof(agsaSASIdentify_t));
if (SA_IDFRM_GET_DEVICETTYPE(IDframe) == SAS_END_DEVICE)
{
onePortContext->directAttatchedSAS = agTRUE;
}
}
onePortContext->sasLocalAddressHi = SA_IDFRM_GET_SAS_ADDRESSHI(&tdsaAllShared->Ports[PhyID].SASID);
onePortContext->sasLocalAddressLo = SA_IDFRM_GET_SAS_ADDRESSLO(&tdsaAllShared->Ports[PhyID].SASID);
onePortContext->tiPortalContext = tdsaAllShared->Ports[PhyID].tiPortalContext;
onePortContext->agRoot = agRoot;
onePortContext->agPortContext = agPortContext;
tdsaAllShared->Ports[PhyID].portContext = onePortContext;
agPortContext->osData = onePortContext;
onePortContext->valid = agTRUE;
if (LinkRate == 0x01)
{
onePortContext->LinkRate = SAS_CONNECTION_RATE_1_5G;
}
else if (LinkRate == 0x02)
{
onePortContext->LinkRate = SAS_CONNECTION_RATE_3_0G;
}
else if (LinkRate == 0x04)
{
onePortContext->LinkRate = SAS_CONNECTION_RATE_6_0G;
}
else
{
onePortContext->LinkRate = SAS_CONNECTION_RATE_12_0G;
}
tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK);
TDLIST_ENQUEUE_AT_TAIL(&(onePortContext->MainLink), &(tdsaAllShared->MainPortContextList));
tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
}
else
{
tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
TI_DBG1(("\nossaHwCB: Attention!!! no more free PortContext.\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'd', "Y2");
return;
}
}
else
{
TI_DBG2(("ossaHwCB: SAS already allocated port context\n"));
if (TDLIST_EMPTY(&(tdsaAllShared->MainPortContextList)))
{
TI_DBG1(("ossaHwCB: wrong!!! null tdsaPortContext list\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'e', "Y2");
return;
}
if (onePortContext == agNULL)
{
TI_DBG1(("ossaHwCB: wrong !!! No corressponding tdsaPortContext\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'f', "Y2");
return;
}
TI_DBG2(("ossaHwCB: existing pid %d\n", onePortContext->id));
if (tdsaAllShared->Ports[PhyID].portContext == agNULL)
{
TI_DBG1(("ossaHwCB: existing allshared pid is NULL\n"));
}
else
{
TI_DBG2(("ossaHwCB: existing allshared pid %d\n", tdsaAllShared->Ports[PhyID].portContext->id));
}
onePortContext->PhyIDList[PhyID] = agTRUE;
#ifdef FDS_DM
if (SA_IDFRM_GET_DEVICETTYPE(IDframe) == SAS_END_DEVICE &&
SA_IDFRM_IS_SSP_TARGET(IDframe) )
{
TI_DBG2(("ossaHwCB: NOTIFY_ENABLE_SPINUP PhyID %d \n", PhyID));
for (i=0;i<TD_MAX_NUM_NOTIFY_SPINUP;i++)
{
saLocalPhyControl(agRoot, agNULL, 0, PhyID, AGSA_PHY_NOTIFY_ENABLE_SPINUP, agNULL);
}
}
tdsaUpdateMCN(dmRoot, onePortContext);
#endif
}
onePortContext->SeenLinkUp = agTRUE;
}
break;
}
#ifdef INITIATOR_DRIVER
case OSSA_HW_EVENT_SATA_PHY_UP:
{
PhyID = TD_GET_PHY_ID(eventParm1);
LinkRate = TD_GET_LINK_RATE(eventParm1);
PortState = TD_GET_PORT_STATE(eventParm1);
agDevHandle = agNULL;
RegD2H = ( agsaFisRegDeviceToHost_t *)eventParm3;
TI_DBG2(("ossaHwCB: Phy%d SATA link Up\n", PhyID));
if (agDevHandle == agNULL)
{
TI_DBG3(("ossaHwCB: agDevHandle null by design change\n"));
}
if (RegD2H == agNULL)
{
TI_DBG1(("ossaHwCB: RegD2H null, wrong\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'g', "Y2");
return;
}
TI_DBG2(("ossaHwCB: agDevHandle %p\n", agDevHandle));
tdhexdump("ossaHWCB RegD2H", (bit8 *)RegD2H, sizeof(agsaFisRegDeviceToHost_t));
TI_DBG2(("ossaHwCB: Sector Count %d\n", RegD2H->d.sectorCount));
TI_DBG2(("ossaHwCB: LBA LOW %d\n", RegD2H->d.lbaLow));
TI_DBG2(("ossaHwCB: LBA MID %d\n", RegD2H->d.lbaMid));
TI_DBG2(("ossaHwCB: LBA HIGH %d\n", RegD2H->d.lbaHigh));
TI_DBG2(("ossaHwCB: DEVICE %d\n", RegD2H->d.device));
if (LinkRate == 0x01)
{
TI_DBG1(("ossaHwCB: SATA Link Rate is 1.5 Gbps PhyID %d\n",PhyID));
}
if (LinkRate == 0x02)
{
TI_DBG1(("ossaHwCB: SATA Link Rate is 3.0 Gbps PhyID %d\n",PhyID));
}
if (LinkRate == 0x04)
{
TI_DBG1(("ossaHwCB: SATA Link Rate is 6.0 Gbps PhyID %d\n",PhyID));
}
if (LinkRate == 0x08)
{
TI_DBG1(("ossaHwCB: SATA Link Rate is 12.0 Gbps PhyID %d\n",PhyID));
}
if (PortState == OSSA_PORT_INVALID)
{
TI_DBG1(("ossaHwCB: Wrong port state with SATA link up\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'h', "Y2");
return;
}
if ( agPortContext->osData == agNULL)
{
TI_DBG6 (("ossaHwCB: PhyID %d tdsaAllShared %p\n", PhyID, tdsaAllShared));
tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK);
if (TDLIST_NOT_EMPTY(&(tdsaAllShared->FreePortContextList)))
{
TDLIST_DEQUEUE_FROM_HEAD(&PortContextList, &(tdsaAllShared->FreePortContextList));
tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
onePortContext = TDLIST_OBJECT_BASE(tdsaPortContext_t, FreeLink, PortContextList);
TI_DBG2(("ossaHwCB: pid %d\n", onePortContext->id));
TI_DBG6(("ossaHwCB: onePortContext %p\n", onePortContext));
if (onePortContext == agNULL)
{
TI_DBG1(("ossaHwCB: onePortContext is NULL in allocation, wrong!\n"));
return;
}
onePortContext->DiscoveryState = ITD_DSTATE_NOT_STARTED;
onePortContext->discoveryOptions = AG_SA_DISCOVERY_OPTION_FULL_START;
onePortContext->PhyIDList[PhyID] = agTRUE;
onePortContext->sasRemoteAddressHi = 0xFFFFFFFF;
onePortContext->sasRemoteAddressLo = 0xFFFFFFFF;
onePortContext->remoteSignature[0] = RegD2H->d.sectorCount;
onePortContext->remoteSignature[1] = RegD2H->d.lbaLow;
onePortContext->remoteSignature[2] = RegD2H->d.lbaMid;
onePortContext->remoteSignature[3] = RegD2H->d.lbaHigh;
onePortContext->remoteSignature[4] = RegD2H->d.device;
onePortContext->sasLocalAddressHi = SA_IDFRM_GET_SAS_ADDRESSHI(&tdsaAllShared->Ports[PhyID].SASID);
onePortContext->sasLocalAddressLo = SA_IDFRM_GET_SAS_ADDRESSLO(&tdsaAllShared->Ports[PhyID].SASID);
onePortContext->tiPortalContext = tdsaAllShared->Ports[PhyID].tiPortalContext;
onePortContext->agRoot = agRoot;
onePortContext->agPortContext = agPortContext;
tdsaAllShared->Ports[PhyID].portContext = onePortContext;
agPortContext->osData = onePortContext;
onePortContext->nativeSATAMode = agTRUE;
onePortContext->valid = agTRUE;
if (LinkRate == 0x01)
{
onePortContext->LinkRate = SAS_CONNECTION_RATE_1_5G;
}
else if (LinkRate == 0x02)
{
onePortContext->LinkRate = SAS_CONNECTION_RATE_3_0G;
}
else if (LinkRate == 0x04)
{
onePortContext->LinkRate = SAS_CONNECTION_RATE_6_0G;
}
else
{
onePortContext->LinkRate = SAS_CONNECTION_RATE_12_0G;
}
tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK);
TDLIST_ENQUEUE_AT_TAIL(&(onePortContext->MainLink), &(tdsaAllShared->MainPortContextList));
tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
}
else
{
tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
TI_DBG1(("\nossaHwCB: Attention!!! no more free PortContext.\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'i', "Y2");
return;
}
#ifdef SATA_ENABLE
tdssAddSATAToSharedcontext(
onePortContext,
agRoot,
agDevHandle,
agNULL,
agTRUE,
(bit8)PhyID
);
#endif
saPortControl(agRoot,
agNULL,
0,
agPortContext,
AGSA_PORT_SET_PORT_RESET_TIME,
0,
SATA_PORT_RESET_TMO
);
}
else
{
TI_DBG1(("ossaHwCB: SATA existing portcontext returned. need testing\n"));
onePortContext = (tdsaPortContext_t *)agPortContext->osData;
if (onePortContext->valid == agFALSE)
{
TI_DBG2(("ossaHwCB: SATA allocating port context\n"));
}
else
{
TI_DBG1(("ossaHwCB: Wrong!!! SATA already allocated port context\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'j', "Y2");
return;
}
tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK);
if (TDLIST_NOT_EMPTY(&(tdsaAllShared->FreePortContextList)))
{
TDLIST_DEQUEUE_FROM_HEAD(&PortContextList, &(tdsaAllShared->FreePortContextList));
tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
onePortContext = TDLIST_OBJECT_BASE(tdsaPortContext_t, FreeLink, PortContextList);
TI_DBG2(("ossaHwCB: pid %d\n", onePortContext->id));
TI_DBG6(("ossaHwCB: onePortContext %p\n", onePortContext));
if (onePortContext == agNULL)
{
TI_DBG1(("ossaHwCB: onePortContext is NULL in allocation, wrong!\n"));
return;
}
onePortContext->DiscoveryState = ITD_DSTATE_NOT_STARTED;
onePortContext->discoveryOptions = AG_SA_DISCOVERY_OPTION_FULL_START;
onePortContext->PhyIDList[PhyID] = agTRUE;
onePortContext->sasRemoteAddressHi = 0xFFFFFFFF;
onePortContext->sasRemoteAddressLo = 0xFFFFFFFF;
onePortContext->remoteSignature[0] = RegD2H->d.sectorCount;
onePortContext->remoteSignature[1] = RegD2H->d.lbaLow;
onePortContext->remoteSignature[2] = RegD2H->d.lbaMid;
onePortContext->remoteSignature[3] = RegD2H->d.lbaHigh;
onePortContext->remoteSignature[4] = RegD2H->d.device;
onePortContext->sasLocalAddressHi = SA_IDFRM_GET_SAS_ADDRESSHI(&tdsaAllShared->Ports[PhyID].SASID);
onePortContext->sasLocalAddressLo = SA_IDFRM_GET_SAS_ADDRESSLO(&tdsaAllShared->Ports[PhyID].SASID);
onePortContext->tiPortalContext = tdsaAllShared->Ports[PhyID].tiPortalContext;
onePortContext->agRoot = agRoot;
onePortContext->agPortContext = agPortContext;
tdsaAllShared->Ports[PhyID].portContext = onePortContext;
agPortContext->osData = onePortContext;
onePortContext->nativeSATAMode = agTRUE;
onePortContext->valid = agTRUE;
if (LinkRate == 0x01)
{
onePortContext->LinkRate = SAS_CONNECTION_RATE_1_5G;
}
else if (LinkRate == 0x02)
{
onePortContext->LinkRate = SAS_CONNECTION_RATE_3_0G;
}
else if (LinkRate == 0x04)
{
onePortContext->LinkRate = SAS_CONNECTION_RATE_6_0G;
}
else
{
onePortContext->LinkRate = SAS_CONNECTION_RATE_12_0G;
}
tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK);
TDLIST_ENQUEUE_AT_TAIL(&(onePortContext->MainLink), &(tdsaAllShared->MainPortContextList));
tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
}
else
{
tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
TI_DBG1(("\nossaHwCB: Attention!!! no more free PortContext.\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'k', "Y2");
return;
}
#ifdef SATA_ENABLE
tdssAddSATAToSharedcontext(
onePortContext,
agRoot,
agDevHandle,
agNULL,
agTRUE,
(bit8)PhyID
);
#endif
}
break;
}
#endif
case OSSA_HW_EVENT_SATA_SPINUP_HOLD:
{
PhyID = TD_GET_PHY_ID(eventParm1);
TI_DBG2(("ossaHwCB: spinup hold PhyID %d\n", PhyID));
break;
}
case OSSA_HW_EVENT_PHY_DOWN:
{
bit32 AllPhyDown = agTRUE;
PhyID = TD_GET_PHY_ID(eventParm1);
LinkRate = TD_GET_LINK_RATE(eventParm1);
PortState = TD_GET_PORT_STATE(eventParm1);
TI_DBG2(("ossaHwCB: Phy%d link Down\n", PhyID));
if (agPortContext == agNULL)
{
TI_DBG1(("ossaHwCB: agPortContext null, wrong\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'l', "Y2");
return;
}
if ( agPortContext->osData == agNULL)
{
TI_DBG1(("ossaHwCB: NULL portalcontext. Error. Can't be NULL\n"));
}
else
{
TI_DBG3(("ossaHwCB: NOT NULL portalcontext\n"));
onePortContext = (tdsaPortContext_t *)agPortContext->osData;
if (onePortContext == agNULL)
{
TI_DBG1(("ossaHwCB: wrong !!! No corressponding tdsaPortContext\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'm', "Y2");
return;
}
onePortContext->PhyIDList[PhyID] = agFALSE;
for(i=0;i<TD_MAX_NUM_PHYS;i++)
{
if (onePortContext->PhyIDList[i] == agTRUE)
{
TI_DBG3(("ossaHwCB: Phy %d is still up\n", i));
AllPhyDown = agFALSE;
break;
}
}
if (AllPhyDown == agTRUE)
{
#ifdef NOT_YET
TI_DBG1(("ossaHwCB: calling tiPortLinkDown\n"));
ostiPortEvent (
tiRoot,
tiPortLinkDown,
tiSuccess,
(void *)onePortContext->tiPortalContext
);
#endif
}
if (PortState == OSSA_PORT_VALID)
{
#ifdef FDS_DM
tdsaUpdateMCN(dmRoot, onePortContext);
#endif
}
else if (PortState == OSSA_PORT_LOSTCOMM)
{
TI_DBG2(("ossaHwCB: phy Down and OSSA_PORT_LOSTCOMM\n"));
tdsaAllShared->eventSource[PhyID].EventValid = agTRUE;
tdsaAllShared->eventSource[PhyID].Source.agPortContext = agPortContext;
tdsaAllShared->eventSource[PhyID].Source.event = OSSA_HW_EVENT_PHY_DOWN;
tdsaAllShared->eventSource[PhyID].Source.param = PhyID;
onePortContext->eventPhyID = PhyID;
onePortContext->valid = agFALSE;
break;
}
else if (PortState == OSSA_PORT_IN_RESET)
{
TI_DBG2(("ossaHwCB: phy Down and OSSA_PORT_IN_RESET\n"));
tdsaAllShared->eventSource[PhyID].EventValid = agTRUE;
tdsaAllShared->eventSource[PhyID].Source.agPortContext = agPortContext;
tdsaAllShared->eventSource[PhyID].Source.event = OSSA_HW_EVENT_PHY_DOWN;
tdsaAllShared->eventSource[PhyID].Source.param = PhyID;
onePortContext->eventPhyID = PhyID;
onePortContext->valid = agFALSE;
break;
}
else if (PortState == OSSA_PORT_INVALID)
{
TI_DBG1(("ossaHwCB: Last phy Down and port invalid OSSA_PORT_INVALID\n"));
tdsaAllShared->eventSource[PhyID].EventValid = agTRUE;
tdsaAllShared->eventSource[PhyID].Source.agPortContext = agPortContext;
tdsaAllShared->eventSource[PhyID].Source.event = OSSA_HW_EVENT_PHY_DOWN;
tdsaAllShared->eventSource[PhyID].Source.param = PhyID;
onePortContext->eventPhyID = PhyID;
onePortContext->valid = agFALSE;
TI_DBG2(("ossaHwCB: pid %d\n", onePortContext->id));
#ifdef INITIATOR_DRIVER
ostiPortEvent(
tiRoot,
tiPortStopped,
tiSuccess,
(void *)onePortContext->tiPortalContext
);
#endif
#ifdef TARGET_DRIVER
ostiPortEvent(
tiRoot,
tiPortLinkDown,
tiSuccess,
(void *)onePortContext->tiPortalContext
);
#endif
#ifdef INITIATOR_DRIVER
tdssReportRemovals(agRoot,
onePortContext,
agFALSE
);
#endif
#ifdef TARGET_DRIVER
ttdssReportRemovals(agRoot,
onePortContext,
agFALSE
);
#endif
for(i=0;i<TD_MAX_NUM_PHYS;i++)
{
if (onePortContext->PhyIDList[i] == agTRUE)
{
tdsaAllShared->Ports[i].portContext = agNULL;
}
}
}
else
{
TI_DBG2(("ossaHwCB: portstate 0x%x\n", PortState));
}
}
break;
}
case OSSA_HW_EVENT_PHY_START_STATUS:
{
PhyID = TD_GET_PHY_ID(eventParm1);
PhyStatus = TD_GET_PHY_STATUS(eventParm1);
TI_DBG6(("ossaHwCB: OSSA_HW_EVENT_PHY_START_STATUS\n"));
if (PhyStatus == 0x00)
{
TI_DBG6(("ossaHwCB: OSSA_HW_EVENT_PHY_START_STATUS, SUCCESS\n"));
}
else if (PhyStatus == 0x01)
{
TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_START_STATUS, INVALID_PHY\n"));
}
else if (PhyStatus == 0x02)
{
TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_START_STATUS, PHY_NOT_DISABLED\n"));
}
else
{
TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_START_STATUS, OTHER_FAILURE %d\n", PhyStatus));
}
break;
}
case OSSA_HW_EVENT_PHY_STOP_STATUS:
{
agsaContext_t *agContext;
PhyID = TD_GET_PHY_ID(eventParm1);
PhyStatus = TD_GET_PHY_STATUS(eventParm1);
PortState = TD_GET_PORT_STATE(eventParm1);
TI_DBG2(("ossaHwCB: OSSA_HW_EVENT_PHY_STOP_STATUS\n"));
if (PhyStatus == 0x00)
{
TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_STOP_STATUS, SUCCESS\n"));
agContext = (agsaContext_t *)eventParm2;
onePortContext = (tdsaPortContext_t *)agContext->osData;
if (onePortContext == agNULL)
{
TI_DBG1(("ossaHwCB: onePortContext is null, wrong!!!\n"));
return;
}
onePortContext->PhyIDList[PhyID] = agFALSE;
if (PortState == OSSA_PORT_INVALID)
{
TI_DBG1(("ossaHwCB: OSSA_PORT_INVALID\n"));
tdsaAllShared->eventSource[PhyID].EventValid = NO_ACK;
onePortContext->eventPhyID = PhyID;
onePortContext->valid = agFALSE;
TI_DBG2(("ossaHwCB: pid %d\n", onePortContext->id));
#ifdef INITIATOR_DRIVER
ostiPortEvent(
tiRoot,
tiPortStopped,
tiSuccess,
(void *)onePortContext->tiPortalContext
);
#endif
#ifdef TARGET_DRIVER
ostiPortEvent(
tiRoot,
tiPortLinkDown,
tiSuccess,
(void *)onePortContext->tiPortalContext
);
#endif
#ifdef INITIATOR_DRIVER
tdssReportRemovals(agRoot,
onePortContext,
agFALSE
);
#endif
#ifdef TARGET_DRIVER
ttdssReportRemovals(agRoot,
onePortContext,
agFALSE
);
#endif
for(i=0;i<TD_MAX_NUM_PHYS;i++)
{
if (onePortContext->PhyIDList[i] == agTRUE)
{
tdsaAllShared->Ports[i].portContext = agNULL;
}
}
}
}
else if (PhyStatus == 0x01)
{
TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_STOP_STATUS, INVALID_PHY\n"));
}
else if (PhyStatus == 0x02)
{
TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_STOP_STATUS, DEVICES_ATTACHED\n"));
}
else if (PhyStatus == 0x03)
{
TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_STOP_STATUS, OTHER_FAILURE\n"));
}
else if (PhyStatus == 0x04)
{
TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_STOP_STATUS, PHY_NOT_DISABLED\n"));
}
else
{
TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_STOP_STATUS, Unknown %d\n", PhyStatus));
}
break;
}
case OSSA_HW_EVENT_RESET_START:
{
bit32 new_status = TD_GET_RESET_STATUS(eventParm1);
TI_DBG2(("ossaHwCB: RESET_START, status %d\n", new_status));
if (new_status == OSSA_SUCCESS)
{
tdsaAllShared->flags.resetInProgress = agTRUE;
TI_DBG2(("ossaHwCB: RESET_START, SUCCESS\n"));
}
else if (new_status == OSSA_FAILURE)
{
TI_DBG1(("ossaHwCB: RESET_START, FAILURE\n"));
}
else
{
TI_DBG1(("ossaHwCB: RESET_START, PENDING\n"));
}
break;
}
case OSSA_HW_EVENT_RESET_COMPLETE:
{
bit32 new_status = TD_GET_RESET_STATUS(eventParm1);
#ifdef SOFT_RESET_TEST
DbgPrint("Reset Complete\n");
#endif
TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_RESET_COMPLETE, status %d\n", new_status));
if (new_status == OSSA_SUCCESS)
{
#ifdef INITIATOR_DRIVER
tdssRemoveSASSATAFromSharedcontextByReset(agRoot);
#endif
tdsaAllShared->flags.resetInProgress = agFALSE;
ostiPortEvent(
tiRoot,
tiPortResetComplete,
tiSuccess,
agNULL
);
}
else
{
tdsaAllShared->flags.resetInProgress = agFALSE;
ostiPortEvent(
tiRoot,
tiPortResetComplete,
tiError,
agNULL
);
}
break;
}
case OSSA_HW_EVENT_PHY_ERR_INBOUND_CRC:
{
PhyID = TD_GET_PHY_ID(eventParm1);
PortState = TD_GET_PORT_STATE(eventParm1);
agPhyErrCountersPage = (agsaPhyErrCountersPage_t *)eventParm2;
TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_INBOUND_CRC from PhyID %d; to be tested\n", PhyID));
if (PortState == OSSA_PORT_INVALID)
{
TI_DBG1(("ossaHwCB: Wrong port state with OSSA_HW_EVENT_PHY_ERR_INBOUND_CRC\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'n', "Y2");
return;
}
if (agPhyErrCountersPage != agNULL)
{
TI_DBG2(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_INBOUND_CRC from PhyID %d\n", PhyID));
TI_DBG1(("ossaHwCB: iDw %d rDE %d cV %d lS %d rP %d iCRC %d\n",
agPhyErrCountersPage->invalidDword,
agPhyErrCountersPage->runningDisparityError,
agPhyErrCountersPage->codeViolation,
agPhyErrCountersPage->lossOfDwordSynch,
agPhyErrCountersPage->phyResetProblem,
agPhyErrCountersPage->inboundCRCError ));
}
else
{
TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_INBOUND_CRC: Error!!! eventParm2 is NULL\n"));
}
eventSource.agPortContext = agPortContext;
eventSource.event = OSSA_HW_EVENT_PHY_ERR_INBOUND_CRC;
eventSource.param = PhyID;
HwAckSatus = saHwEventAck(
agRoot,
agNULL,
0,
&eventSource,
0,
0
);
if ( HwAckSatus != AGSA_RC_SUCCESS)
{
TI_DBG1(("ossaHwCB: failing in saHwEventAck; status %d\n", HwAckSatus));
smTraceFuncExit(hpDBG_VERY_LOUD, 'o', "Y2");
return;
}
break;
}
#ifdef REMOVED
case OSSA_HW_EVENT_PORT_INVALID:
{
TI_DBG1(("ossaHwCB: PORT_INVALID\n"));
if ( agPortContext == agNULL)
{
TI_DBG1(("ossaHwCB: agPortContext is NULL, wrong.\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'p', "Y2");
return;
}
if ( agPortContext->osData != agNULL)
{
TI_DBG1(("ossaHwCB: NOT NULL osDATA\n"));
onePortContext = (tdsaPortContext_t *)agPortContext->osData;
TI_DBG1(("ossaHwCB: pid %d\n", onePortContext->id));
#ifdef INITIATOR_DRIVER
ostiPortEvent (
tiRoot,
tiPortStopped,
tiSuccess,
(void *)onePortContext->tiPortalContext
);
#endif
#ifdef TARGET_DRIVER
ostiPortEvent(
tiRoot,
tiPortLinkDown,
tiSuccess,
(void *)onePortContext->tiPortalContext
);
#endif
#ifdef INITIATOR_DRIVER
onePortContext->DiscoveryState = ITD_DSTATE_NOT_STARTED;
tdssReportRemovals(agRoot,
onePortContext,
agFALSE
);
onePortContext->discoveryOptions = AG_SA_DISCOVERY_OPTION_FULL_START;
onePortContext->DiscoveryRdyGiven = agFALSE;
onePortContext->SeenLinkUp = agFALSE;
#endif
for(i=0;i<TD_MAX_NUM_PHYS;i++)
{
if (onePortContext->PhyIDList[i] == agTRUE)
{
tdsaAllShared->Ports[i].portContext = agNULL;
}
}
for(i=0;i<TD_MAX_NUM_PHYS;i++)
{
onePortContext->PhyIDList[i] = agFALSE;
}
onePortContext->agPortContext = agNULL;
onePortContext->valid = agFALSE;
TI_DBG4(("ossaHwCB: pid %d count %d\n", onePortContext->id, onePortContext->Count));
onePortContext->Count = 0;
onePortContext->discovery.pendingSMP = 0;
onePortContext->discovery.SeenBC = agFALSE;
tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK);
TDLIST_DEQUEUE_THIS(&(onePortContext->MainLink));
TDLIST_ENQUEUE_AT_TAIL(&(onePortContext->FreeLink), &(tdsaPortContext->FreeLink));
tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
}
else
{
TI_DBG1(("ossaHwCB: NULL osDATA: wrong\n"));
}
TI_DBG6(("ossaHwCB: PORT_INVALID end\n"));
break;
}
#endif
case OSSA_HW_EVENT_BROADCAST_CHANGE:
{
PhyID = TD_GET_PHY_ID(eventParm1);
PortState = TD_GET_PORT_STATE(eventParm1);
TI_DBG1(("ossaHwCB: BROADCAST_CHANGE from PhyID %d\n", PhyID));
if (PortState == OSSA_PORT_INVALID)
{
TI_DBG1(("ossaHwCB: Wrong port state with BROADCAST_CHANGE\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'q', "Y2");
return;
}
eventSource.agPortContext = agPortContext;
eventSource.event = OSSA_HW_EVENT_BROADCAST_CHANGE;
eventSource.param = PhyID;
HwAckSatus = saHwEventAck(
agRoot,
agNULL,
0,
&eventSource,
0,
0
);
TI_DBG4(("ossaHwCB: calling saHwEventAck\n"));
if ( HwAckSatus != AGSA_RC_SUCCESS)
{
TI_DBG1(("ossaHwCB: failing in saHwEventAck; status %d\n", HwAckSatus));
smTraceFuncExit(hpDBG_VERY_LOUD, 'r', "Y2");
return;
}
if (tIsSPC12SATA(agRoot))
{
TI_DBG1(("ossaHwCB: BROADCAST_CHANGE received for SATA Controller\n"));
break;
}
#ifdef FDS_DM_NO
if (agPortContext == agNULL)
{
TI_DBG2(("ossaHwCB: agPortContext is NULL. Do nothing.\n"));
}
else if ( agPortContext->osData != agNULL)
{
dmRoot = &(tdsaAllShared->dmRoot);
onePortContext = (tdsaPortContext_t *)agPortContext->osData;
dmPortContext = &(onePortContext->dmPortContext);
dmQueryDiscovery(dmRoot, dmPortContext);
#if 1
if (onePortContext->DMDiscoveryState == dmDiscInProgress)
{
dmDiscover(dmRoot, dmPortContext, DM_DISCOVERY_OPTION_ABORT);
}
#endif
TI_DBG2(("ossaHwCB: portcontext pid %d\n", onePortContext->id));
if (onePortContext->DMDiscoveryState == dmDiscCompleted ||
onePortContext->DMDiscoveryState == dmDiscAborted ||
onePortContext->DMDiscoveryState == dmDiscAbortInvalid )
{
TI_DBG1(("ossaHwCB: BROADCAST_CHANGE; calling dmNotifyBC and does incremental discovery\n"));
dmNotifyBC(dmRoot, dmPortContext, OSSA_HW_EVENT_BROADCAST_CHANGE);
dmDiscover(dmRoot, dmPortContext, DM_DISCOVERY_OPTION_INCREMENTAL_START);
}
else
{
TI_DBG2(("ossaHwCB: pid %d BROADCAST_CHANGE; updating SeenBC. calling dmNotifyBC\n", onePortContext->id));
dmNotifyBC(dmRoot, dmPortContext, OSSA_HW_EVENT_BROADCAST_CHANGE);
}
}
else
{
TI_DBG1(("ossaHwCB: BROADCAST_CHANGE NULL osDATA wrong !!! \n"));
}
#endif
#ifdef FDS_DM
if (agPortContext == agNULL)
{
TI_DBG2(("ossaHwCB: agPortContext is NULL. Do nothing.\n"));
}
else if ( agPortContext->osData != agNULL)
{
dmRoot = &(tdsaAllShared->dmRoot);
onePortContext = (tdsaPortContext_t *)agPortContext->osData;
dmPortContext = &(onePortContext->dmPortContext);
dmQueryDiscovery(dmRoot, dmPortContext);
TI_DBG2(("ossaHwCB: portcontext pid %d\n", onePortContext->id));
if (onePortContext->DMDiscoveryState == dmDiscCompleted ||
onePortContext->DMDiscoveryState == dmDiscAborted ||
onePortContext->DMDiscoveryState == dmDiscAbortInvalid )
{
TI_DBG1(("ossaHwCB: BROADCAST_CHANGE; calling dmNotifyBC and does incremental discovery, pid %d\n", onePortContext->id));
onePortContext->DiscoveryState = ITD_DSTATE_STARTED;
dmNotifyBC(dmRoot, dmPortContext, OSSA_HW_EVENT_BROADCAST_CHANGE);
dmDiscover(dmRoot, dmPortContext, DM_DISCOVERY_OPTION_INCREMENTAL_START);
}
else if (onePortContext->DMDiscoveryState == dmDiscFailed )
{
TI_DBG1(("ossaHwCB: dmDiscFailed; pid %d BROADCAST_CHANGE; updating SeenBC. calling dmNotifyBC\n", onePortContext->id));
onePortContext->DiscFailNSeenBC = agTRUE;
dmNotifyBC(dmRoot, dmPortContext, OSSA_HW_EVENT_BROADCAST_CHANGE);
}
else
{
TI_DBG2(("ossaHwCB: pid %d BROADCAST_CHANGE; updating SeenBC. calling dmNotifyBC\n", onePortContext->id));
dmNotifyBC(dmRoot, dmPortContext, OSSA_HW_EVENT_BROADCAST_CHANGE);
}
}
else
{
TI_DBG1(("ossaHwCB: BROADCAST_CHANGE NULL osDATA wrong !!! \n"));
}
#endif
#ifdef FDS_DM_WORKED
if (agPortContext == agNULL)
{
TI_DBG2(("ossaHwCB: agPortContext is NULL. Do nothing.\n"));
}
else if ( agPortContext->osData != agNULL)
{
onePortContext = (tdsaPortContext_t *)agPortContext->osData;
TI_DBG2(("ossaHwCB: calling dmNotifyBC\n"));
dmRoot = &(tdsaAllShared->dmRoot);
dmPortContext = &(onePortContext->dmPortContext);
dmNotifyBC(dmRoot, dmPortContext, OSSA_HW_EVENT_BROADCAST_CHANGE);
}
#endif
#ifndef FDS_DM
#ifdef INITIATOR_DRIVER
if (agPortContext == agNULL)
{
TI_DBG2(("ossaHwCB: agPortContext is NULL. Do nothing.\n"));
}
else if ( agPortContext->osData != agNULL)
{
onePortContext = (tdsaPortContext_t *)agPortContext->osData;
TI_DBG2(("ossaHwCB: portcontext pid %d\n", onePortContext->id));
if (onePortContext->DiscoveryState == ITD_DSTATE_COMPLETED)
{
TI_DBG1(("ossaHwCB: BROADCAST_CHANGE; does incremental discovery\n"));
onePortContext->DiscoveryState = ITD_DSTATE_NOT_STARTED;
onePortContext->discoveryOptions = AG_SA_DISCOVERY_OPTION_INCREMENTAL_START;
onePortContext->discovery.SeenBC = agFALSE;
#ifdef TD_DISCOVER
if (tdsaAllShared->ResetInDiscovery != 0 &&
onePortContext->discovery.ResetTriggerred == agTRUE)
{
TI_DBG2(("ossaHwCB: tdsaBCTimer\n"));
tdsaBCTimer(tiRoot, onePortContext);
}
else
{
tdsaDiscover(
tiRoot,
onePortContext,
TDSA_DISCOVERY_TYPE_SAS,
TDSA_DISCOVERY_OPTION_INCREMENTAL_START
);
}
#else
saDiscover(agRoot,
agPortContext,
AG_SA_DISCOVERY_TYPE_SAS,
onePortContext->discoveryOptions);
#endif
}
else
{
TI_DBG2(("ossaHwCB: pid %d BROADCAST_CHANGE; updating SeenBC. Do nothing.\n", onePortContext->id));
onePortContext->discovery.SeenBC = agTRUE;
}
}
else
{
TI_DBG1(("ossaHwCB: BROADCAST_CHANGE NULL osDATA wrong !!! \n"));
}
#endif
#endif
break;
}
case OSSA_HW_EVENT_PORT_RECOVERY_TIMER_TMO:
{
PhyID = TD_GET_PHY_ID(eventParm1);
PortState = TD_GET_PORT_STATE(eventParm1);
TI_DBG2(("ossaHwCB: OSSA_HW_EVENT_PORT_RECOVERY_TIMER_TMO\n"));
if (PortState == OSSA_PORT_VALID)
{
TI_DBG1(("ossaHwCB: Wrong port state\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 's', "Y2");
return;
}
TD_ASSERT(agPortContext, "agPortContext");
if ( agPortContext->osData == agNULL)
{
TI_DBG1(("ossaHwCB: NULL portalcontext. Error. Can't be NULL\n"));
}
else
{
onePortContext = (tdsaPortContext_t *)agPortContext->osData;
onePortContext->valid = agFALSE;
TI_DBG1(("ossaHwCB: tiPortStopped pid %d\n", onePortContext->id));
#ifdef INITIATOR_DRIVER
ostiPortEvent(
tiRoot,
tiPortStopped,
tiSuccess,
(void *)onePortContext->tiPortalContext
);
#endif
#ifdef TARGET_DRIVER
ostiPortEvent(
tiRoot,
tiPortLinkDown,
tiSuccess,
(void *)onePortContext->tiPortalContext
);
#endif
#ifdef INITIATOR_DRIVER
tdssReportRemovals(agRoot,
onePortContext,
agFALSE
);
#endif
#ifdef TARGET_DRIVER
ttdssReportRemovals(agRoot,
onePortContext,
agFALSE
);
#endif
for(i=0;i<TD_MAX_NUM_PHYS;i++)
{
if (onePortContext->PhyIDList[i] == agTRUE)
{
tdsaAllShared->Ports[i].portContext = agNULL;
}
}
}
break;
}
case OSSA_HW_EVENT_PORT_RESET_TIMER_TMO:
{
PhyID = TD_GET_PHY_ID(eventParm1);
PortState = TD_GET_PORT_STATE(eventParm1);
TI_DBG2(("ossaHwCB: OSSA_HW_EVENT_PORT_RESET_TIMER_TMO\n"));
if (PortState == OSSA_PORT_VALID)
{
TI_DBG1(("ossaHwCB: Wrong port state\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 't', "Y2");
return;
}
if (agPortContext == agNULL)
{
TI_DBG1(("ossaHwCB: agPortContext is NULL, error\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'u', "Y2");
return;
}
if ( agPortContext->osData == agNULL)
{
TI_DBG1(("ossaHwCB: NULL portalcontext. Error. Can't be NULL\n"));
}
else
{
onePortContext = (tdsaPortContext_t *)agPortContext->osData;
onePortContext->valid = agFALSE;
TI_DBG1(("ossaHwCB: pid %d tiPortStopped\n", onePortContext->id));
#ifdef INITIATOR_DRIVER
ostiPortEvent(
tiRoot,
tiPortStopped,
tiSuccess,
(void *)onePortContext->tiPortalContext
);
#endif
#ifdef TARGET_DRIVER
ostiPortEvent(
tiRoot,
tiPortLinkDown,
tiSuccess,
(void *)onePortContext->tiPortalContext
);
#endif
#ifdef INITIATOR_DRIVER
tdssReportRemovals(agRoot,
onePortContext,
agFALSE
);
#endif
#ifdef TARGET_DRIVER
ttdssReportRemovals(agRoot,
onePortContext,
agFALSE
);
#endif
for(i=0;i<TD_MAX_NUM_PHYS;i++)
{
if (onePortContext->PhyIDList[i] == agTRUE)
{
tdsaAllShared->Ports[i].portContext = agNULL;
}
}
}
break;
}
case OSSA_HW_EVENT_PORT_RESET_COMPLETE:
{
#ifdef INITIATOR_DRIVER
tiIORequest_t *currentTaskTag = agNULL;
#endif
#ifdef REMOVED
smRoot_t *smRoot = &(tdsaAllShared->smRoot);
#endif
PhyID = TD_GET_PHY_ID(eventParm1);
PortState = TD_GET_PORT_STATE(eventParm1);
IDframe = (agsaSASIdentify_t *)eventParm3;
TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PORT_RESET_COMPLETE, phyID %d\n", PhyID));
if (PortState == OSSA_PORT_INVALID)
{
TI_DBG1(("ossaHwCB: Wrong port state\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'v', "Y2");
return;
}
if (agPortContext == agNULL)
{
TI_DBG1(("ossaHwCB: agPortContext null, wrong\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'w', "Y2");
return;
}
if ( agPortContext->osData == agNULL)
{
TI_DBG1(("ossaHwCB: agPortContext->osData null, wrong\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'x', "Y2");
return;
}
onePortContext = (tdsaPortContext_t *)agPortContext->osData;
if (onePortContext == agNULL)
{
TI_DBG1(("ossaHwCB: oneportContext is NULL; wrong??????\n"));
}
else
{
TI_DBG1(("ossaHwCB: oneportContext %p pid %d\n", onePortContext, onePortContext->id));
onePortContext->valid = agTRUE;
#ifdef INITIATOR_DRIVER
#ifdef REMOVED
if (tdsaAllShared->ResetInDiscovery != 0)
{
DeviceListList = tdsaAllShared->MainDeviceList.flink;
while (DeviceListList != &(tdsaAllShared->MainDeviceList))
{
oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
if (oneDeviceData->tdPortContext != onePortContext)
{
DeviceListList = DeviceListList->flink;
}
else
{
found = agTRUE;
break;
}
}
if (found == agTRUE)
{
if (DEVICE_IS_SATA_DEVICE(oneDeviceData) || DEVICE_IS_STP_TARGET(oneDeviceData))
{
#ifdef FDS_SM
tdIDStart(tiRoot, agRoot, smRoot, oneDeviceData, onePortContext);
#else
tdssRetrySATAID(tiRoot, oneDeviceData);
#endif
}
}
else
{
TI_DBG1(("ossaHwCB: no onedevicedata found!\n"));
}
}
#endif
DeviceListList = tdsaAllShared->MainDeviceList.flink;
while (DeviceListList != &(tdsaAllShared->MainDeviceList))
{
oneDeviceData = TDLIST_OBJECT_BASE(tdsaDeviceData_t, MainLink, DeviceListList);
if ( oneDeviceData == agNULL)
{
TI_DBG1(("ossaHwCB: oneDeviceData is NULL!!!\n"));
return;
}
if ( (oneDeviceData->tdPortContext == onePortContext) &&
(oneDeviceData->directlyAttached == agTRUE) &&
(oneDeviceData->phyID == PhyID) )
{
TI_DBG1(("ossaHwCB: found the onePortContext and oneDeviceData!!\n"));
currentTaskTag = (tiIORequest_t *)oneDeviceData->agDeviceResetContext.osData;
if (currentTaskTag != agNULL )
{
if (DEVICE_IS_SATA_DEVICE(oneDeviceData))
{
tdIORequestBody_t *SMTMtdIORequestBody = agNULL;
SMTMtdIORequestBody = (tdIORequestBody_t *)currentTaskTag->tdData;
if (SMTMtdIORequestBody != agNULL)
{
ostiFreeMemory(
tiRoot,
SMTMtdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
}
else
{
TI_DBG1(("ossaHwCB: SATA device but SMTMtdIORequestBody is NULL!!!\n"));
}
}
saSetDeviceState(agRoot,
agNULL,
tdsaRotateQnumber(tiRoot, oneDeviceData),
oneDeviceData->agDevHandle,
SA_DS_OPERATIONAL
);
ostiInitiatorEvent(tiRoot,
agNULL,
agNULL,
tiIntrEventTypeTaskManagement,
tiTMOK,
currentTaskTag
);
}
else
{
TI_DBG1(("ossaHwCB: currentTaskTag is NULL!!!\n"));
}
break;
}
else
{
DeviceListList = DeviceListList->flink;
}
}
#endif
}
break;
}
case OSSA_HW_EVENT_BROADCAST_ASYNCH_EVENT:
{
PhyID = TD_GET_PHY_ID(eventParm1);
PortState = TD_GET_PORT_STATE(eventParm1);
TI_DBG2(("ossaHwCB: OSSA_HW_EVENT_BROADCAST_ASYNCH_EVENT\n"));
if (tIsSPC12SATA(agRoot))
{
TI_DBG1(("ossaHwCB: BROADCAST_ASYNCH_EVENT received for SATA Controller\n"));
break;
}
if (agPortContext == agNULL)
{
TI_DBG1(("ossaHwCB: Error!!! agPortContext is NULL %d\n", PhyID));
smTraceFuncExit(hpDBG_VERY_LOUD, 'y', "Y2");
return;
}
onePortContext = (tdsaPortContext_t *)agPortContext->osData;
if (onePortContext == agNULL)
{
TI_DBG1(("ossaHwCB: Error!!! onePortContext is NULL %d\n", PhyID));
smTraceFuncExit(hpDBG_VERY_LOUD, 'z', "Y2");
return;
}
if (onePortContext->tiPortalContext != agNULL)
{
#if 0
ostiInitiatorEvent(
tiRoot,
onePortContext->tiPortalContext,
agNULL,
tiIntrEventTypeDeviceChange,
OSSA_HW_EVENT_BROADCAST_ASYNCH_EVENT,
agNULL
);
#endif
}
else
{
TI_DBG1(("ossaHwCB: Error!!! onePortContext->tiPortalContext is NULL\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'A', "Y2");
return;
}
break;
}
case OSSA_HW_EVENT_PORT_RECOVER:
{
PhyID = TD_GET_PHY_ID(eventParm1);
if (agPortContext == agNULL)
{
TI_DBG1(("ossaHwCB: Error!!! agPortContext is NULL %d\n", PhyID));
smTraceFuncExit(hpDBG_VERY_LOUD, 'B', "Y2");
return;
}
LinkRate = TD_GET_LINK_RATE(eventParm1);
PortState = TD_GET_PORT_STATE(eventParm1);
agDevHandle = agNULL;
IDframe = (agsaSASIdentify_t *)eventParm3;
TI_DBG2(("ossaHwCB: OSSA_HW_EVENT_PORT_RECOVER, phyID %d\n", PhyID));
if (PortState == OSSA_PORT_INVALID)
{
TI_DBG1(("ossaHwCB: Wrong port state\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'C', "Y2");
return;
}
if ( agPortContext->osData == agNULL)
{
TI_DBG1(("ossaHwCB: NULL portalcontext. Error. Can't be NULL\n"));
}
else
{
onePortContext = (tdsaPortContext_t *)agPortContext->osData;
TI_DBG2(("ossaHwCB: pid %d\n", onePortContext->id));
onePortContext->PhyIDList[PhyID] = agTRUE;
onePortContext->valid = agTRUE;
tdsaAllShared->Ports[PhyID].portContext = onePortContext;
onePortContext->tiPortalContext = tdsaAllShared->Ports[PhyID].tiPortalContext;
onePortContext->PortRecoverPhyID = PhyID;
if (LinkRate == 0x01)
{
onePortContext->LinkRate = SAS_CONNECTION_RATE_1_5G;
}
else if (LinkRate == 0x02)
{
onePortContext->LinkRate = SAS_CONNECTION_RATE_3_0G;
}
else if (LinkRate == 0x04)
{
onePortContext->LinkRate = SAS_CONNECTION_RATE_6_0G;
}
else
{
onePortContext->LinkRate = SAS_CONNECTION_RATE_12_0G;
}
if (SA_IDFRM_GET_DEVICETTYPE(&onePortContext->sasIDframe) == SAS_END_DEVICE &&
SA_IDFRM_IS_SSP_TARGET(&onePortContext->sasIDframe) )
{
TI_DBG2(("ossaHwCB: OSSA_HW_EVENT_PORT_RECOVER, sending spinup on phyID %d\n", PhyID));
for (i=0;i<TD_MAX_NUM_NOTIFY_SPINUP;i++)
{
saLocalPhyControl(agRoot, agNULL, 0, PhyID, AGSA_PHY_NOTIFY_ENABLE_SPINUP, agNULL);
}
}
if (onePortContext->Transient == agTRUE && onePortContext->RegisteredDevNums == 0)
{
TI_DBG2(("ossaHwCB: OSSA_HW_EVENT_PORT_RECOVER transient period"));
if (SA_IDFRM_GET_DEVICETTYPE(IDframe) != SAS_NO_DEVICE)
{
#ifdef INITIATOR_DRIVER
agSASSubID.sasAddressHi = SA_IDFRM_GET_SAS_ADDRESSHI(IDframe);
agSASSubID.sasAddressLo = SA_IDFRM_GET_SAS_ADDRESSLO(IDframe);
agSASSubID.initiator_ssp_stp_smp = IDframe->initiator_ssp_stp_smp;
agSASSubID.target_ssp_stp_smp = IDframe->target_ssp_stp_smp;
tdssAddSASToSharedcontext(
onePortContext,
agRoot,
agDevHandle,
&agSASSubID,
agTRUE,
(bit8)PhyID,
TD_OPERATION_INITIATOR
);
#endif
}
onePortContext->Transient = agFALSE;
}
}
break;
}
case OSSA_HW_EVENT_BROADCAST_SES:
{
PhyID = TD_GET_PHY_ID(eventParm1);
PortState = TD_GET_PORT_STATE(eventParm1);
TI_DBG2(("ossaHwCB: BROADCAST_SES from PhyID %d; to be tested\n", PhyID));
if (tIsSPC12SATA(agRoot))
{
TI_DBG1(("ossaHwCB: BROADCAST_SES received for SATA Controller\n"));
break;
}
if (PortState == OSSA_PORT_INVALID)
{
TI_DBG1(("ossaHwCB: Wrong port state with BROADCAST_SES\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'D', "Y2");
return;
}
break;
}
case OSSA_HW_EVENT_BROADCAST_EXP:
{
PhyID = TD_GET_PHY_ID(eventParm1);
PortState = TD_GET_PORT_STATE(eventParm1);
TI_DBG2(("ossaHwCB: BROADCAST_EXP from PhyID %d; to be tested\n", PhyID));
if (tIsSPC12SATA(agRoot))
{
TI_DBG1(("ossaHwCB: BROADCAST_EXP received for SATA Controller\n"));
break;
}
if (PortState == OSSA_PORT_INVALID)
{
TI_DBG1(("ossaHwCB: Wrong port state with BROADCAST_EXP\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'E', "Y2");
return;
}
break;
}
case OSSA_HW_EVENT_HARD_RESET_RECEIVED:
{
PhyID = TD_GET_PHY_ID(eventParm1);
PortState = TD_GET_PORT_STATE(eventParm1);
TI_DBG2(("ossaHwCB: HARD_RESET_RECEIVED from PhyID %d\n", PhyID));
if (PortState == OSSA_PORT_VALID && tiIS_SPC(agRoot))
{
TI_DBG1(("ossaHwCB: calling saPortControl and OSSA_PORT_VALID\n"));
saPortControl(agRoot, agNULL, 0, agPortContext, AGSA_PORT_HARD_RESET, 0,0);
}
else if (PortState == OSSA_PORT_3RDPARTY_RESET && (tIsSPCV12or6G(agRoot)) )
{
TI_DBG1(("ossaHwCB: calling saPortControl and OSSA_PORT_3RDPARTY_RESET\n"));
saPortControl(agRoot, agNULL, 0, agPortContext, AGSA_PORT_HARD_RESET, 0,0);
}
else
{
TI_DBG1(("ossaHwCB: Error. Port state is invalid\n"));
#ifdef REMOVED
TI_DBG1(("ossaHwCB: calling saLocalPhyControl on phyID %d\n", PhyID));
saLocalPhyControl(agRoot, agNULL, 0, PhyID, AGSA_PHY_LINK_RESET, agNULL);
#endif
}
break;
}
case OSSA_HW_EVENT_MALFUNCTION:
{
#ifdef TD_DEBUG_ENABLE
agsaFatalErrorInfo_t *FatalError = (agsaFatalErrorInfo_t *)eventParm2;
#endif
TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_MALFUNCTION \n"));
TI_DBG1(("ossaHwCB: errorInfo0 %8X errorInfo1 %8X\n", FatalError->errorInfo0, FatalError->errorInfo1));
TI_DBG1(("ossaHwCB: errorInfo2 %8X errorInfo3 %8X\n", FatalError->errorInfo2, FatalError->errorInfo3));
TI_DBG1(("ossaHwCB: regDumpBusBaseNum0 %8X regDumpOffset0 %8X regDumpLen0 %8X\n", FatalError->regDumpBusBaseNum0, FatalError->regDumpOffset0, FatalError->regDumpLen0));
TI_DBG1(("ossaHwCB: regDumpBusBaseNum1 %8X regDumpOffset1 %8X regDumpLen1 %8X\n", FatalError->regDumpBusBaseNum1, FatalError->regDumpOffset1, FatalError->regDumpLen1));
if (eventParm1 == agTRUE)
{
TI_DBG1(("ossaHwCB: fatal error\n"));
ostiPortEvent (
tiRoot,
tiPortPanic,
0,
agNULL
);
}
else
{
TI_DBG1(("ossaHwCB: non-fatal error \n"));
}
break;
}
case OSSA_HW_EVENT_ID_FRAME_TIMEOUT:
{
PhyID = TD_GET_PHY_ID(eventParm1);
PortState = TD_GET_PORT_STATE(eventParm1);
TI_DBG2(("ossaHwCB: OSSA_HW_EVENT_ID_FRAME_TIMEOUT from PhyID %d\n", PhyID));
if (PortState == OSSA_PORT_INVALID)
{
TI_DBG1(("ossaHwCB: Wrong port state with OSSA_HW_EVENT_ID_FRAME_TIMEOUT\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'F', "Y2");
return;
}
break;
}
case OSSA_HW_EVENT_PHY_ERR_INVALID_DWORD:
{
PhyID = TD_GET_PHY_ID(eventParm1);
PortState = TD_GET_PORT_STATE(eventParm1);
agPhyErrCountersPage = (agsaPhyErrCountersPage_t *)eventParm2;
TI_DBG2(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_INVALID_DWORD\n"));
if (PortState == OSSA_PORT_INVALID)
{
TI_DBG1(("ossaHwCB: Wrong port state with OSSA_HW_EVENT_PHY_ERR_INVALID_DWORD\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'G', "Y2");
return;
}
if (agPhyErrCountersPage != agNULL)
{
TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_INVALID_DWORD from PhyID %d\n", PhyID));
TI_DBG1(("ossaHwCB: invalidDword %d\n", agPhyErrCountersPage->invalidDword));
}
else
{
TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_INVALID_DWORD: Error!!! eventParm2 is NULL\n"));
}
eventSource.agPortContext = agPortContext;
eventSource.event = OSSA_HW_EVENT_PHY_ERR_INVALID_DWORD;
eventSource.param = PhyID;
HwAckSatus = saHwEventAck(
agRoot,
agNULL,
0,
&eventSource,
0,
0
);
if ( HwAckSatus != AGSA_RC_SUCCESS)
{
TI_DBG1(("ossaHwCB: failing in saHwEventAck; status %d\n", HwAckSatus));
smTraceFuncExit(hpDBG_VERY_LOUD, 'H', "Y2");
return;
}
break;
}
case OSSA_HW_EVENT_PHY_ERR_DISPARITY_ERROR:
{
PhyID = TD_GET_PHY_ID(eventParm1);
PortState = TD_GET_PORT_STATE(eventParm1);
agPhyErrCountersPage = (agsaPhyErrCountersPage_t *)eventParm2;
TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_DISPARITY_ERROR\n"));
if (PortState == OSSA_PORT_INVALID)
{
TI_DBG1(("ossaHwCB: Wrong port state with OSSA_HW_EVENT_PHY_ERR_DISPARITY_ERROR\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'I', "Y2");
return;
}
if (agPhyErrCountersPage != agNULL)
{
TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_DISPARITY_ERROR from PhyID %d\n", PhyID));
TI_DBG1(("ossaHwCB: runningDisparityError %d\n", agPhyErrCountersPage->runningDisparityError));
}
else
{
TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_DISPARITY_ERROR: Error!!! eventParm2 is NULL\n"));
}
eventSource.agPortContext = agPortContext;
eventSource.event = OSSA_HW_EVENT_PHY_ERR_DISPARITY_ERROR;
eventSource.param = PhyID;
HwAckSatus = saHwEventAck(
agRoot,
agNULL,
0,
&eventSource,
0,
0
);
if ( HwAckSatus != AGSA_RC_SUCCESS)
{
TI_DBG1(("ossaHwCB: failing in saHwEventAck; status %d\n", HwAckSatus));
smTraceFuncExit(hpDBG_VERY_LOUD, 'J', "Y2");
return;
}
break;
}
case OSSA_HW_EVENT_PHY_ERR_CODE_VIOLATION:
{
PhyID = TD_GET_PHY_ID(eventParm1);
PortState = TD_GET_PORT_STATE(eventParm1);
agPhyErrCountersPage = (agsaPhyErrCountersPage_t *)eventParm2;
TI_DBG2(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_CODE_VIOLATION\n"));
if (PortState == OSSA_PORT_INVALID)
{
TI_DBG1(("ossaHwCB: Wrong port state with OSSA_HW_EVENT_PHY_ERR_CODE_VIOLATION\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'K', "Y2");
return;
}
if (agPhyErrCountersPage != agNULL)
{
TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_CODE_VIOLATION from PhyID %d\n", PhyID));
TI_DBG1(("ossaHwCB: codeViolation %d\n", agPhyErrCountersPage->codeViolation));
}
else
{
TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_CODE_VIOLATION: Error!!! eventParm2 is NULL\n"));
}
eventSource.agPortContext = agPortContext;
eventSource.event = OSSA_HW_EVENT_PHY_ERR_CODE_VIOLATION;
eventSource.param = PhyID;
HwAckSatus = saHwEventAck(
agRoot,
agNULL,
0,
&eventSource,
0,
0
);
if ( HwAckSatus != AGSA_RC_SUCCESS)
{
TI_DBG1(("ossaHwCB: failing in saHwEventAck; status %d\n", HwAckSatus));
smTraceFuncExit(hpDBG_VERY_LOUD, 'L', "Y2");
return;
}
break;
}
#ifdef REMOVED
case OSSA_HW_EVENT_LINK_ERR_CODE_VIOLATION1:
{
PhyID = eventParm1 & 0xFF;
agPhyErrCountersPage = (agsaPhyErrCountersPage_t *)eventParm2;
if (agPhyErrCountersPage != agNULL)
{
TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_LINK_ERR_CODE_VIOLATION1 from PhyID %d\n", PhyID));
TI_DBG1(("ossaHwCB: invalidDword %d\n", agPhyErrCountersPage->invalidDword));
TI_DBG1(("ossaHwCB: runningDisparityError %d\n", agPhyErrCountersPage->runningDisparityError));
TI_DBG1(("ossaHwCB: codeViolation %d\n", agPhyErrCountersPage->codeViolation));
TI_DBG1(("ossaHwCB: lostOfDwordSynch %d\n", agPhyErrCountersPage->lossOfDwordSynch));
TI_DBG1(("ossaHwCB: phyResetProblem %d\n", agPhyErrCountersPage->phyResetProblem));
TI_DBG1(("ossaHwCB: inboundCRCError %d\n", agPhyErrCountersPage->inboundCRCError));
}
else
{
TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_LINK_ERR_CODE_VIOLATION1: Error!!! eventParm2 is NULL\n"));
}
break;
}
#endif
case OSSA_HW_EVENT_PHY_ERR_LOSS_OF_DWORD_SYNCH:
{
PhyID = TD_GET_PHY_ID(eventParm1);
PortState = TD_GET_PORT_STATE(eventParm1);
agPhyErrCountersPage = (agsaPhyErrCountersPage_t *)eventParm2;
TI_DBG2(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_LOSS_OF_DWORD_SYNCH\n"));
if (PortState == OSSA_PORT_INVALID)
{
TI_DBG1(("ossaHwCB: Wrong port state with OSSA_HW_EVENT_PHY_ERR_LOSS_OF_DWORD_SYNCH\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'M', "Y2");
return;
}
if (agPhyErrCountersPage != agNULL)
{
TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_LOSS_OF_DWORD_SYNCH from PhyID %d\n", PhyID));
TI_DBG1(("ossaHwCB: lostOfDwordSynch %d\n", agPhyErrCountersPage->lossOfDwordSynch));
}
else
{
TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_LOSS_OF_DWORD_SYNCH: Error!!! eventParm2 is NULL\n"));
}
eventSource.agPortContext = agPortContext;
eventSource.event = OSSA_HW_EVENT_PHY_ERR_LOSS_OF_DWORD_SYNCH;
eventSource.param = PhyID;
HwAckSatus = saHwEventAck(
agRoot,
agNULL,
0,
&eventSource,
0,
0
);
if ( HwAckSatus != AGSA_RC_SUCCESS)
{
TI_DBG1(("ossaHwCB: failing in saHwEventAck; status %d\n", HwAckSatus));
smTraceFuncExit(hpDBG_VERY_LOUD, 'N', "Y2");
return;
}
break;
}
case OSSA_HW_EVENT_PHY_ERR_PHY_RESET_FAILED:
{
PhyID = TD_GET_PHY_ID(eventParm1);
PortState = TD_GET_PORT_STATE(eventParm1);
agPhyErrCountersPage = (agsaPhyErrCountersPage_t *)eventParm2;
TI_DBG2(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_PHY_RESET_FAILED\n"));
if (PortState == OSSA_PORT_INVALID)
{
TI_DBG1(("ossaHwCB: Wrong port state with OSSA_HW_EVENT_PHY_ERR_PHY_RESET_FAILED\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'O', "Y2");
return;
}
if (agPhyErrCountersPage != agNULL)
{
TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_PHY_RESET_FAILED from PhyID %d\n", PhyID));
TI_DBG1(("ossaHwCB: phyResetProblem %d\n", agPhyErrCountersPage->phyResetProblem));
}
else
{
TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_ERR_PHY_RESET_FAILED: Error!!! eventParm2 is NULL\n"));
}
eventSource.agPortContext = agPortContext;
eventSource.event = OSSA_HW_EVENT_PHY_ERR_PHY_RESET_FAILED;
eventSource.param = PhyID;
HwAckSatus = saHwEventAck(
agRoot,
agNULL,
0,
&eventSource,
0,
0
);
if ( HwAckSatus != AGSA_RC_SUCCESS)
{
TI_DBG1(("ossaHwCB: failing in saHwEventAck; status %d\n", HwAckSatus));
smTraceFuncExit(hpDBG_VERY_LOUD, 'P', "Y2");
return;
}
break;
}
case OSSA_HW_EVENT_ENCRYPTION:
{
pEncryptCBData = (agsaHWEventEncrypt_t *) eventParm2;
TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_ENCRYPTION: encryptOperation 0x%x\n",pEncryptCBData->encryptOperation));
TI_DBG1(("ossaHwCB: event 0x%x eventParm1 0x%x eventParm2 %p eventParm3 %p\n",event,eventParm1,eventParm2,eventParm3));
if (pEncryptCBData->encryptOperation == OSSA_HW_ENCRYPT_KEK_UPDATE_AND_STORE)
{
TI_DBG1(("ossaHwCB: OSSA_HW_ENCRYPT_KEK_UPDATE_AND_STORE\n"));
encryptEventData.encryptEvent = tiEncryptKekStore;
}
else if (pEncryptCBData->encryptOperation == OSSA_HW_ENCRYPT_KEK_UPDATE)
{
TI_DBG1(("ossaHwCB:OSSA_HW_ENCRYPT_KEK_UPDATE \n"));
encryptEventData.encryptEvent = tiEncryptKekAdd;
}
else if (pEncryptCBData->encryptOperation == OSSA_HW_ENCRYPT_KEK_INVALIDTE)
{
TI_DBG1(("ossaHwCB:OSSA_HW_ENCRYPT_KEK_INVALIDTE \n"));
}
else if (pEncryptCBData->encryptOperation == OSSA_HW_ENCRYPT_DEK_UPDATE)
{
TI_DBG1(("ossaHwCB: OSSA_HW_ENCRYPT_DEK_UPDATE\n"));
encryptEventData.encryptEvent = tiEncryptDekAdd;
}
else if (pEncryptCBData->encryptOperation == OSSA_HW_ENCRYPT_DEK_INVALIDTE)
{
TI_DBG1(("ossaHwCB: OSSA_HW_ENCRYPT_DEK_INVALIDTE\n"));
encryptEventData.encryptEvent = tiEncryptDekInvalidate;
}
else if (pEncryptCBData->encryptOperation == OSSA_HW_ENCRYPT_OPERATOR_MANAGEMENT)
{
TI_DBG1(("ossaHwCB: OSSA_HW_ENCRYPT_OPERATOR_MANAGEMENT\n"));
encryptEventData.encryptEvent = tiEncryptOperatorManagement;
}
else if (pEncryptCBData->encryptOperation == OSSA_HW_ENCRYPT_TEST_EXECUTE)
{
TI_DBG1(("ossaHwCB: OSSA_HW_ENCRYPT_TEST_EXECUTE\n"));
encryptEventData.encryptEvent = tiEncryptSelfTest;
encryptEventData.subEvent = pEncryptCBData->eq;
}
else
{
TI_DBG1(("ossaHwCB: unknown encryptOperation 0x%x\n",pEncryptCBData->encryptOperation));
}
if (pEncryptCBData->status != OSSA_SUCCESS)
{
encryptStatus = tiError;
TI_DBG1(("ossaHwCB: encrypt response status 0x%x error qualifier 0x%x\n", pEncryptCBData->status, pEncryptCBData->eq));
}
else
{
encryptStatus = tiSuccess;
}
if (pEncryptCBData->encryptOperation == OSSA_HW_ENCRYPT_KEK_UPDATE_AND_STORE ||
pEncryptCBData->encryptOperation == OSSA_HW_ENCRYPT_KEK_UPDATE )
{
encryptEventData.pData = pEncryptCBData->handle;
}
else
{
encryptEventData.pData = pEncryptCBData->param;
}
ostiPortEvent(tiRoot,
tiEncryptOperation,
encryptStatus,
&encryptEventData);
break;
}
case OSSA_HW_EVENT_SECURITY_MODE:
{
securitySetModeStatus = eventParm1;
pEncryptInfo = (agsaEncryptInfo_t *) eventParm2;
TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_SECURITY_MODE\n"));
if (securitySetModeStatus == OSSA_SUCCESS)
{
securityModeStatus = tiSuccess;
}
else
{
securityModeStatus = tiError;
}
encryptEventData.encryptEvent = tiEncryptSetMode;
TI_DBG1(("ossaHwCB: pEncryptInfo->status 0x%x\n", pEncryptInfo->status));
if ( pEncryptInfo->status == OSSA_SUCCESS)
{
encryptEventData.subEvent = tiNVRAMSuccess;
}
else if (pEncryptInfo->status == 0x24)
{
encryptEventData.subEvent = tiNVRAMNotFound;
}
else if (pEncryptInfo->status == 0x05 || pEncryptInfo->status == 0x20 || pEncryptInfo->status == 0x21)
{
encryptEventData.subEvent = tiNVRAMAccessTimeout;
}
else
{
encryptEventData.subEvent = tiNVRAMWriteFail;
}
encryptEventData.pData = agNULL;
ostiPortEvent(tiRoot,
tiEncryptOperation,
securityModeStatus,
&encryptEventData);
break;
}
case OSSA_HW_EVENT_MODE:
{
pModeEvent = (agsaHWEventMode_t *) eventParm2;
pModePage = (bit32 *) pModeEvent->modePage;
TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_MODE modePageOperation 0x%x status 0x%x modePageLen 0x%x\n",
pModeEvent->modePageOperation, pModeEvent->status, pModeEvent->modePageLen));
if (pModeEvent->modePageOperation == agsaModePageSet)
{
TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_MODE page code 0x%x error qualifier 0x%x\n", (eventParm1 & 0xFF), (eventParm1 >> 16)));
ostiPortEvent(tiRoot,
tiModePageOperation,
pModeEvent->status,
eventParm2);
}
else if (pModeEvent->modePageOperation == agsaModePageGet)
{
TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_MODE error qualifier 0x%x\n", eventParm1));
switch ((*pModePage) & 0xFF)
{
case AGSA_ENCRYPTION_GENERAL_CONFIG_PAGE:
TI_DBG1(("ossaHwCB: AGSA_ENCRYPTION_GENERAL_CONFIG_PAGE 0x%x %p\n", pModeEvent->status,eventParm2));
TI_DBG1(("ossaHwCB:modePageOperation 0x%x status 0x%x modePageLen 0x%x modePage %p context %p\n",
pModeEvent->modePageOperation,
pModeEvent->status,
pModeEvent->modePageLen,
pModeEvent->modePage,
pModeEvent->context));
ostiPortEvent(tiRoot,
tiModePageOperation,
pModeEvent->status,
eventParm2);
break;
case AGSA_ENCRYPTION_DEK_CONFIG_PAGE:
TI_DBG1(("ossaHwCB: AGSA_ENCRYPTION_DEK_CONFIG_PAGE 0x%x %p\n", pModeEvent->status,eventParm2));
ostiPortEvent(tiRoot,
tiModePageOperation,
pModeEvent->status,
eventParm2);
break;
case AGSA_ENCRYPTION_HMAC_CONFIG_PAGE:
TI_DBG1(("ossaHwCB: AGSA_ENCRYPTION_HMAC_CONFIG_PAGE 0x%x %p\n", pModeEvent->status,eventParm2));
ostiPortEvent(tiRoot,
tiModePageOperation,
pModeEvent->status,
eventParm2);
break;
case AGSA_ENCRYPTION_CONTROL_PARM_PAGE:
TI_DBG1(("ossaHwCB: AGSA_ENCRYPTION_CONTROL_PARM_PAGE 0x%x %p\n", pModeEvent->status,eventParm2));
securityMode = *pModePage & 0x0F00 >> 8;
cipherMode = *pModePage & 0xF000 >> 12;
if (securityMode == agsaEncryptSMA)
{
encryptInfo.securityCipherMode = TI_ENCRYPT_SEC_MODE_A;
}
else if (securityMode == agsaEncryptSMB)
{
encryptInfo.securityCipherMode = TI_ENCRYPT_SEC_MODE_B;
}
else
{
encryptInfo.securityCipherMode = TI_ENCRYPT_SEC_MODE_FACT_INIT;
}
if (cipherMode == agsaEncryptCipherModeECB)
{
encryptInfo.securityCipherMode |= TI_ENCRYPT_ATTRIB_CIPHER_ECB;
}
if (cipherMode == agsaEncryptCipherModeXTS)
{
encryptInfo.securityCipherMode |= TI_ENCRYPT_ATTRIB_CIPHER_XTS;
}
encryptInfo.status = 0;
encryptInfo.sectorSize[0] = 512;
encryptInfo.sectorSize[1] = 520;
encryptInfo.sectorSize[2] = 528;
encryptInfo.sectorSize[3] = 4104;
encryptInfo.sectorSize[4] = 4168;
encryptInfo.sectorSize[5] = 4232;
encryptEventData.encryptEvent = tiEncryptGetInfo;
encryptEventData.subEvent = 0;
encryptEventData.pData = &encryptInfo;
ostiPortEvent(tiRoot,
tiEncryptOperation,
pModeEvent->status,
&encryptEventData);
break;
case AGSA_SAS_PROTOCOL_TIMER_CONFIG_PAGE:
TI_DBG1(("ossaHwCB: AGSA_SAS_PROTOCOL_TIMER_CONFIG_PAGE 0x%x %p\n", pModeEvent->status,eventParm2));
#ifdef IOCTL_INTERRUPT_TIME_CONFIG
ostiPortEvent(tiRoot,
tiModePageOperation,
pModeEvent->status,
eventParm2
);
#endif
break;
case AGSA_INTERRUPT_CONFIGURATION_PAGE:
TI_DBG1(("ossaHwCB: AGSA_INTERRUPT_CONFIGURATION_PAGE 0x%x %p\n", pModeEvent->status,eventParm2));
#ifdef IOCTL_INTERRUPT_TIME_CONFIG
ostiPortEvent(tiRoot,
tiModePageOperation,
pModeEvent->status,
eventParm2
);
#endif
break;
default:
TI_DBG1(("ossaHwCB: Unknown Mode Event %x\n", *pModePage));
break;
}
}
else
{
TI_DBG1(("ossaHwCB: Unknown modePageOperation %x\n", pModeEvent->modePageOperation));
}
break;
}
#ifdef REMOVED
case OSSA_HW_EVENT_PHY_UNRECOVERABLE_ERROR:
{
PhyID = TD_GET_PHY_ID(eventParm1);
PortState = TD_GET_PORT_STATE(eventParm1);
TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_PHY_UNRECOVERABLE_ERROR\n"));
if (PortState == OSSA_PORT_INVALID)
{
TI_DBG1(("ossaHwCB: INVALID port state\n"));
}
else
{
TI_DBG1(("ossaHwCB: VALID port state\n"));
}
break;
}
#endif
case OSSA_HW_EVENT_OPEN_RETRY_BACKOFF_THR_ADJUSTED:
{
TI_DBG1(("ossaHwCB: OSSA_HW_EVENT_OPEN_RETRY_BACKOFF_THR_ADJUSTED\n"));
break;
}
default:
{
TI_DBG1(("ossaHwCB: default error (0x%X)!!!!!\n",event));
break;
}
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'R', "Y2");
return;
}
osGLOBAL void ossaPortControlCB(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
agsaPortContext_t *agPortContext,
bit32 portOperation,
bit32 status)
{
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
tdsaPortContext_t *onePortContext = agNULL;
TI_DBG6(("ossaPortControlCB: start\n"));
smTraceFuncEnter(hpDBG_VERY_LOUD,"Y3");
if (portOperation == AGSA_PORT_SET_SMP_PHY_WIDTH)
{
TI_DBG1(("ossaPortControlCB: portOperation AGSA_PORT_SET_SMP_PHY_WIDTH\n"));
}
else if (portOperation == AGSA_PORT_SET_PORT_RECOVERY_TIME)
{
TI_DBG1(("ossaPortControlCB: portOperation AGSA_PORT_SET_PORT_RECOVERY_TIME\n"));
}
else if (portOperation == AGSA_PORT_IO_ABORT)
{
TI_DBG1(("ossaPortControlCB: portOperation AGSA_PORT_IO_ABORT\n"));
onePortContext = (tdsaPortContext_t *)agPortContext->osData;
if (onePortContext == agNULL)
{
TI_DBG1(("ossaPortControlCB: onePortContext is NULL\n"));
return;
}
tdsaDeregisterDevicesInPort(tiRoot, onePortContext);
}
else if (portOperation == AGSA_PORT_SET_PORT_RESET_TIME)
{
TI_DBG1(("ossaPortControlCB: portOperation AGSA_PORT_SET_PORT_RESET_TIME\n"));
}
else if (portOperation == AGSA_PORT_HARD_RESET)
{
TI_DBG1(("ossaPortControlCB: portOperation AGSA_PORT_HARD_RESET\n"));
}
else if (portOperation == AGSA_PORT_CLEAN_UP)
{
TI_DBG1(("ossaPortControlCB: portOperation AGSA_PORT_CLEAN_UP\n"));
}
else if (portOperation == AGSA_STOP_PORT_RECOVERY_TIMER)
{
TI_DBG1(("ossaPortControlCB: portOperation AGSA_STOP_PORT_RECOVERY_TIMER\n"));
}
else
{
TI_DBG1(("ossaPortControlCB: undefined portOperation %d\n", portOperation));
}
TI_DBG1(("ossaPortControlCB: status %d\n", status));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Y3");
return;
}
FORCEINLINE
bit32
ossaHwRegRead(agsaRoot_t *agRoot,
bit32 regOffset
)
{
tdsaRootOsData_t *osData = (tdsaRootOsData_t *) (agRoot->osData);
bit32 return_value;
return_value = ostiChipReadBit32 (
osData->tiRoot,
regOffset
);
if( agNULL != agRoot->sdkData )
{
smTrace(hpDBG_REGISTERS,"RR",regOffset);
smTrace(hpDBG_REGISTERS,"RV",return_value);
}
return(return_value);
}
FORCEINLINE
void
ossaHwRegWrite(agsaRoot_t *agRoot,
bit32 regOffset,
bit32 regValue
)
{
tdsaRootOsData_t *osData = (tdsaRootOsData_t *) (agRoot->osData);
if( agNULL != agRoot->sdkData )
{
smTrace(hpDBG_REGISTERS,"RW",regOffset);
smTrace(hpDBG_REGISTERS,"VW",regValue);
}
ostiChipWriteBit32 (
osData->tiRoot,
regOffset,
regValue
);
return;
}
FORCEINLINE
bit32
ossaHwRegReadExt(
agsaRoot_t *agRoot,
bit32 busBaseNumber,
bit32 regOffset
)
{
tdsaRootOsData_t *osData = (tdsaRootOsData_t *) (agRoot->osData);
bit32 return_value;
return_value = ostiChipReadBit32Ext(
osData->tiRoot,
busBaseNumber,
regOffset
);
if( agNULL != agRoot->sdkData )
{
smTrace(hpDBG_REGISTERS,"EB",busBaseNumber);
smTrace(hpDBG_REGISTERS,"EO",regOffset);
smTrace(hpDBG_REGISTERS,"ER",return_value);
}
return(return_value);
}
void ossaPCI_TRIGGER(agsaRoot_t *agRoot )
{
tdsaRootOsData_t *osData = (tdsaRootOsData_t *) (agRoot->osData);
ostiPCI_TRIGGER(osData->tiRoot);
}
FORCEINLINE
void
ossaHwRegWriteExt(
agsaRoot_t *agRoot,
bit32 busBaseNumber,
bit32 regOffset,
bit32 regValue
)
{
tdsaRootOsData_t *osData = (tdsaRootOsData_t *) (agRoot->osData);
ostiChipWriteBit32Ext(
osData->tiRoot,
busBaseNumber,
regOffset,
regValue
);
if( agNULL != agRoot->sdkData )
{
smTrace(hpDBG_REGISTERS,"Eb",busBaseNumber);
smTrace(hpDBG_REGISTERS,"Eo",regOffset);
smTrace(hpDBG_REGISTERS,"Ew",regValue);
}
return;
}
osGLOBAL bit32 ossaHwRegReadConfig32(
agsaRoot_t *agRoot,
bit32 regOffset
)
{
tdsaRootOsData_t *osData = (tdsaRootOsData_t *) (agRoot->osData);
bit32 to_ret;
to_ret= ostiChipConfigReadBit32( osData->tiRoot, regOffset);
TI_DBG4(("ossaHwRegReadConfig32: regOffset 0x%x returns 0x%x\n",regOffset,to_ret));
return(to_ret);
}
#ifdef TD_INT_COALESCE
void
ossaIntCoalesceInitCB(
agsaRoot_t *agRoot,
agsaIntCoalesceContext_t *agIntCoContext,
bit32 status
)
{
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
tdsaContext_t *tdsaAllShared = (tdsaContext_t *)osData->tdsaAllShared;
tiIntCoalesceContext_t *tiIntCoalesceCxt;
tdsaIntCoalesceContext_t *tdsaIntCoalCxt;
tdsaIntCoalesceContext_t *tdsaIntCoalCxtHead
= (tdsaIntCoalesceContext_t *)tdsaAllShared->IntCoalesce;
bit32 tiStatus;
TI_DBG2(("ossaIntCoalesceInitCB: start\n"));
tdsaIntCoalCxt = (tdsaIntCoalesceContext_t *)agIntCoContext->osData;
tiIntCoalesceCxt = tdsaIntCoalCxt->tiIntCoalesceCxt;
switch (status)
{
case AGSA_RC_SUCCESS:
tiStatus = tiSuccess;
break;
case AGSA_RC_BUSY:
tiStatus = tiBusy;
break;
case AGSA_RC_FAILURE:
tiStatus = tiError;
break;
default:
TI_DBG1(("ossaIntCoalesceInitCB: unknown status %d\n", status));
tiStatus = tiError;
break;
}
TI_DBG2(("ossaIntCoalesceInitCB: status %d\n", tiStatus));
tdsaIntCoalCxt->tiIntCoalesceCxt = agNULL;
TI_DBG2(("ossaIntCoalesceInitCB: id %d\n", tdsaIntCoalCxt->id));
tdsaSingleThreadedEnter(tiRoot, TD_INTCOAL_LOCK);
TDLIST_DEQUEUE_THIS(&(tdsaIntCoalCxt->MainLink));
TDLIST_ENQUEUE_AT_TAIL(&(tdsaIntCoalCxt->FreeLink), &(tdsaIntCoalCxtHead->FreeLink));
tdsaSingleThreadedLeave(tiRoot, TD_INTCOAL_LOCK);
#ifdef OS_INT_COALESCE
ostiInitiatorIntCoalesceInitCB(tiRoot,
tiIntCoalesceCxt,
tiStatus);
#endif
TI_DBG2(("ossaIntCoalesceInitCB: return end\n"));
return;
}
#endif
FORCEINLINE
void ossaSingleThreadedEnter(
agsaRoot_t *agRoot,
bit32 syncLockId
)
{
tdsaRootOsData_t *pOsData = agNULL;
tiRoot_t *ptiRoot = agNULL;
tdsaContext_t *tdsaAllShared = agNULL;
TD_ASSERT(agRoot, "agRoot");
pOsData = (tdsaRootOsData_t *) (agRoot->osData);
TD_ASSERT(pOsData, "pOsData");
ptiRoot = pOsData->tiRoot;
TD_ASSERT(ptiRoot, "ptiRoot");
tdsaAllShared = (tdsaContext_t *)pOsData->tdsaAllShared;
TD_ASSERT(tdsaAllShared, "tdsaAllShared");
ostiSingleThreadedEnter(ptiRoot, syncLockId + tdsaAllShared->MaxNumOSLocks);
return;
}
FORCEINLINE
void ossaSingleThreadedLeave(
agsaRoot_t *agRoot,
bit32 syncLockId
)
{
tdsaRootOsData_t *pOsData = agNULL;
tiRoot_t *ptiRoot = agNULL;
tdsaContext_t *tdsaAllShared = agNULL;
TD_ASSERT(agRoot, "agRoot");
pOsData = (tdsaRootOsData_t *) (agRoot->osData);
TD_ASSERT(pOsData, "pOsData");
ptiRoot = pOsData->tiRoot;
TD_ASSERT(ptiRoot, "ptiRoot");
tdsaAllShared = (tdsaContext_t *)pOsData->tdsaAllShared;
TD_ASSERT(tdsaAllShared, "tdsaAllShared");
ostiSingleThreadedLeave(ptiRoot, syncLockId + tdsaAllShared->MaxNumOSLocks);
return;
}
#ifdef PERF_COUNT
osGLOBAL void ossaEnter(agsaRoot_t *agRoot, int io)
{
ostiEnter(((tdsaRootOsData_t*)(agRoot->osData))->tiRoot, 0, io);
return;
}
osGLOBAL void ossaLeave(agsaRoot_t *agRoot, int io)
{
ostiLeave(((tdsaRootOsData_t*)(agRoot->osData))->tiRoot, 0, io);
return;
}
#endif
osGLOBAL void
ossaSSPIoctlCompleted(
agsaRoot_t *agRoot,
agsaIORequest_t *agIORequest,
bit32 agIOStatus,
bit32 agIOInfoLen,
void *agParam,
bit16 sspTag,
bit32 agOtherInfo
)
{
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
tdIORequestBody_t *tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
agsaSASRequestBody_t *agSASRequestBody = agNULL;
agsaSSPInitiatorRequest_t *agSSPFrame = agNULL;
bit8 scsiOpcode = 0;
agSASRequestBody = &(tdIORequestBody->transport.SAS.agSASRequestBody);
agSSPFrame = &(agSASRequestBody->sspInitiatorReq);
scsiOpcode = agSSPFrame->sspCmdIU.cdb[0];
TI_DBG2(("ossaSSPIoctlCompleted: start\n"));
if (agIOStatus == OSSA_SUCCESS)
{
TI_DBG2(("ossaSSPIoctlCompleted: Success status\n"));
}
else
{
TI_DBG1(("ossaSSPIoctlCompleted: Status 0x%x\n", agIOStatus));
}
switch(scsiOpcode)
{
case REPORT_LUN_OPCODE:
ostiNumOfLUNIOCTLRsp(tiRoot, agIOStatus);
break;
default:
TI_DBG1(("ossaSSPIoctlCompleted: Unsupported SCSI command Response 0x%x\n",scsiOpcode));
break;
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yi");
return;
}
osGLOBAL void
ossaSMPIoctlCompleted(
agsaRoot_t *agRoot,
agsaIORequest_t *agIORequest,
bit32 agIOStatus,
bit32 agIOInfoLen,
agsaFrameHandle_t agFrameHandle
)
{
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
TI_DBG2(("ossaSMPIoctlCompleted: start\n"));
if (agIOStatus == OSSA_SUCCESS)
{
TI_DBG2(("ossaSMPIoctlCompleted: Success status\n"));
}
else
{
TI_DBG1(("ossaSMPIoctlCompleted: Status 0x%x\n", agIOStatus));
}
ostiSendSMPIOCTLRsp(tiRoot, agIOStatus);
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yi");
return;
}
osGLOBAL void ossaSMPCompleted(
agsaRoot_t *agRoot,
agsaIORequest_t *agIORequest,
bit32 agIOStatus,
bit32 agIOInfoLen,
agsaFrameHandle_t agFrameHandle
)
{
#ifdef PASSTHROUGH
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
tdPassthroughCmndBody_t *tdPTCmndBody = (tdPassthroughCmndBody_t *)agIORequest->osData;
bit32 tiStatus = tiPassthroughError;
bit8 SMPframe[agIOInfoLen + sizeof(agsaSMPFrameHeader_t)];
bit8 SMPpayload[agIOInfoLen];
TI_DBG2(("ossaSMPCompleted: start and passthrough\n"));
#else
tdssSMPRequestBody_t *pSMPRequestBody = (tdssSMPRequestBody_t *) agIORequest->osData;
TI_DBG4(("ossaSMPCompleted: start\n"));
#endif
TDSA_OUT_ENTER((tiRoot_t *)((tdsaRootOsData_t *)agRoot->osData)->tiRoot);
smTraceFuncEnter(hpDBG_VERY_LOUD,"Y4");
#ifdef PASSTHROUGH
if (tdPTCmndBody == agNULL)
{
TI_DBG1(("ossaSMPCompleted: tdPTCmndBody is NULL \n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Y4");
goto ext;
}
if (tdPTCmndBody->EventCB == agNULL)
{
TI_DBG1(("ossaSMPCompleted: tdPTCmndBody->EventCB is NULL \n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "Y4");
goto ext;
}
if (agIOStatus == OSSA_IO_SUCCESS)
{
tiStatus = tiPassthroughSuccess;
}
else if (agIOStatus == OSSA_IO_ABORTED)
{
tiStatus = tiPassthroughAborted;
}
else
{
tiStatus = tiPassthroughError;
}
osti_memset(SMPpayload, 0, agIOInfoLen);
osti_memset(SMPframe, 0, agIOInfoLen + sizeof(agsaSMPFrameHeader_t));
saFrameReadBlock(agRoot, agFrameHandle, 0, &SMPpayload, agIOInfoLen);
osti_memcpy(SMPframe, agFrameHeader, sizeof(agsaSMPFrameHeader_t));
osti_memcpy(SMPframe+sizeof(agsaSMPFrameHeader_t), SMPpayload, agIOInfoLen);
tdPTCmndBody->EventCB(tiRoot,
tdPTCmndBody->tiPassthroughRequest,
tiStatus,
SMPframe,
agIOInfoLen + sizeof(agsaSMPFrameHeader_t)
);
#else
TI_DBG4(("ossaSMPCompleted: start\n"));
if (pSMPRequestBody == agNULL)
{
TI_DBG1(("ossaSMPCompleted: pSMPRequestBody is NULL \n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "Y4");
goto ext;
}
if (pSMPRequestBody->SMPCompletionFunc == agNULL)
{
TI_DBG1(("ossaSMPCompleted: pSMPRequestBody->SMPCompletionFunc is NULL \n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'd', "Y4");
goto ext;
}
#ifdef TD_INTERNAL_DEBUG
TI_DBG4(("ossaSMPCompleted: agIOrequest %p\n", agIORequest->osData));
TI_DBG4(("ossaSMPCompleted: sizeof(tdIORequestBody_t) %d 0x%x\n", sizeof(tdIORequestBody_t),
sizeof(tdIORequestBody_t)));
TI_DBG4(("ossaSMPCompleted: SMPRequestbody %p\n", pSMPRequestBody));
TI_DBG4(("ossaSMPCompleted: calling callback fn\n"));
TI_DBG4(("ossaSMPCompleted: callback fn %p\n",pSMPRequestBody->SMPCompletionFunc));
#endif
pSMPRequestBody->SMPCompletionFunc(
agRoot,
agIORequest,
agIOStatus,
agIOInfoLen,
agFrameHandle
);
#endif
smTraceFuncExit(hpDBG_VERY_LOUD, 'e', "Y4");
ext:
TDSA_OUT_LEAVE((tiRoot_t *)((tdsaRootOsData_t *)agRoot->osData)->tiRoot);
return;
}
osGLOBAL void
ossaSMPReqReceived(
agsaRoot_t *agRoot,
agsaDevHandle_t *agDevHandle,
agsaFrameHandle_t agFrameHandle,
bit32 agIOInfoLen,
bit32 phyId
)
{
smTraceFuncEnter(hpDBG_VERY_LOUD,"Y5");
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Y5");
return;
}
osGLOBAL void ossaSMPCAMCompleted(
agsaRoot_t *agRoot,
agsaIORequest_t *agIORequest,
bit32 agIOStatus,
bit32 agIOInfoLen,
agsaFrameHandle_t agFrameHandle
)
{
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
tdIORequestBody_t *tdSMPRequestBody = agNULL;
bit32 context = osData->IntContext;
tiSMPStatus_t status;
bit32 PhysUpper32;
bit32 PhysLower32;
bit32 memAllocStatus;
void *osMemHandle;
bit32 *SMPpayload;
TI_DBG2(("ossaSMPCAMCompleted: start\n"));
TI_DBG2(("ossaSMPCAMCompleted: agIOInfoLen %d\n", agIOInfoLen));
if (!agIORequest->osData)
{
TD_ASSERT((0), "ossaSMPCAMCompleted agIORequest->osData");
goto ext;
}
tdSMPRequestBody = (tdIORequestBody_t *)agIORequest->osData;
if (tdSMPRequestBody->tiIORequest->osData == agNULL)
{
TI_DBG1(("ossaSMPCAMCompleted: tdIORequestBody->tiIORequest->osData is null, wrong\n"));
goto ext;
}
memAllocStatus = ostiAllocMemory(
tiRoot,
&osMemHandle,
(void **)&SMPpayload,
&PhysUpper32,
&PhysLower32,
8,
agIOInfoLen,
agTRUE
);
if (memAllocStatus != tiSuccess)
{
TI_DBG1(("ossaSMPCAMCompleted: ostiAllocMemory failed...\n"));
goto ext;
}
if (SMPpayload == agNULL)
{
TI_DBG1(("ossaSMPCAMCompleted: ostiAllocMemory returned NULL SMPpayload\n"));
goto ext;
}
if (agIOStatus == OSSA_IO_SUCCESS)
{
TI_DBG1(("ossaSMPCAMCompleted: Success status\n"));
osti_memset(SMPpayload, 0, agIOInfoLen);
TI_DBG1(("ossaSMPCAMCompleted: after memset\n"));
saFrameReadBlock(agRoot, agFrameHandle, 0, SMPpayload, agIOInfoLen);
TI_DBG1(("ossaSMPCAMCompleted: after read \n"));
status = tiSMPSuccess;
}
else if (agIOStatus == OSSA_IO_ABORTED)
{
TI_DBG1(("ossaSMPCAMCompleted: SMP Aborted status\n"));
status = tiSMPAborted;
TI_DBG1(("ossaSMPCAMCompleted: failed status=%d\n", status));
ostiFreeMemory(
tiRoot,
osMemHandle,
agIOInfoLen
);
}
else
{
TI_DBG1(("ossaSMPCAMCompleted: SMP failed status\n"));
status = tiSMPFailed;
TI_DBG1(("ossaSMPCAMCompleted: failed status=%d\n", status));
ostiFreeMemory(
tiRoot,
osMemHandle,
agIOInfoLen
);
}
ostiInitiatorSMPCompleted(tiRoot,
tdSMPRequestBody->tiIORequest,
status,
agIOInfoLen,
SMPpayload,
context
);
ext:
TDSA_OUT_LEAVE((tiRoot_t*)((tdsaRootOsData_t*)agRoot->osData)->tiRoot);
return;
}
#ifdef REMOVED
#ifdef TARGET_DRIVER
osGLOBAL void ossaSMPReqReceived(
agsaRoot_t *agRoot,
agsaDevHandle_t *agDevHandle,
agsaFrameHandle_t agFrameHandle,
bit32 agFrameLength,
bit32 phyId
)
{
bit8 smpHeader[4];
agsaSMPFrameHeader_t *agFrameHeader;
#ifdef PASSTHROUGH
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
ttdsaTgt_t *Target = (ttdsaTgt_t *)osData->ttdsaTgt;
bit8 SMPframe[agIOInfoLen + sizeof(agsaSMPFrameHeader_t)];
bit8 SMPpayload[agIOInfoLen];
TI_DBG2(("ossaSMPReqReceived: start and passthrough\n"));
osti_memset(SMPpayload, 0, agIOInfoLen);
osti_memset(SMPframe, 0, agIOInfoLen + sizeof(agsaSMPFrameHeader_t));
saFrameReadBlock(agRoot, agFrameHandle, 0, &SMPpayload, agIOInfoLen);
osti_memcpy(SMPframe, agFrameHeader, sizeof(agsaSMPFrameHeader_t));
osti_memcpy(SMPframe+sizeof(agsaSMPFrameHeader_t), SMPpayload, agIOInfoLen);
Target->PasthroughCB(
tiRoot,
tiSASATA,
tiSMP,
tiSMPResponse,
SMPframe,
agIOInfoLen + sizeof(agsaSMPFrameHeader_t),
phyId
);
#else
tdsaDeviceData_t *pDeviceData = (tdsaDeviceData_t *) agDevHandle->osData;
saFrameReadBlock(agRoot, agFrameHandle, 0, smpHeader, 4);
agFrameHeader = (agsaSMPFrameHeader_t *)smpHeader;
TI_DBG4(("ossaSMPReqReceived: start\n"));
pDeviceData->pJumpTable->pSMPReqReceived (
agRoot,
agDevHandle,
agFrameHeader,
agFrameHandle,
agFrameLength,
phyId
);
#endif
return;
}
#endif
#endif
FORCEINLINE
void ossaSSPCompleted(
agsaRoot_t *agRoot,
agsaIORequest_t *agIORequest,
bit32 agIOStatus,
bit32 agIOInfoLen,
void *agParam,
bit16 sspTag,
bit32 agOtherInfo
)
{
tdIORequestBody_t *pIORequestBody;
#ifdef TD_DEBUG_ENABLE
tiDeviceHandle_t *tiDeviceHandle = agNULL;
tdsaDeviceData_t *oneDeviceData = agNULL;
#endif
TDSA_OUT_ENTER((tiRoot_t*)((tdsaRootOsData_t*)agRoot->osData)->tiRoot);
smTraceFuncEnter(hpDBG_VERY_LOUD,"2L");
if(!agIORequest->osData)
{
TD_ASSERT((0), "ossaSSPCompleted agIORequest->osData");
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2L");
goto ext;
}
pIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
TI_DBG4(("ossaSSPCompleted: start\n"));
if (pIORequestBody == agNULL)
{
TI_DBG1(("ossaSSPCompleted: pIORequestBody is NULL \n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "2L");
goto ext;
}
if (pIORequestBody->IOCompletionFunc == agNULL)
{
#ifdef TD_DEBUG_ENABLE
tiDeviceHandle = pIORequestBody->tiDevHandle;
oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData;
#endif
TI_DBG1(("ossaSSPCompleted: IOCompletionFunc is NULL \n"));
TI_DBG1(("ossaSSPCompleted: did %d \n", oneDeviceData->id));
smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "2L");
goto ext;
}
pIORequestBody->IOCompletionFunc(
agRoot,
agIORequest,
agIOStatus,
agIOInfoLen,
agParam,
agOtherInfo
);
smTraceFuncExit(hpDBG_VERY_LOUD, 'd', "2L");
ext:
TDSA_OUT_LEAVE((tiRoot_t*)((tdsaRootOsData_t*)agRoot->osData)->tiRoot);
return;
}
#ifdef FAST_IO_TEST
GLOBAL void ossaFastSSPCompleted(
agsaRoot_t *agRoot,
agsaIORequest_t *cbArg,
bit32 agIOStatus,
bit32 agIOInfoLen,
void *agParam,
bit16 sspTag,
bit32 agOtherInfo
)
{
agsaFastCBBuf_t *safb = (agsaFastCBBuf_t*)cbArg;
tdsaRootOsData_t *osData = (tdsaRootOsData_t*)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t*)osData->tiRoot;
bit32 scsi_status;
bit32 data_status;
bit32 respLen;
bit8 respData[128];
bit32 senseLen;
agsaSSPResponseInfoUnit_t agSSPRespIU;
TDSA_OUT_ENTER((tiRoot_t*)((tdsaRootOsData_t*)agRoot->osData)->tiRoot);
smTraceFuncEnter(hpDBG_VERY_LOUD,"Y6");
TI_DBG4(("ossaSSPCompleted: start\n"));
if (safb->cb == agNULL || safb->cbArg == agNULL)
{
TI_DBG1(("ossaFastSSPCompleted: pIORequestBody is NULL \n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Y6");
TD_ASSERT((0), "");
goto ext;
}
switch (agIOStatus)
{
case OSSA_IO_SUCCESS:
if ((agIOInfoLen < sizeof(agsaSSPResponseInfoUnit_t)))
{
((ostiFastSSPCb_t)safb->cb)(tiRoot, safb->cbArg, OSSA_IO_SUCCESS, 0);
break;
}
saFrameReadBlock(agRoot, agParam, 0, &agSSPRespIU,
sizeof(agsaSSPResponseInfoUnit_t));
data_status = SA_SSPRESP_GET_DATAPRES(&agSSPRespIU);
scsi_status = agSSPRespIU.status;
TI_DBG1(("itdssIOSuccessHandler: scsi_status %d\n", scsi_status));
senseLen = SA_SSPRESP_GET_SENSEDATALEN(&agSSPRespIU);
respLen = SA_SSPRESP_GET_RESPONSEDATALEN(&agSSPRespIU);
TI_DBG2(("itdssIOSuccessHandler: scsi status=0x%x, senselen=0x%x resplen "
"0x%x\n", scsi_status, senseLen, respLen));
if (agIOInfoLen < sizeof(agsaSSPResponseInfoUnit_t) + senseLen + respLen)
{
((ostiFastSSPCb_t)safb->cb)(tiRoot, safb->cbArg, tiIOFailed,
tiDetailOtherError);
break;
}
saFrameReadBlock(agRoot, agParam, sizeof(agsaSSPResponseInfoUnit_t),
respData, respLen);
saFrameReadBlock(agRoot, agParam, sizeof(agsaSSPResponseInfoUnit_t)
+ respLen, safb->pSenseData, senseLen);
if (data_status == 0)
{
TI_DBG2(("ossaFastSSPCompleted: no data\n"));
((ostiFastSSPCb_t)safb->cb)(tiRoot, safb->cbArg, tiIOSuccess,
scsi_status);
break;
}
if (data_status == 1)
{
TI_DBG1(("ossaFastSSPCompleted: response data \n"));
((ostiFastSSPCb_t)safb->cb)(tiRoot, safb->cbArg, tiIOSuccess, 0);
break;
}
if (data_status == 2)
{
tiSenseData_t senseData;
TI_DBG2(("itdssIOSuccessHandler: sense data \n"));
senseData.senseData = safb->pSenseData;
senseData.senseLen = MIN(*(safb->senseLen), senseLen);
if (((char*)safb->pSenseData)[12] == 0x04 &&
((char*)safb->pSenseData)[13] == 0x11)
{
int i;
TI_DBG2(("ossaFastSSPCompleted: sending notfify spinup\n"));
if (((tdsaDeviceData_t*)safb->oneDeviceData)->directlyAttached ==
agTRUE)
{
for (i = 0; i < TD_MAX_NUM_NOTIFY_SPINUP; i++)
{
saLocalPhyControl(agRoot, agNULL, 0,
((tdsaDeviceData_t*)safb->oneDeviceData)->phyID,
AGSA_PHY_NOTIFY_ENABLE_SPINUP,
agNULL);
}
}
}
if (*(safb->senseLen) > senseData.senseLen)
*(safb->senseLen) = senseData.senseLen;
((ostiFastSSPCb_t)safb->cb)(tiRoot, safb->cbArg, tiIOSuccess,
scsi_status);
break;
}
if (data_status == 3)
{
TI_DBG1(("ossaFastSSPCompleted: reserved wrong!!!\n"));
((ostiFastSSPCb_t)safb->cb)(tiRoot, safb->cbArg, tiIOFailed,
scsi_status);
break;
}
break;
#ifdef REMOVED
case OSSA_IO_OVERFLOW:
((ostiFastSSPCb_t)safb->cb)(tiRoot, safb->cbArg, tiIOOverRun,
agIOInfoLen);
break;
#endif
case OSSA_IO_UNDERFLOW:
((ostiFastSSPCb_t)safb->cb)(tiRoot, safb->cbArg, tiIOUnderRun,
agIOInfoLen);
break;
case OSSA_IO_ABORTED:
((ostiFastSSPCb_t)safb->cb)(tiRoot, safb->cbArg, tiIOFailed,
tiDetailAborted);
break;
case OSSA_IO_ABORT_RESET:
((ostiFastSSPCb_t)safb->cb)(tiRoot, safb->cbArg, tiIOFailed,
tiDetailAbortReset);
break;
case OSSA_IO_NO_DEVICE:
((ostiFastSSPCb_t)safb->cb)(tiRoot, safb->cbArg, tiIOFailed,
tiDetailNoLogin);
break;
case OSSA_IO_DS_NON_OPERATIONAL:
{
tdsaDeviceData_t *oneDeviceData;
oneDeviceData = (tdsaDeviceData_t*)safb->oneDeviceData;
if (oneDeviceData->valid == agTRUE &&
oneDeviceData->registered == agTRUE &&
oneDeviceData->tdPortContext != agNULL)
{
saSetDeviceState(oneDeviceData->agRoot, agNULL, tdsaRotateQnumber(tiRoot, oneDeviceData),
oneDeviceData->agDevHandle, SA_DS_OPERATIONAL);
}
}
default:
((ostiFastSSPCb_t)safb->cb)(tiRoot, safb->cbArg, tiIOFailed,
tiDetailOtherError);
break;
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "Y6");
ext:
TDSA_OUT_LEAVE((tiRoot_t*)((tdsaRootOsData_t*)agRoot->osData)->tiRoot);
return;
}
#endif
osGLOBAL void ossaSSPReqReceived(
agsaRoot_t *agRoot,
agsaDevHandle_t *agDevHandle,
agsaFrameHandle_t agFrameHandle,
bit16 agInitiatorTag,
bit32 parameter,
bit32 agFrameLen
)
{
tdsaDeviceData_t *pDeviceData = (tdsaDeviceData_t *) agDevHandle->osData;
smTraceFuncEnter(hpDBG_VERY_LOUD,"Y7");
pDeviceData->pJumpTable->pSSPReqReceived (
agRoot,
agDevHandle,
agFrameHandle,
agInitiatorTag,
parameter,
agFrameLen
);
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Y7");
return;
}
osGLOBAL void ossaStallThread(agsaRoot_t *agRoot,
bit32 microseconds
)
{
tdsaRootOsData_t *pOsData = (tdsaRootOsData_t *) (agRoot->osData);
ostiStallThread (
pOsData->tiRoot,
microseconds
);
return;
}
osGLOBAL void ossaSSPEvent(
agsaRoot_t *agRoot,
agsaIORequest_t *agIORequest,
agsaPortContext_t *agPortContext,
agsaDevHandle_t *agDevHandle,
bit32 event,
bit16 sspTag,
bit32 agIOInfoLen,
void *agParam
)
{
#ifdef INITIATOR_DRIVER
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
void *osMemHandle;
tdIORequestBody_t *TMtdIORequestBody;
bit32 PhysUpper32;
bit32 PhysLower32;
bit32 memAllocStatus;
bit32 agRequestType;
agsaIORequest_t *agTMIORequest = agNULL;
agsaSASRequestBody_t *agSASRequestBody = agNULL;
agsaSSPScsiTaskMgntReq_t *agSSPTaskMgntRequest;
bit32 saStatus;
bit32 agIORequestType;
tiIORequest_t *taskTag;
tdIORequestBody_t *tdIORequestBody;
#endif
#ifdef REMOVED
tiDeviceHandle_t *tiDeviceHandle;
tdsaDeviceData_t *oneDeviceData = agNULL;
tdIORequestBody_t *tdAbortIORequestBody;
#endif
agsaDifDetails_t agDifDetails;
bit8 framePayload[256];
#ifdef REMOVED
bit16 frameOffset = 0;
#endif
bit16 frameLen = 0;
TI_DBG6(("ossaSSPEvent: start\n"));
smTraceFuncEnter(hpDBG_VERY_LOUD,"Y9");
if (event == OSSA_IO_XFER_ERROR_CMD_ISSUE_ACK_NAK_TIMEOUT ||
event == OSSA_IO_XFER_ERROR_BREAK ||
event == OSSA_IO_XFER_ERROR_PHY_NOT_READY
)
{
#ifdef INITIATOR_DRIVER
tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
taskTag = tdIORequestBody->tiIORequest;
#endif
#ifdef REMOVED
tiDeviceHandle = tdIORequestBody->tiDevHandle;
oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData;
#endif
#ifdef INITIATOR_DRIVER
agIORequestType = tdIORequestBody->agRequestType;
if (agIORequestType == AGSA_REQ_TYPE_UNKNOWN)
{
TI_DBG1(("ossaSSPEvent: incorrect frame 0x%x. Should be command\n", agIORequestType));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Y9");
return;
}
memAllocStatus = ostiAllocMemory(
tiRoot,
&osMemHandle,
(void **)&TMtdIORequestBody,
&PhysUpper32,
&PhysLower32,
8,
sizeof(tdIORequestBody_t),
agTRUE
);
if (memAllocStatus != tiSuccess)
{
TI_DBG1(("ossaSSPEvent: ostiAllocMemory failed...\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "Y9");
return;
}
if (TMtdIORequestBody == agNULL)
{
TI_DBG1(("ossaSSPEvent: ostiAllocMemory returned NULL TMIORequestBody\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "Y9");
return;
}
TMtdIORequestBody->IOType.InitiatorTMIO.osMemHandle = osMemHandle;
TMtdIORequestBody->IOType.InitiatorTMIO.CurrentTaskTag = agNULL;
TMtdIORequestBody->IOType.InitiatorTMIO.TaskTag = taskTag;
TMtdIORequestBody->IOCompletionFunc = itdssQueryTaskCompleted;
TMtdIORequestBody->tiDevHandle = tdIORequestBody->tiDevHandle;
agTMIORequest = &(TMtdIORequestBody->agIORequest);
agTMIORequest->osData = (void *) TMtdIORequestBody;
agTMIORequest->sdkData = agNULL;
agRequestType = AGSA_SSP_TASK_MGNT_REQ;
TMtdIORequestBody->agRequestType = AGSA_SSP_TASK_MGNT_REQ;
agSASRequestBody = &(TMtdIORequestBody->transport.SAS.agSASRequestBody);
agSSPTaskMgntRequest = &(agSASRequestBody->sspTaskMgntReq);
osti_memset(agSSPTaskMgntRequest->lun, 0, 8);
agSSPTaskMgntRequest->taskMgntFunction = AGSA_QUERY_TASK;
if (TMtdIORequestBody->IOCompletionFunc == agNULL)
{
TI_DBG1(("ossaSSPEvent: Error !!! IOCompletionFunc is NULL\n"));
}
saStatus = saSSPStart(agRoot,
agTMIORequest,
0,
agDevHandle,
agRequestType,
agSASRequestBody,
agIORequest,
&ossaSSPCompleted);
if (saStatus != AGSA_RC_SUCCESS)
{
ostiFreeMemory(
tiRoot,
TMtdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
TI_DBG1(("ossaSSPEvent: saSSPStart failed\n"));
return;
}
#endif
}
#ifdef REMOVED
else if (event == OSSA_IO_ABORTED)
{
TI_DBG2(("ossaSSPEvent: OSSA_IO_ABORTED\n"));
tdAbortIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
}
else if (event == OSSA_IO_NOT_VALID)
{
TI_DBG1(("ossaSSPEvent: OSSA_IO_NOT_VALID\n"));
tdAbortIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
}
#endif
else if (event == OSSA_IO_XFER_CMD_FRAME_ISSUED)
{
TI_DBG2(("ossaSSPEvent: OSSA_IO_XFER_CMD_FRAME_ISSUED\n"));
}
else if (event == OSSA_IO_XFER_ERROR_OFFSET_MISMATCH)
{
TI_DBG1(("ossaSSPEvent: OSSA_IO_XFER_ERROR_OFFSET_MISMATCH\n"));
}
else if (event == OSSA_IO_OVERFLOW)
{
TI_DBG1(("ossaSSPEvent: OSSA_IO_OVERFLOW\n"));
}
else if (event == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED)
{
TI_DBG1(("ossaSSPEvent: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED\n"));
}
else if (event == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_TMO)
{
TI_DBG1(("ossaSSPEvent: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_TMO\n"));
}
else if (event == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST)
{
TI_DBG1(("ossaSSPEvent: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST\n"));
}
else if (event == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE)
{
TI_DBG1(("ossaSSPEvent: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE\n"));
}
else if (event == OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED)
{
TI_DBG1(("ossaSSPEvent: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED\n"));
}
else if (event == OSSA_IO_XFR_ERROR_DEK_KEY_TAG_MISMATCH)
{
TI_DBG1(("ossaSSPEvent: OSSA_IO_XFR_ERROR_DEK_KEY_TAG_MISMATCH\n"));
}
else if (event == OSSA_IO_XFER_ERROR_XFER_RDY_OVERRUN)
{
TI_DBG1(("ossaSSPEvent: OSSA_IO_XFER_ERROR_XFER_RDY_OVERRUN\n"));
}
else if (event == OSSA_IO_XFR_ERROR_DIF_MISMATCH ||
event == OSSA_IO_XFR_ERROR_DIF_APPLICATION_TAG_MISMATCH ||
event == OSSA_IO_XFR_ERROR_DIF_REFERENCE_TAG_MISMATCH ||
event == OSSA_IO_XFR_ERROR_DIF_CRC_MISMATCH )
{
TI_DBG1(("ossaSSPEvent: DIF related, event 0x%x\n", event));
TI_DBG2(("ossaSSPEvent: agIOInfoLen %d\n", agIOInfoLen));
if (agParam == agNULL)
{
TI_DBG2(("ossaSSPEvent: agParam is NULL!!!\n"));
return;
}
if (agIOInfoLen < sizeof(agsaDifDetails_t))
{
TI_DBG2(("ossaSSPEvent: wrong agIOInfoLen!!! agIOInfoLen %d sizeof(agsaDifDetails_t) %d\n", agIOInfoLen, (int)sizeof(agsaDifDetails_t)));
return;
}
saFrameReadBlock(agRoot, agParam, 0, &agDifDetails, sizeof(agsaDifDetails_t));
#ifdef REMOVED
frameOffset = (agDifDetails.ErrBoffsetEDataLen & 0xFFFF);
#endif
frameLen = (bit16)((agDifDetails.ErrBoffsetEDataLen & 0xFFFF0000) >> 16);
TI_DBG2(("ossaSSPEvent: UpperLBA 0x%08x LowerLBA 0x%08x\n", agDifDetails.UpperLBA, agDifDetails.LowerLBA));
TI_DBG2(("ossaSSPEvent: SASAddrHI 0x%08x SASAddrLO 0x%08x\n",
TD_GET_SAS_ADDRESSHI(agDifDetails.sasAddressHi), TD_GET_SAS_ADDRESSLO(agDifDetails.sasAddressLo)));
TI_DBG2(("ossaSSPEvent: DIF error mask 0x%x Device ID 0x%x\n",
(agDifDetails.DIFErrDevID) & 0xFF, (agDifDetails.DIFErrDevID & 0xFFFF0000) >> 16));
if (frameLen != 0 && frameLen <= 256)
{
saFrameReadBlock(agRoot, agParam, sizeof(agsaDifDetails_t), framePayload, frameLen);
tdhexdump("ossaSSPEvent frame", framePayload, frameLen);
}
}
else
{
TI_DBG1(("ossaSSPEvent: other event 0x%x\n", event));
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'd', "Y9");
return;
}
#ifdef FDS_SM
osGLOBAL void ossaSATAIDAbortCB(
agsaRoot_t *agRoot,
agsaIORequest_t *agIORequest,
bit32 flag,
bit32 status)
{
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
tdIORequestBody_t *tdAbortIORequestBody;
TI_DBG1(("ossaSATAIDAbortCB: start flag %d status %d\n", flag, status));
tdAbortIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
return;
}
#endif
#ifdef INITIATOR_DRIVER
osGLOBAL void ossaSSPAbortCB(
agsaRoot_t *agRoot,
agsaIORequest_t *agIORequest,
bit32 flag,
bit32 status)
{
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
tdIORequestBody_t *tdAbortIORequestBody = agNULL;
tdsaDeviceData_t *oneDeviceData = agNULL;
tiDeviceHandle_t *tiDeviceHandle = agNULL;
tiIORequest_t *taskTag = agNULL;
TI_DBG2(("ossaSSPAbortCB: start\n"));
smTraceFuncEnter(hpDBG_VERY_LOUD,"Ya");
tdAbortIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
if (tdAbortIORequestBody == agNULL)
{
TI_DBG1(("ossaSSPAbortCB: tdAbortIORequestBody is NULL warning!!!!\n"));
return;
}
if (flag == 2)
{
TI_DBG1(("ossaSSPAbortCB: abort per port\n"));
}
else if (flag == 1)
{
TI_DBG2(("ossaSSPAbortCB: abort all\n"));
tiDeviceHandle = (tiDeviceHandle_t *)tdAbortIORequestBody->tiDevHandle;
if (tiDeviceHandle == agNULL)
{
TI_DBG1(("ossaSSPAbortCB: tiDeviceHandle is NULL warning!!!!\n"));
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
return;
}
oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData;
if (oneDeviceData == agNULL)
{
TI_DBG1(("ossaSSPAbortCB: oneDeviceData is NULL warning!!!!\n"));
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
return;
}
if (status == OSSA_IO_SUCCESS)
{
TI_DBG2(("ossaSSPAbortCB: OSSA_IO_SUCCESS\n"));
if (oneDeviceData->OSAbortAll == agTRUE)
{
oneDeviceData->OSAbortAll = agFALSE;
ostiInitiatorEvent( tiRoot,
agNULL,
tiDeviceHandle,
tiIntrEventTypeLocalAbort,
tiAbortOK,
agNULL);
}
else
{
TI_DBG2(("ossaSSPAbortCB: calling saDeregisterDeviceHandle\n"));
saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
}
TI_DBG2(("ossaSSPAbortCB: did %d\n", oneDeviceData->id));
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
}
else if (status == OSSA_IO_NOT_VALID)
{
TI_DBG1(("ossaSSPAbortCB: OSSA_IO_NOT_VALID\n"));
if (oneDeviceData->OSAbortAll == agTRUE)
{
oneDeviceData->OSAbortAll = agFALSE;
ostiInitiatorEvent( tiRoot,
agNULL,
tiDeviceHandle,
tiIntrEventTypeLocalAbort,
tiAbortFailed,
agNULL );
}
else
{
TI_DBG2(("ossaSSPAbortCB: calling saDeregisterDeviceHandle\n"));
saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
}
TI_DBG2(("ossaSSPAbortCB: did %d\n", oneDeviceData->id));
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
}
else if (status == OSSA_IO_NO_DEVICE)
{
TI_DBG1(("ossaSSPAbortCB: OSSA_IO_NO_DEVICE\n"));
if (oneDeviceData->OSAbortAll == agTRUE)
{
oneDeviceData->OSAbortAll = agFALSE;
ostiInitiatorEvent( tiRoot,
agNULL,
tiDeviceHandle,
tiIntrEventTypeLocalAbort,
tiAbortInProgress,
agNULL );
}
else
{
TI_DBG2(("ossaSSPAbortCB: calling saDeregisterDeviceHandle\n"));
saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
}
TI_DBG2(("ossaSSPAbortCB: did %d\n", oneDeviceData->id));
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
}
else if (status == OSSA_IO_ABORT_IN_PROGRESS)
{
TI_DBG1(("ossaSSPAbortCB: OSSA_IO_ABORT_IN_PROGRESS\n"));
if (oneDeviceData->OSAbortAll == agTRUE)
{
oneDeviceData->OSAbortAll = agFALSE;
ostiInitiatorEvent( tiRoot,
agNULL,
tiDeviceHandle,
tiIntrEventTypeLocalAbort,
tiAbortInProgress,
agNULL );
}
else
{
TI_DBG2(("ossaSSPAbortCB: calling saDeregisterDeviceHandle\n"));
saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
}
TI_DBG2(("ossaSSPAbortCB: did %d\n", oneDeviceData->id));
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
}
#ifdef REMOVED
else if (status == OSSA_IO_ABORT_DELAYED)
{
TI_DBG1(("ossaSSPAbortCB: OSSA_IO_ABORT_DELAYED\n"));
if (oneDeviceData->OSAbortAll == agTRUE)
{
oneDeviceData->OSAbortAll = agFALSE;
ostiInitiatorEvent( tiRoot,
agNULL,
tiDeviceHandle,
tiIntrEventTypeLocalAbort,
tiAbortDelayed,
agNULL );
}
else
{
TI_DBG2(("ossaSSPAbortCB: calling saDeregisterDeviceHandle\n"));
saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
}
TI_DBG2(("ossaSSPAbortCB: did %d\n", oneDeviceData->id));
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
}
#endif
else
{
TI_DBG1(("ossaSSPAbortCB: other status %d\n", status));
if (oneDeviceData->OSAbortAll == agTRUE)
{
oneDeviceData->OSAbortAll = agFALSE;
ostiInitiatorEvent( tiRoot,
agNULL,
tiDeviceHandle,
tiIntrEventTypeLocalAbort,
tiAbortInProgress,
agNULL );
}
else
{
TI_DBG2(("ossaSSPAbortCB: calling saDeregisterDeviceHandle\n"));
saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
}
TI_DBG2(("ossaSSPAbortCB: did %d\n", oneDeviceData->id));
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
}
}
else if (flag == 0)
{
TI_DBG2(("ossaSSPAbortCB: abort one\n"));
taskTag = tdAbortIORequestBody->tiIOToBeAbortedRequest;
if ( taskTag == agNULL)
{
TI_DBG1(("ossaSSPAbortCB: taskTag is NULL; triggered by itdssQueryTaskCompleted\n"));
}
if (status == OSSA_IO_SUCCESS)
{
TI_DBG2(("ossaSSPAbortCB: OSSA_IO_SUCCESS\n"));
if (taskTag != agNULL)
{
ostiInitiatorEvent( tiRoot,
agNULL,
agNULL,
tiIntrEventTypeLocalAbort,
tiAbortOK,
taskTag );
}
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
}
else if (status == OSSA_IO_NOT_VALID)
{
TI_DBG1(("ossaSSPAbortCB: OSSA_IO_NOT_VALID\n"));
if (taskTag != agNULL)
{
ostiInitiatorEvent( tiRoot,
agNULL,
agNULL,
tiIntrEventTypeLocalAbort,
tiAbortFailed,
taskTag );
}
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
}
else if (status == OSSA_IO_NO_DEVICE)
{
TI_DBG1(("ossaSSPAbortCB: OSSA_IO_NO_DEVICE\n"));
if (taskTag != agNULL)
{
ostiInitiatorEvent( tiRoot,
agNULL,
agNULL,
tiIntrEventTypeLocalAbort,
tiAbortInProgress,
taskTag );
}
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
}
else if (status == OSSA_IO_ABORT_IN_PROGRESS)
{
TI_DBG1(("ossaSSPAbortCB: OSSA_IO_ABORT_IN_PROGRESS\n"));
if (taskTag != agNULL)
{
ostiInitiatorEvent( tiRoot,
agNULL,
agNULL,
tiIntrEventTypeLocalAbort,
tiAbortInProgress,
taskTag );
}
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
}
#ifdef REMOVED
else if (status == OSSA_IO_ABORT_DELAYED)
{
TI_DBG1(("ossaSSPAbortCB: OSSA_IO_ABORT_DELAYED\n"));
if (taskTag != agNULL)
{
ostiInitiatorEvent( tiRoot,
agNULL,
agNULL,
tiIntrEventTypeLocalAbort,
tiAbortDelayed,
taskTag );
}
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
}
#endif
else
{
TI_DBG1(("ossaSSPAbortCB: other status %d\n", status));
if (taskTag != agNULL)
{
ostiInitiatorEvent( tiRoot,
agNULL,
agNULL,
tiIntrEventTypeLocalAbort,
tiAbortFailed,
taskTag );
}
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
}
}
else
{
TI_DBG1(("ossaSSPAbortCB: wrong flag %d\n", flag));
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Ya");
return;
}
#endif
#ifdef TARGET_DRIVER
osGLOBAL void ossaSSPAbortCB(
agsaRoot_t *agRoot,
agsaIORequest_t *agIORequest,
bit32 flag,
bit32 status)
{
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
tdIORequestBody_t *tdAbortIORequestBody;
tdsaDeviceData_t *oneDeviceData;
tiDeviceHandle_t *tiDeviceHandle;
TI_DBG3(("ossaSSPAbortCB: start\n"));
tdAbortIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
if (flag == 2)
{
TI_DBG2(("ossaSSPAbortCB: abort per port\n"));
}
else if (flag == 1)
{
TI_DBG2(("ossaSSPAbortCB: abort all\n"));
tiDeviceHandle = (tiDeviceHandle_t *)tdAbortIORequestBody->tiDevHandle;
oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData;
if (status == OSSA_IO_SUCCESS)
{
TI_DBG2(("ossaSSPAbortCB: OSSA_IO_SUCCESS\n"));
TI_DBG3(("ossaSSPAbortCB: calling saDeregisterDeviceHandle\n"));
saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
TI_DBG2(("ossaSSPAbortCB: did %d\n", oneDeviceData->id));
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
}
else if (status == OSSA_IO_NOT_VALID)
{
TI_DBG1(("ossaSSPAbortCB: OSSA_IO_NOT_VALID\n"));
TI_DBG2(("ossaSSPAbortCB: calling saDeregisterDeviceHandle\n"));
saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
TI_DBG2(("ossaSSPAbortCB: did %d\n", oneDeviceData->id));
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
}
else if (status == OSSA_IO_NO_DEVICE)
{
TI_DBG1(("ossaSSPAbortCB: OSSA_IO_NO_DEVICE\n"));
TI_DBG2(("ossaSSPAbortCB: calling saDeregisterDeviceHandle\n"));
saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
TI_DBG2(("ossaSSPAbortCB: did %d\n", oneDeviceData->id));
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
}
else if (status == OSSA_IO_ABORT_IN_PROGRESS)
{
TI_DBG1(("ossaSSPAbortCB: OSSA_IO_ABORT_IN_PROGRESS\n"));
TI_DBG2(("ossaSSPAbortCB: calling saDeregisterDeviceHandle\n"));
saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
TI_DBG2(("ossaSSPAbortCB: did %d\n", oneDeviceData->id));
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
}
#ifdef REMOVED
else if (status == OSSA_IO_ABORT_DELAYED)
{
TI_DBG1(("ossaSSPAbortCB: OSSA_IO_ABORT_DELAYED\n"));
TI_DBG2(("ossaSSPAbortCB: calling saDeregisterDeviceHandle\n"));
saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
TI_DBG2(("ossaSSPAbortCB: did %d\n", oneDeviceData->id));
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
}
#endif
else
{
TI_DBG1(("ossaSSPAbortCB: other status %d\n", status));
TI_DBG2(("ossaSSPAbortCB: calling saDeregisterDeviceHandle\n"));
saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
TI_DBG1(("ossaSSPAbortCB: did %d\n", oneDeviceData->id));
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
}
}
else if (flag == 0)
{
TI_DBG2(("ossaSSPAbortCB: abort one\n"));
if (status == OSSA_IO_SUCCESS)
{
TI_DBG2(("ossaSSPAbortCB: OSSA_IO_SUCCESS\n"));
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
}
else if (status == OSSA_IO_NOT_VALID)
{
TI_DBG1(("ossaSSPAbortCB: OSSA_IO_NOT_VALID\n"));
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
}
else if (status == OSSA_IO_NO_DEVICE)
{
TI_DBG1(("ossaSSPAbortCB: OSSA_IO_NO_DEVICE\n"));
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
}
else if (status == OSSA_IO_ABORT_IN_PROGRESS)
{
TI_DBG1(("ossaSSPAbortCB: OSSA_IO_ABORT_IN_PROGRESS\n"));
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
}
#ifdef REMOVED
else if (status == OSSA_IO_ABORT_DELAYED)
{
TI_DBG1(("ossaSSPAbortCB: OSSA_IO_ABORT_DELAYED\n"));
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
}
#endif
else
{
TI_DBG1(("ossaSSPAbortCB: other status %d\n", status));
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
}
}
else
{
TI_DBG1(("ossaSSPAbortCB: wrong flag %d\n", flag));
}
return;
}
#endif
osGLOBAL void ossaLocalPhyControlCB(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 phyId,
bit32 phyOperation,
bit32 status,
void *parm
)
{
#ifdef REMVOED
agsaPhyErrCounters_t *agPhyErrCounters;
#endif
#ifdef INITIATOR_DRIVER
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
tiIORequest_t *currentTaskTag;
tdsaDeviceData_t *TargetDeviceData;
satDeviceData_t *pSatDevData;
agsaDevHandle_t *agDevHandle = agNULL;
agsaContext_t *agContextDevice;
#endif
smTraceFuncEnter(hpDBG_VERY_LOUD,"Yb");
TI_DBG3(("ossaLocalPhyControlCB: start phyID %d\n", phyId));
TI_DBG3(("ossaLocalPhyControlCB: phyOperation %d status 0x%x\n", phyOperation, status));
switch (phyOperation)
{
case AGSA_PHY_LINK_RESET:
case AGSA_PHY_HARD_RESET:
if (phyOperation == AGSA_PHY_LINK_RESET)
{
TI_DBG1(("ossaLocalPhyControlCB: AGSA_PHY_LINK_RESET, status 0x%x\n", status));
}
else
{
TI_DBG1(("ossaLocalPhyControlCB: AGSA_PHY_HARD_RESET, status 0x%x\n", status));
}
#ifdef INITIATOR_DRIVER
if (agContext != agNULL)
{
currentTaskTag = (tiIORequest_t *)agContext->osData;
if (status == OSSA_SUCCESS)
{
if (currentTaskTag != agNULL)
{
TI_DBG2(("ossaLocalPhyControlCB: callback to OS layer with success\n"));
TargetDeviceData = (tdsaDeviceData_t *)currentTaskTag->tdData;
pSatDevData = (satDeviceData_t *)&(TargetDeviceData->satDevData);
agDevHandle = TargetDeviceData->agDevHandle;
TI_DBG2(("ossaLocalPhyControlCB: satPendingIO %d satNCQMaxIO %d\n", pSatDevData->satPendingIO, pSatDevData->satNCQMaxIO ));
TI_DBG2(("ossaLocalPhyControlCB: satPendingNCQIO %d satPendingNONNCQIO %d\n", pSatDevData->satPendingNCQIO, pSatDevData->satPendingNONNCQIO));
pSatDevData->satDriveState = SAT_DEV_STATE_NORMAL;
if (TargetDeviceData->TRflag == agTRUE)
{
saSetDeviceState(agRoot, agNULL, tdsaRotateQnumber(tiRoot, TargetDeviceData), agDevHandle, SA_DS_OPERATIONAL);
TargetDeviceData->TRflag = agFALSE;
ostiInitiatorEvent(tiRoot,
TargetDeviceData->tdPortContext->tiPortalContext,
&(TargetDeviceData->tiDeviceHandle),
tiIntrEventTypeTransportRecovery,
tiRecOK,
agNULL
);
}
else
{
agDevHandle = TargetDeviceData->agDevHandle;
if (agDevHandle == agNULL)
{
TI_DBG1(("ossaLocalPhyControlCB: wrong, agDevHandle is NULL\n"));
}
agContextDevice = &(TargetDeviceData->agDeviceResetContext);
agContextDevice->osData = currentTaskTag;
#ifdef REMOVED
ostiInitiatorEvent( tiRoot,
NULL,
NULL,
tiIntrEventTypeTaskManagement,
tiTMOK,
currentTaskTag );
#endif
}
}
}
else
{
if (currentTaskTag != agNULL)
{
TI_DBG1(("ossaLocalPhyControlCB: callback to OS layer with failure\n"));
TargetDeviceData = (tdsaDeviceData_t *)currentTaskTag->tdData;
pSatDevData = (satDeviceData_t *)&(TargetDeviceData->satDevData);
TI_DBG1(("ossaLocalPhyControlCB: satPendingIO %d satNCQMaxIO %d\n", pSatDevData->satPendingIO, pSatDevData->satNCQMaxIO ));
TI_DBG1(("ossaLocalPhyControlCB: satPendingNCQIO %d satPendingNONNCQIO %d\n", pSatDevData->satPendingNCQIO, pSatDevData->satPendingNONNCQIO));
if (TargetDeviceData->TRflag == agTRUE)
{
TargetDeviceData->TRflag = agFALSE;
ostiInitiatorEvent(tiRoot,
TargetDeviceData->tdPortContext->tiPortalContext,
&(TargetDeviceData->tiDeviceHandle),
tiIntrEventTypeTransportRecovery,
tiRecFailed ,
agNULL
);
}
else
{
ostiInitiatorEvent( tiRoot,
NULL,
NULL,
tiIntrEventTypeTaskManagement,
tiTMFailed,
currentTaskTag );
}
}
}
}
#endif
break;
#ifdef REMOVED
case AGSA_PHY_GET_ERROR_COUNTS:
TI_DBG2(("ossaLocalPhyControlCB: AGSA_PHY_GET_ERROR_COUNTS, status 0x%x\n", status));
if(parm !=agNULL )
{
agPhyErrCounters = (agsaPhyErrCounters_t *)parm;
TI_DBG2(("ossaLocalPhyControlCB: invalidDword %d\n", agPhyErrCounters->invalidDword));
TI_DBG2(("ossaLocalPhyControlCB: runningDisparityError %d\n", agPhyErrCounters->runningDisparityError));
TI_DBG2(("ossaLocalPhyControlCB: lostOfDwordSynch %d\n", agPhyErrCounters->lossOfDwordSynch));
TI_DBG2(("ossaLocalPhyControlCB: phyResetProblem %d\n", agPhyErrCounters->phyResetProblem));
TI_DBG2(("ossaLocalPhyControlCB: elasticityBufferOverflow %d\n", agPhyErrCounters->elasticityBufferOverflow));
TI_DBG2(("ossaLocalPhyControlCB: receivedErrorPrimitive %d\n", agPhyErrCounters->receivedErrorPrimitive));
}
break;
case AGSA_PHY_CLEAR_ERROR_COUNTS:
TI_DBG2(("ossaLocalPhyControlCB: AGSA_PHY_CLEAR_ERROR_COUNTS, status 0x%x\n", status));
break;
#endif
case AGSA_PHY_NOTIFY_ENABLE_SPINUP:
TI_DBG2(("ossaLocalPhyControlCB: AGSA_PHY_NOTIFY_ENABLE_SPINUP, status 0x%x\n", status));
break;
case AGSA_PHY_BROADCAST_ASYNCH_EVENT:
TI_DBG2(("ossaLocalPhyControlCB: AGSA_PHY_BROADCAST_ASYNCH_EVENT, status 0x%x\n", status));
if (tIsSPC12SATA(agRoot))
{
TI_DBG1(("ossaLocalPhyControlCB: BROADCAST_ASYNCH_EVENT received for SATA Controller\n"));
break;
}
break;
case AGSA_PHY_COMINIT_OOB :
TI_DBG2(("ossaLocalPhyControlCB: AGSA_PHY_COMINIT_OOB, status 0x%x\n", status));
break;
default:
TI_DBG1(("ossaLocalPhyControlCB: UNKNOWN default case. phyOperation %d status 0x%x\n", phyOperation, status));
break;
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yb");
return;
}
GLOBAL void ossaGetPhyProfileCB(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 status,
bit32 ppc,
bit32 phyID,
void *parm )
{
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
#ifdef CCFLAGS_PHYCONTROL_COUNTS
agsaPhyAnalogSettingsPage_t *analog;
#endif
tdPhyCount_t *PhyBlob = agNULL;
agsaPhyBWCountersPage_t *agBWCounters;
agsaPhyErrCountersPage_t *agPhyErrCounters;
TI_DBG1(("ossaGetPhyProfileCB: agContext %p parm %p\n", agContext, parm));
switch(ppc)
{
case AGSA_SAS_PHY_BW_COUNTERS_PAGE:
TI_DBG1(("ossaGetPhyProfileCB: AGSA_SAS_PHY_BW_COUNTERS_PAGE, status 0x%x phyID %d\n", status, phyID));
if(parm !=agNULL )
{
agBWCounters = (agsaPhyBWCountersPage_t *)parm;
TI_DBG1(("ossaGetPhyProfileCB: RX %d TX %d\n", agBWCounters->RXBWCounter,agBWCounters->TXBWCounter));
if(PhyBlob !=agNULL )
{
PhyBlob->InvalidDword = 0;
PhyBlob->runningDisparityError = 0;
PhyBlob->codeViolation = 0;
PhyBlob->phyResetProblem = 0;
PhyBlob->inboundCRCError = 0;
PhyBlob->BW_rx = agBWCounters->RXBWCounter;
PhyBlob->BW_tx = agBWCounters->TXBWCounter;
}
}
break;
case AGSA_SAS_PHY_ERR_COUNTERS_PAGE:
if( tdsaAllShared->tdFWControlEx.inProgress )
{
tdsaAllShared->tdFWControlEx.inProgress = 0;
PhyBlob = (tdPhyCount_t *)tdsaAllShared->tdFWControlEx.usrAddr;
}
TI_DBG1(("ossaGetPhyProfileCB: AGSA_SAS_PHY_ERR_COUNTERS_PAGE, status 0x%x phyID %d\n", status, phyID));
if(parm !=agNULL )
{
agPhyErrCounters = (agsaPhyErrCountersPage_t *)parm;
if(PhyBlob !=agNULL )
{
PhyBlob->InvalidDword = agPhyErrCounters->invalidDword;
PhyBlob->runningDisparityError = agPhyErrCounters->runningDisparityError;
PhyBlob->LossOfSyncDW = agPhyErrCounters->lossOfDwordSynch;
PhyBlob->codeViolation = agPhyErrCounters->codeViolation;
PhyBlob->phyResetProblem = agPhyErrCounters->phyResetProblem;
PhyBlob->inboundCRCError = agPhyErrCounters->inboundCRCError;
PhyBlob->BW_rx = 0;
PhyBlob->BW_tx = 0;
TI_DBG2(("ossaGetPhyProfileCB: invalidDword %d\n", agPhyErrCounters->invalidDword));
TI_DBG2(("ossaGetPhyProfileCB: runningDisparityError %d\n", agPhyErrCounters->runningDisparityError));
TI_DBG2(("ossaGetPhyProfileCB: lostOfDwordSynch %d\n", agPhyErrCounters->lossOfDwordSynch));
TI_DBG2(("ossaGetPhyProfileCB: phyResetProblem %d\n", agPhyErrCounters->phyResetProblem));
TI_DBG2(("ossaGetPhyProfileCB: inboundCRCError %d\n", agPhyErrCounters->inboundCRCError));
}
}
break;
case AGSA_SAS_PHY_ERR_COUNTERS_CLR_PAGE:
TI_DBG1(("ossaGetPhyProfileCB: AGSA_SAS_PHY_ERR_COUNTERS_CLR_PAGE status 0x%x phyID %d\n", status, phyID));
break;
case AGSA_SAS_PHY_ANALOG_SETTINGS_PAGE:
TI_DBG1(("ossaGetPhyProfileCB:AGSA_SAS_PHY_ANALOG_SETTINGS_PAGE status 0x%x phyID %d\n", status, phyID));
#ifdef CCFLAGS_PHYCONTROL_COUNTS
if(parm !=agNULL )
{
analog = (agsaPhyAnalogSettingsPage_t *)parm;
TI_DBG1(("ossaGetPhyProfileCB: 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n",
analog->Dword0, analog->Dword1, analog->Dword2, analog->Dword3, analog->Dword4,
analog->Dword5, analog->Dword6, analog->Dword7, analog->Dword8, analog->Dword9));
tdsaAllShared->analog[phyID].spaRegister0 = analog->Dword0;
tdsaAllShared->analog[phyID].spaRegister1 = analog->Dword1;
tdsaAllShared->analog[phyID].spaRegister2 = analog->Dword2;
tdsaAllShared->analog[phyID].spaRegister3 = analog->Dword3;
tdsaAllShared->analog[phyID].spaRegister4 = analog->Dword4;
saSetPhyProfile( agRoot,agContext,tdsaRotateQnumber(tiRoot, agNULL), AGSA_SAS_PHY_ANALOG_SETTINGS_PAGE,sizeof(agsaPhyAnalogSetupRegisters_t),&tdsaAllShared->analog[phyID],phyID);
}
#endif
break;
case AGSA_SAS_PHY_OPEN_REJECT_RETRY_BACKOFF_THRESHOLD_PAGE:
{
TI_DBG1(("ossaGetPhyProfileCB:AGSA_SAS_PHY_OPEN_REJECT_RETRY_BACKOFF_THRESHOLD_PAGE status 0x%x phyID %d\n", status, phyID));
if( parm !=agNULL )
{
#ifdef TD_DEBUG_ENABLE
agsaSASPhyOpenRejectRetryBackOffThresholdPage_t *Backoff =
(agsaSASPhyOpenRejectRetryBackOffThresholdPage_t *)parm;
#endif
TI_DBG2(("ossaGetPhyProfileCB: DW0 0x%X DW1 0x%X DW2 0x%X DW3 0x%X\n",
Backoff->Dword0,Backoff->Dword1,
Backoff->Dword2,Backoff->Dword3));
}
break;
}
case AGSA_SAS_PHY_GENERAL_STATUS_PAGE:
{
agsaSASPhyGeneralStatusPage_t * GenStatus = NULL;
TI_DBG1(("ossaGetPhyProfileCB: AGSA_SAS_PHY_GENERAL_STATUS_PAGE status 0x%x phyID %d\n",
status, phyID));
if( parm !=agNULL )
{
GenStatus=
(agsaSASPhyGeneralStatusPage_t *)parm;
TI_DBG2(("ossaGetPhyProfileCB: "
"AGSA_SAS_PHY_GENERAL_STATUS_PAGE status %d DW0 0x%x DW1 0x%x\n",
status, GenStatus->Dword0, GenStatus->Dword1));
}
ostiGetPhyGeneralStatusRsp(tiRoot, GenStatus, phyID);
return ;
}
default:
TI_DBG1(("ossaGetPhyProfileCB: UNKNOWN default case. phyOperation %d status 0x%x\n", ppc, status));
break;
}
ostiGetPhyProfileIOCTLRsp(tiRoot, status);
}
GLOBAL void ossaSetPhyProfileCB(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 status,
bit32 ppc,
bit32 phyID,
void *parm )
{
TI_DBG1(("ossaSetPhyProfileCB:agContext %p status 0x%x ppc %d phyID %d parm %p\n",agContext, status, ppc, phyID,parm));
}
osGLOBAL void ossaGetDeviceHandlesCB(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
agsaPortContext_t *agPortContext,
agsaDevHandle_t *agDev[],
bit32 validDevs
)
{
TI_DBG2(("ossaGetDeviceHandlesCB: start\n"));
TI_DBG2(("ossaGetDeviceHandlesCB: validDevs %d\n", validDevs));
smTraceFuncEnter(hpDBG_VERY_LOUD,"Yc");
#ifdef TO_DO
for (i = 0 ; i < validDevs ; i++)
{
agDev[i];
}
#endif
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yc");
return;
}
osGLOBAL void ossaGetDeviceInfoCB(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
agsaDevHandle_t *agDevHandle,
bit32 status,
void *agInfo
)
{
#ifdef TD_DEBUG_ENABLE
agsaDeviceInfo_t *agDeviceInfo;
agsaSASDeviceInfo_t *agSASDeviceInfo;
agsaSATADeviceInfo_t *agSATADeviceInfo;
#endif
smTraceFuncEnter(hpDBG_VERY_LOUD,"Yd");
TI_DBG1(("ossaGetDeviceInfoCB: start agContext %p\n",agContext));
switch (status)
{
case OSSA_DEV_INFO_INVALID_HANDLE:
TI_DBG1(("ossaGetDeviceInfoCB: OSSA_DEV_INFO_INVALID_HANDLE\n"));
break;
case OSSA_DEV_INFO_NO_EXTENDED_INFO:
#ifdef TD_DEBUG_ENABLE
agDeviceInfo = (agsaDeviceInfo_t *)agInfo;
#endif
TI_DBG1(("ossaGetDeviceInfoCB: OSSA_DEV_INFO_NO_EXTENDED_INFO\n"));
TI_DBG1(("ossaGetDeviceInfoCB: sasAddressHi 0x%08x\n", SA_DEVINFO_GET_SAS_ADDRESSHI(agDeviceInfo)));
TI_DBG1(("ossaGetDeviceInfoCB: sasAddressLo 0x%08x\n", SA_DEVINFO_GET_SAS_ADDRESSLO(agDeviceInfo)));
TI_DBG1(("ossaGetDeviceInfoCB: devType_S_Rate 0x%08x\n", agDeviceInfo->devType_S_Rate));
TI_DBG1(("ossaGetDeviceInfoCB: firstBurstSize 0x%08x\n", agDeviceInfo->firstBurstSize));
break;
case OSSA_DEV_INFO_SAS_EXTENDED_INFO:
#ifdef TD_DEBUG_ENABLE
agSASDeviceInfo = (agsaSASDeviceInfo_t *)agInfo;
#endif
TI_DBG2(("ossaGetDeviceInfoCB: OSSA_DEV_INFO_SAS_EXTENDED_INFO\n"));
TI_DBG2(("ossaGetDeviceInfoCB: sasAddressHi 0x%08x\n", SA_DEVINFO_GET_SAS_ADDRESSHI(&agSASDeviceInfo->commonDevInfo)));
TI_DBG2(("ossaGetDeviceInfoCB: sasAddressLo 0x%08x\n", SA_DEVINFO_GET_SAS_ADDRESSLO(&agSASDeviceInfo->commonDevInfo)));
TI_DBG2(("ossaGetDeviceInfoCB: initiator_ssp_stp_smp %d\n", agSASDeviceInfo->initiator_ssp_stp_smp));
TI_DBG2(("ossaGetDeviceInfoCB: target_ssp_stp_smp %d\n", agSASDeviceInfo->target_ssp_stp_smp));
TI_DBG2(("ossaGetDeviceInfoCB: numOfPhys %d\n", agSASDeviceInfo->numOfPhys));
TI_DBG2(("ossaGetDeviceInfoCB: phyIdentifier %d\n", agSASDeviceInfo->phyIdentifier));
break;
case OSSA_DEV_INFO_SATA_EXTENDED_INFO:
#ifdef TD_DEBUG_ENABLE
agSATADeviceInfo = (agsaSATADeviceInfo_t *)agInfo;
#endif
TI_DBG2(("ossaGetDeviceInfoCB: OSSA_DEV_INFO_SATA_EXTENDED_INFO\n"));
TI_DBG2(("ossaGetDeviceInfoCB: sasAddressHi 0x%08x\n", SA_DEVINFO_GET_SAS_ADDRESSHI(&agSATADeviceInfo->commonDevInfo)));
TI_DBG2(("ossaGetDeviceInfoCB: sasAddressLo 0x%08x\n", SA_DEVINFO_GET_SAS_ADDRESSLO(&agSATADeviceInfo->commonDevInfo)));
TI_DBG2(("ossaGetDeviceInfoCB: connection %d\n", agSATADeviceInfo->connection));
TI_DBG2(("ossaGetDeviceInfoCB: portMultiplierField %d\n", agSATADeviceInfo->portMultiplierField));
TI_DBG2(("ossaGetDeviceInfoCB: stpPhyIdentifier %d\n", agSATADeviceInfo->stpPhyIdentifier));
#ifdef TD_DEBUG_ENABLE
tdhexdump("ossaGetDeviceInfoCB: signature", (bit8 *)agSATADeviceInfo->signature, 8);
#endif
break;
default:
TI_DBG2(("ossaGetDeviceInfoCB: error default case, status is %d\n", status));
break;
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yd");
return;
}
osGLOBAL void ossaDeviceRegistrationCB(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 status,
agsaDevHandle_t *agDevHandle,
bit32 deviceID
)
{
#ifdef INITIATOR_DRIVER
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
bit32 Indenom = tdsaAllShared->QueueConfig.numInboundQueues;
bit32 Outdenom = tdsaAllShared->QueueConfig.numOutboundQueues;
tdsaDeviceData_t *oneDeviceData = (tdsaDeviceData_t *)agContext->osData;
tdsaPortContext_t *onePortContext = oneDeviceData->tdPortContext;
tiPortalContext_t *tiPortalContext = onePortContext->tiPortalContext;
#ifdef FDS_DM
dmRoot_t *dmRoot = &(tdsaAllShared->dmRoot);
dmPortContext_t *dmPortContext = &(onePortContext->dmPortContext);
dmDeviceInfo_t dmDeviceInfo;
bit32 DMstatus = DM_RC_FAILURE;
bit16 ext = 0;
bit32 expanderType = 1;
#endif
#if defined(FDS_DM) && !defined(FDS_SM)
bit32 IDstatus;
#endif
#ifdef FDS_SM
smRoot_t *smRoot = &(tdsaAllShared->smRoot);
bit32 SMstatus = SM_RC_FAILURE;
#endif
smTraceFuncEnter(hpDBG_VERY_LOUD,"Ye");
TI_DBG3(("ossaDeviceRegistrationCB: start status 0x%x\n",status));
TI_DBG3(("ossaDeviceRegistrationCB: device AddrHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi));
TI_DBG3(("ossaDeviceRegistrationCB: device AddrLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo));
TI_DBG3(("ossaDeviceRegistrationCB: did 0x%x\n", oneDeviceData->id));
TI_DBG3(("ossaDeviceRegistrationCB: deviceID 0x%x\n", deviceID));
TI_DBG3(("ossaDeviceRegistrationCB: agDevHandle %p %p %p\n",agDevHandle,agDevHandle->osData,agDevHandle->sdkData ));
if (oneDeviceData->valid == agFALSE && oneDeviceData->valid2 == agFALSE
&& oneDeviceData->DeviceType == TD_DEFAULT_DEVICE)
{
if (status == OSSA_SUCCESS)
{
TI_DBG2(("ossaDeviceRegistrationCB: transient, calling saDeregisterDeviceHandle, did %d\n", oneDeviceData->id));
oneDeviceData->agDevHandle = agDevHandle;
agDevHandle->osData = oneDeviceData;
if (DEVICE_IS_SATA_DEVICE(oneDeviceData) || DEVICE_IS_STP_TARGET(oneDeviceData))
{
if (oneDeviceData->satDevData.IDDeviceValid == agFALSE)
{
saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, 0);
}
else
{
saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
}
}
else
{
saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
}
}
else if (status == OSSA_FAILURE_PORT_NOT_VALID_STATE || status == OSSA_ERR_PORT_STATE_NOT_VALID)
{
TI_DBG2(("ossaDeviceRegistrationCB: transient, do nothing did %d\n", oneDeviceData->id));
}
return;
}
if (agDevHandle == agNULL)
{
TI_DBG3(("ossaDeviceRegistrationCB: agDevHandle is NULL\n"));
}
else
{
TI_DBG3(("ossaDeviceRegistrationCB: agDevHandle is NOT NULL\n"));
}
switch (status)
{
case OSSA_SUCCESS:
TI_DBG3(("ossaDeviceRegistrationCB: success\n"));
TI_DBG2(("ossaDeviceRegistrationCB: Success did %d FW did 0x%x\n", oneDeviceData->id, deviceID));
TI_DBG2(("ossaDeviceRegistrationCB: Success pid %d\n", onePortContext->id));
if (agDevHandle == agNULL)
{
TI_DBG1(("ossaDeviceRegistrationCB: agDevHandle is NULL, wrong!\n"));
return;
}
oneDeviceData->agDevHandle = agDevHandle;
agDevHandle->osData = oneDeviceData;
oneDeviceData->registered = agTRUE;
oneDeviceData->InQID = oneDeviceData->id % Indenom;
oneDeviceData->OutQID = oneDeviceData->id % Outdenom;
onePortContext->RegisteredDevNums++;
TI_DBG3(("ossaDeviceRegistrationCB: direct %d STP target %d target_ssp_stp_smp %d\n", oneDeviceData->directlyAttached, DEVICE_IS_STP_TARGET(oneDeviceData), oneDeviceData->target_ssp_stp_smp));
TI_DBG3(("ossaDeviceRegistrationCB: pid %d registeredNumDevice %d\n", onePortContext->id, onePortContext->RegisteredDevNums));
TI_DBG3(("ossaDeviceRegistrationCB: pid %d Count %d\n", onePortContext->id, onePortContext->Count));
#ifdef FDS_DM
if (onePortContext->valid == agTRUE)
{
if (DEVICE_IS_SMP_TARGET(oneDeviceData))
{
TI_DBG1(("ossaDeviceRegistrationCB: calling dmRegisterDevice\n"));
TI_DBG1(("ossaDeviceRegistrationCB: device AddrHi 0x%08x\n", oneDeviceData->SASAddressID.sasAddressHi));
TI_DBG1(("ossaDeviceRegistrationCB: device AddrLo 0x%08x\n", oneDeviceData->SASAddressID.sasAddressLo));
osti_memset(&dmDeviceInfo, 0, sizeof(dmDeviceInfo_t));
DEVINFO_PUT_SAS_ADDRESSLO(&dmDeviceInfo, oneDeviceData->SASAddressID.sasAddressLo);
DEVINFO_PUT_SAS_ADDRESSHI(&dmDeviceInfo, oneDeviceData->SASAddressID.sasAddressHi);
dmDeviceInfo.initiator_ssp_stp_smp = oneDeviceData->initiator_ssp_stp_smp;
dmDeviceInfo.target_ssp_stp_smp = oneDeviceData->target_ssp_stp_smp;
dmDeviceInfo.devType_S_Rate = oneDeviceData->agDeviceInfo.devType_S_Rate;
if (oneDeviceData->directlyAttached == agTRUE)
{
ext = (bit16)(ext | 0x100);
expanderType = SA_IDFRM_GET_DEVICETTYPE(&onePortContext->sasIDframe);
ext = (bit16)( ext | (expanderType << 9));
ext = (bit16)(ext | (bit16)(0xF << 11));
TI_DBG1(("ossaDeviceRegistrationCB: directlyAttached ext 0x%x\n", ext));
dmDeviceInfo.ext = ext;
}
DMstatus = dmRegisterDevice(dmRoot, dmPortContext, &dmDeviceInfo, oneDeviceData->agDevHandle);
if (DMstatus != DM_RC_SUCCESS)
{
TI_DBG1(("ossaDeviceRegistrationCB: dmRegisterDevice failed!!! 0x%x\n", DMstatus));
}
}
}
#endif
#ifdef FDS_SM
if (onePortContext->valid == agTRUE)
{
if (DEVICE_IS_SATA_DEVICE(oneDeviceData) || DEVICE_IS_STP_TARGET(oneDeviceData))
{
TI_DBG1(("ossaDeviceRegistrationCB: calling smRegisterDevice\n"));
if (oneDeviceData->directlyAttached == agTRUE)
{
SMstatus = smRegisterDevice(smRoot,
agDevHandle,
&(oneDeviceData->smDeviceHandle),
agNULL,
(bit32)oneDeviceData->phyID,
oneDeviceData->satDevData.satDeviceType);
}
else
{
if (oneDeviceData->ExpDevice == agNULL)
{
TI_DBG1(("ossaDeviceRegistrationCB: oneDeviceData->ExpDevice NULL!!!\n"));
return;
}
if (oneDeviceData->ExpDevice->agDevHandle == agNULL)
{
TI_DBG1(("ossaDeviceRegistrationCB: oneDeviceData->ExpDevice->agDevHandle NULL!!!\n"));
}
SMstatus = smRegisterDevice(smRoot,
agDevHandle,
&(oneDeviceData->smDeviceHandle),
oneDeviceData->ExpDevice->agDevHandle,
(bit32)oneDeviceData->phyID,
oneDeviceData->satDevData.satDeviceType);
}
if (SMstatus != SM_RC_SUCCESS)
{
TI_DBG1(("ossaDeviceRegistrationCB: smRegisterDevice failed!!! 0x%x\n", DMstatus));
}
}
}
#endif
if (oneDeviceData->directlyAttached == agTRUE)
{
TI_DBG3(("ossaDeviceRegistrationCB: directly attached did %d\n", oneDeviceData->id));
if (oneDeviceData->DeviceType == TD_SAS_DEVICE)
{
TI_DBG3(("ossaDeviceRegistrationCB: SAS target\n"));
if (onePortContext->valid == agTRUE)
{
if (onePortContext->PortRecoverPhyID != 0xFF)
{
oneDeviceData->phyID = (bit8)onePortContext->PortRecoverPhyID;
onePortContext->PortRecoverPhyID = 0xFF;
TI_DBG3(("ossaDeviceRegistrationCB: PortRecoverPhyID %d\n", oneDeviceData->phyID));
}
if (onePortContext->DiscoveryRdyGiven == agFALSE)
{
TI_DBG2(("ossaDeviceRegistrationCB: link up and discovery ready\n"));
TI_DBG3(("ossaDeviceRegistrationCB: phyID %d pid %d\n", oneDeviceData->phyID, onePortContext->id));
TI_DBG3(("ossaDeviceRegistrationCB: tiPortalContext %p\n", tdsaAllShared->Ports[oneDeviceData->phyID].tiPortalContext));
TI_DBG3(("ossaDeviceRegistrationCB: onePortContext->tiPortalContext %p\n", onePortContext->tiPortalContext));
onePortContext->DiscoveryRdyGiven = agTRUE;
if (onePortContext->DiscoveryState != ITD_DSTATE_NOT_STARTED)
{
TI_DBG1(("ossaDeviceRegistrationCB: wrong discovery state 0x%x\n", onePortContext->DiscoveryState));
}
ostiPortEvent (
tiRoot,
tiPortLinkUp,
tiSuccess,
(void *)onePortContext->tiPortalContext
);
#ifdef INITIATOR_DRIVER
ostiPortEvent(
tiRoot,
tiPortDiscoveryReady,
tiSuccess,
(void *)onePortContext->tiPortalContext
);
#endif
}
}
else
{
TI_DBG2(("ossaDeviceRegistrationCB: abort call\n"));
tdsaAbortAll(tiRoot, agRoot, oneDeviceData);
}
}
else
{
TI_DBG2(("ossaDeviceRegistrationCB: SATA target\n"));
if (onePortContext->valid == agTRUE)
{
if (oneDeviceData->satDevData.IDDeviceValid == agFALSE)
{
#ifdef FDS_SM
tdIDStart(tiRoot, agRoot, smRoot, oneDeviceData, onePortContext);
#else
tdssSubAddSATAToSharedcontext(tiRoot, oneDeviceData);
#endif
}
}
else
{
TI_DBG2(("ossaDeviceRegistrationCB: abort call\n"));
tdsaAbortAll(tiRoot, agRoot, oneDeviceData);
}
}
}
else
{
#if defined(FDS_DM) && defined(FDS_SM)
if ( (DEVICE_IS_SATA_DEVICE(oneDeviceData) || DEVICE_IS_STP_TARGET(oneDeviceData))
&&
oneDeviceData->satDevData.IDDeviceValid == agFALSE)
{
tdIDStart(tiRoot, agRoot, smRoot, oneDeviceData, onePortContext);
}
#elif defined(FDS_DM)
if ( (DEVICE_IS_SATA_DEVICE(oneDeviceData) || DEVICE_IS_STP_TARGET(oneDeviceData))
&&
oneDeviceData->satDevData.IDDeviceValid == agFALSE)
{
IDstatus = tdsaDiscoveryStartIDDev(tiRoot,
agNULL,
&(oneDeviceData->tiDeviceHandle),
agNULL,
oneDeviceData);
if (IDstatus != tiSuccess)
{
TI_DBG1(("ossaDeviceRegistrationCB: fail or busy %d\n", IDstatus));
oneDeviceData->satDevData.IDDeviceValid = agFALSE;
}
}
#endif
}
if (onePortContext->DiscoveryState == ITD_DSTATE_COMPLETED)
{
TI_DBG2(("ossaDeviceRegistrationCB: calling new device arrival\n"));
if (DEVICE_IS_SSP_TARGET(oneDeviceData))
{
#ifdef AGTIAPI_CTL
if (tdsaAllShared->SASConnectTimeLimit)
tdsaCTLSet(tiRoot, onePortContext, tiIntrEventTypeDeviceChange,
tiDeviceArrival);
else
#endif
ostiInitiatorEvent(
tiRoot,
tiPortalContext,
agNULL,
tiIntrEventTypeDeviceChange,
tiDeviceArrival,
agNULL
);
}
else if ( (DEVICE_IS_SATA_DEVICE(oneDeviceData) || DEVICE_IS_STP_TARGET(oneDeviceData))
&&
oneDeviceData->satDevData.IDDeviceValid == agTRUE )
{
ostiInitiatorEvent(
tiRoot,
tiPortalContext,
agNULL,
tiIntrEventTypeDeviceChange,
tiDeviceArrival,
agNULL
);
}
}
break;
case OSSA_FAILURE_OUT_OF_RESOURCE:
case OSSA_ERR_DEVICE_HANDLE_UNAVAILABLE:
TI_DBG1(("ossaDeviceRegistrationCB: OSSA_FAILURE_OUT_OF_RESOURCE or OSSA_ERR_DEVICE_HANDLE_UNAVAILABLE\n"));
oneDeviceData->registered = agFALSE;
break;
case OSSA_FAILURE_DEVICE_ALREADY_REGISTERED:
case OSSA_ERR_DEVICE_ALREADY_REGISTERED:
TI_DBG1(("ossaDeviceRegistrationCB: OSSA_FAILURE_DEVICE_ALREADY_REGISTERED or OSSA_ERR_DEVICE_ALREADY_REGISTERED\n"));
break;
case OSSA_FAILURE_INVALID_PHY_ID:
case OSSA_ERR_PHY_ID_INVALID:
TI_DBG1(("ossaDeviceRegistrationCB: OSSA_FAILURE_INVALID_PHY_ID or OSSA_ERR_PHY_ID_INVALID\n"));
oneDeviceData->registered = agFALSE;
break;
case OSSA_FAILURE_PHY_ID_ALREADY_REGISTERED:
case OSSA_ERR_PHY_ID_ALREADY_REGISTERED:
TI_DBG1(("ossaDeviceRegistrationCB: OSSA_FAILURE_PHY_ID_ALREADY_REGISTERED or OSSA_ERR_PHY_ID_ALREADY_REGISTERED\n"));
break;
case OSSA_FAILURE_PORT_ID_OUT_OF_RANGE:
case OSSA_ERR_PORT_INVALID:
TI_DBG1(("ossaDeviceRegistrationCB: OSSA_FAILURE_PORT_ID_OUT_OF_RANGE or OSSA_ERR_PORT_INVALID\n"));
oneDeviceData->registered = agFALSE;
break;
case OSSA_FAILURE_PORT_NOT_VALID_STATE:
case OSSA_ERR_PORT_STATE_NOT_VALID:
TI_DBG1(("ossaDeviceRegistrationCB: OSSA_FAILURE_PORT_NOT_VALID_STATE or OSSA_ERR_PORT_STATE_NOT_VALID\n"));
TI_DBG2(("ossaDeviceRegistrationCB: did %d pid %d\n", oneDeviceData->id, onePortContext->id));
oneDeviceData->registered = agFALSE;
onePortContext->Transient = agTRUE;
if (onePortContext->valid == agTRUE && (oneDeviceData->valid == agTRUE || oneDeviceData->valid2 == agTRUE))
{
TI_DBG1(("ossaDeviceRegistrationCB: retries regisration\n"));
#ifdef REMOVED
oneDeviceData->agDeviceInfo.flag = oneDeviceData->agDeviceInfo.flag | (tdsaAllShared->MCN << 16);
#endif
saRegisterNewDevice(
agRoot,
&oneDeviceData->agContext,
0,
&oneDeviceData->agDeviceInfo,
onePortContext->agPortContext,
0
);
}
else if (oneDeviceData->directlyAttached == agTRUE && DEVICE_IS_SATA_DEVICE(oneDeviceData))
{
TI_DBG1(("ossaDeviceRegistrationCB: directly attached SATA, put back into free list\n"));
tdsaDeviceDataReInit(tiRoot, oneDeviceData);
tdsaSingleThreadedEnter(tiRoot, TD_DEVICE_LOCK);
TDLIST_ENQUEUE_AT_TAIL(&(oneDeviceData->FreeLink), &(tdsaAllShared->FreeDeviceList));
tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK);
}
break;
case OSSA_FAILURE_DEVICE_TYPE_NOT_VALID:
case OSSA_ERR_DEVICE_TYPE_NOT_VALID:
TI_DBG1(("ossaDeviceRegistrationCB: OSSA_FAILURE_DEVICE_TYPE_NOT_VALID or OSSA_ERR_DEVICE_TYPE_NOT_VALID\n"));
oneDeviceData->registered = agFALSE;
break;
default:
TI_DBG1(("ossaDeviceRegistrationCB: wrong. default status is %d\n", status));
break;
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Ye");
return;
#endif
}
osGLOBAL void ossaDeregisterDeviceHandleCB(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
agsaDevHandle_t *agDevHandle,
bit32 status
)
{
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
tdsaDeviceData_t *oneDeviceData = agNULL;
tdsaPortContext_t *onePortContext = agNULL;
agsaEventSource_t *eventSource;
bit32 HwAckSatus;
bit32 PhyID;
#ifdef FDS_DM
dmRoot_t *dmRoot = &(tdsaAllShared->dmRoot);
dmPortContext_t *dmPortContext = agNULL;
dmPortInfo_t dmPortInfo;
bit32 DMstatus = DM_RC_FAILURE;
#endif
#ifdef FDS_SM
smRoot_t *smRoot = &(tdsaAllShared->smRoot);
#endif
TI_DBG3(("ossaDeregisterDeviceHandleCB: start\n"));
smTraceFuncEnter(hpDBG_VERY_LOUD,"Yf");
if (status == OSSA_ERR_DEVICE_HANDLE_INVALID)
{
TI_DBG2(("ossaDeregisterDeviceHandleCB: OSSA_ERR_DEVICE_HANDLE_INVALID\n"));
return;
}
oneDeviceData = (tdsaDeviceData_t *)agDevHandle->osData;
onePortContext = oneDeviceData->tdPortContext;
#ifdef FDS_DM
dmPortContext = &(onePortContext->dmPortContext);
#endif
if (oneDeviceData->valid == agFALSE && oneDeviceData->valid2 == agFALSE &&
oneDeviceData->DeviceType == TD_DEFAULT_DEVICE && onePortContext->valid == agTRUE)
{
TI_DBG2(("ossaDeregisterDeviceHandleCB: transient did %d\n", oneDeviceData->id));
return;
}
if (onePortContext != agNULL)
{
TI_DBG2(("ossaDeregisterDeviceHandleCB: pid %d registeredNumDevice %d\n", onePortContext->id, onePortContext->RegisteredDevNums));
}
switch (status)
{
case OSSA_SUCCESS:
TI_DBG3(("ossaDeregisterDeviceHandleCB: Success\n"));
if (onePortContext == agNULL)
{
TI_DBG1(("ossaDeregisterDeviceHandleCB: onePortContext is NULL, wrong!\n"));
return;
}
if (onePortContext->valid == agFALSE)
{
if (!(oneDeviceData->valid == agFALSE && oneDeviceData->valid2 == agFALSE && oneDeviceData->DeviceType == TD_DEFAULT_DEVICE))
{
TI_DBG2(("ossaDeregisterDeviceHandleCB: delete from MainLink\n"));
#ifdef FDS_SM
if (DEVICE_IS_SATA_DEVICE(oneDeviceData) || DEVICE_IS_STP_TARGET(oneDeviceData))
{
TI_DBG1(("ossaDeregisterDeviceHandleCB: did %d calling smDeregisterDevice\n", oneDeviceData->id));
smDeregisterDevice(smRoot, oneDeviceData->agDevHandle, &(oneDeviceData->smDeviceHandle));
}
#endif
tdsaDeviceDataReInit(tiRoot, oneDeviceData);
osti_memset(&(oneDeviceData->satDevData.satIdentifyData), 0xFF, sizeof(agsaSATAIdentifyData_t));
tdsaSingleThreadedEnter(tiRoot, TD_DEVICE_LOCK);
TDLIST_DEQUEUE_THIS(&(oneDeviceData->MainLink));
TDLIST_ENQUEUE_AT_TAIL(&(oneDeviceData->FreeLink), &(tdsaAllShared->FreeDeviceList));
tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK);
}
PhyID = onePortContext->eventPhyID;
TI_DBG3(("ossaDeregisterDeviceHandleCB: PhyID %d\n", PhyID));
onePortContext->RegisteredDevNums--;
if (tdsaAllShared->eventSource[PhyID].EventValid == agTRUE &&
onePortContext->RegisteredDevNums == 0 &&
PhyID != 0xFF
)
{
TI_DBG2(("ossaDeregisterDeviceHandleCB: calling saHwEventAck\n"));
eventSource = &(tdsaAllShared->eventSource[PhyID].Source);
HwAckSatus = saHwEventAck(
agRoot,
agNULL,
0,
eventSource,
0,
0
);
if ( HwAckSatus != AGSA_RC_SUCCESS)
{
TI_DBG1(("ossaDeregisterDeviceHandleCB: failing in saHwEventAck; status %d\n", HwAckSatus));
}
tdsaAllShared->eventSource[PhyID].EventValid = agFALSE;
#ifdef FDS_DM
if (onePortContext->UseDM == agTRUE)
{
TI_DBG1(("ossaDeregisterDeviceHandleCB: calling dmDestroyPort\n"));
PORTINFO_PUT_SAS_REMOTE_ADDRESSLO(&dmPortInfo, onePortContext->sasRemoteAddressLo);
PORTINFO_PUT_SAS_REMOTE_ADDRESSHI(&dmPortInfo, onePortContext->sasRemoteAddressHi);
PORTINFO_PUT_SAS_LOCAL_ADDRESSLO(&dmPortInfo, onePortContext->sasLocalAddressLo);
PORTINFO_PUT_SAS_LOCAL_ADDRESSHI(&dmPortInfo, onePortContext->sasLocalAddressHi);
DMstatus = dmDestroyPort(dmRoot, dmPortContext, &dmPortInfo);
if (DMstatus != DM_RC_SUCCESS)
{
TI_DBG1(("ossaDeregisterDeviceHandleCB: dmDestroyPort failed!!! 0x%x\n", DMstatus));
}
}
#endif
tdsaPortContextReInit(tiRoot, onePortContext);
tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK);
TDLIST_DEQUEUE_THIS(&(onePortContext->MainLink));
TDLIST_ENQUEUE_AT_TAIL(&(onePortContext->FreeLink), &(tdsaAllShared->FreePortContextList));
tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
}
else if (tdsaAllShared->eventSource[PhyID].EventValid == NO_ACK &&
onePortContext->RegisteredDevNums == 0
)
{
TI_DBG2(("ossaDeregisterDeviceHandleCB: NO ACK case\n"));
#ifdef FDS_DM
if (onePortContext->UseDM == agTRUE)
{
TI_DBG1(("ossaDeregisterDeviceHandleCB: calling dmDestroyPort\n"));
PORTINFO_PUT_SAS_REMOTE_ADDRESSLO(&dmPortInfo, onePortContext->sasRemoteAddressLo);
PORTINFO_PUT_SAS_REMOTE_ADDRESSHI(&dmPortInfo, onePortContext->sasRemoteAddressHi);
PORTINFO_PUT_SAS_LOCAL_ADDRESSLO(&dmPortInfo, onePortContext->sasLocalAddressLo);
PORTINFO_PUT_SAS_LOCAL_ADDRESSHI(&dmPortInfo, onePortContext->sasLocalAddressHi);
DMstatus = dmDestroyPort(dmRoot, dmPortContext, &dmPortInfo);
if (DMstatus != DM_RC_SUCCESS)
{
TI_DBG1(("ossaDeregisterDeviceHandleCB: dmDestroyPort failed!!! 0x%x\n", DMstatus));
}
}
#endif
tdsaPortContextReInit(tiRoot, onePortContext);
tdsaSingleThreadedEnter(tiRoot, TD_PORT_LOCK);
TDLIST_DEQUEUE_THIS(&(onePortContext->MainLink));
TDLIST_ENQUEUE_AT_TAIL(&(onePortContext->FreeLink), &(tdsaAllShared->FreePortContextList));
tdsaSingleThreadedLeave(tiRoot, TD_PORT_LOCK);
}
else
{
if (PhyID < TD_MAX_NUM_PHYS)
{
TI_DBG3(("ossaDeregisterDeviceHandleCB: pid %d eventvalid %d registeredNumDevice %d\n", onePortContext->id, tdsaAllShared->eventSource[PhyID].EventValid , onePortContext->RegisteredDevNums));
}
else
{
TI_DBG3(("ossaDeregisterDeviceHandleCB: pid %d registeredNumDevice %d wrong phyid %d\n", onePortContext->id, onePortContext->RegisteredDevNums, PhyID));
}
}
}
else
{
PhyID = onePortContext->eventPhyID;
TI_DBG3(("ossaDeregisterDeviceHandleCB: PhyID %d\n", PhyID));
onePortContext->RegisteredDevNums--;
#ifdef FDS_SM
oneDeviceData->satDevData.IDDeviceValid = agFALSE;
if (DEVICE_IS_SATA_DEVICE(oneDeviceData) || DEVICE_IS_STP_TARGET(oneDeviceData))
{
smDeregisterDevice(smRoot, oneDeviceData->agDevHandle, &(oneDeviceData->smDeviceHandle));
}
#endif
if (tdsaAllShared->eventSource[PhyID].EventValid == agTRUE &&
onePortContext->RegisteredDevNums == 0 &&
PhyID != 0xFF
)
{
TI_DBG2(("ossaDeregisterDeviceHandleCB: calling saHwEventAck\n"));
eventSource = &(tdsaAllShared->eventSource[PhyID].Source);
HwAckSatus = saHwEventAck(
agRoot,
agNULL,
0,
eventSource,
0,
0
);
if ( HwAckSatus != AGSA_RC_SUCCESS)
{
TI_DBG1(("ossaDeregisterDeviceHandleCB: failing in saHwEventAck; status %d\n", HwAckSatus));
}
tdsaAllShared->eventSource[PhyID].EventValid = agFALSE;
}
#ifdef INITIATOR_DRIVER
else if (onePortContext->RegisteredDevNums == 1)
{
TI_DBG1(("ossaDeregisterDeviceHandleCB: all devices have been deregistered except directly attached EXP\n"));
if (onePortContext->DiscFailNSeenBC == agTRUE)
{
TI_DBG1(("ossaDeregisterDeviceHandleCB: calling dmDiscover, incremental, pid %d\n", onePortContext->id));
dmDiscover(dmRoot, dmPortContext, DM_DISCOVERY_OPTION_INCREMENTAL_START);
onePortContext->DiscFailNSeenBC = agFALSE;
}
else
{
TI_DBG1(("ossaDeregisterDeviceHandleCB: not calling dmDiscover\n"));
dmResetFailedDiscovery(dmRoot, dmPortContext);
}
}
#endif
else
{
if (PhyID < TD_MAX_NUM_PHYS)
{
TI_DBG3(("ossaDeregisterDeviceHandleCB: pid %d eventvalid %d registeredNumDevice %d\n", onePortContext->id, tdsaAllShared->eventSource[PhyID].EventValid , onePortContext->RegisteredDevNums));
}
else
{
TI_DBG3(("ossaDeregisterDeviceHandleCB: pid %d registeredNumDevice %d wrong phyid %d\n", onePortContext->id, onePortContext->RegisteredDevNums, PhyID));
}
}
}
break;
case OSSA_INVALID_HANDLE:
TI_DBG1(("ossaDeregisterDeviceHandleCB: OSSA_INVALID_HANDLE\n"));
break;
#ifdef REMOVED
case OSSA_FAILURE_DEVICE_DIRECT_ATTACH:
TI_DBG1(("ossaDeregisterDeviceHandleCB: OSSA_FAILURE_DEVICE_DIRECT_ATTACH\n"));
break;
#endif
case OSSA_ERR_DEVICE_HANDLE_INVALID:
TI_DBG1(("ossaDeregisterDeviceHandleCB: OSSA_ERR_DEVICE_HANDLE_INVALID\n"));
break;
case OSSA_ERR_DEVICE_BUSY:
TI_DBG1(("ossaDeregisterDeviceHandleCB: OSSA_ERR_DEVICE_BUSY\n"));
break;
default:
TI_DBG1(("ossaDeregisterDeviceHandleCB: unknown status 0x%x\n", status));
break;
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yf");
return;
}
osGLOBAL void ossaDeviceHandleRemovedEvent (
agsaRoot_t *agRoot,
agsaDevHandle_t *agDevHandle,
agsaPortContext_t *agPortContext
)
{
#ifdef NOT_YET
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
#endif
tdsaPortContext_t *onePortContext = agNULL;
tdsaDeviceData_t *oneDeviceData = (tdsaDeviceData_t *)agDevHandle->osData;
smTraceFuncEnter(hpDBG_VERY_LOUD,"Yg");
TI_DBG2(("ossaDeviceHandleRemovedEvent: start\n"));
if (oneDeviceData == agNULL)
{
TI_DBG1(("ossaDeviceHandleRemovedEvent: Wrong! oneDeviceData is NULL\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yg");
return;
}
TI_DBG2(("ossaDeviceHandleRemovedEvent: did %d\n", oneDeviceData->id));
oneDeviceData->registered = agFALSE;
onePortContext = (tdsaPortContext_t *)agPortContext->osData;
if (onePortContext == agNULL)
{
TI_DBG1(("ossaDeviceHandleRemovedEvent: Wrong! onePortContext is NULL\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "Yg");
return;
}
TI_DBG2(("ossaDeviceHandleRemovedEvent: pid %d\n", onePortContext->id));
onePortContext->RegisteredDevNums--;
#ifdef NOT_YET
ostiInitiatorEvent(
tiRoot,
onePortContext->tiPortalContext,
agNULL,
tiIntrEventTypeDeviceChange,
tiDeviceRemoval,
agNULL
);
#endif
smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "Yg");
return;
}
#ifdef SPC_ENABLE_PROFILE
osGLOBAL void ossaFwProfileCB(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 status,
bit32 len)
{
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
TI_DBG2(("ossaFwProfileCB: start\n"));
switch (status)
{
case AGSA_RC_SUCCESS:
{
TI_DBG2(("ossaFwProfileCB: SUCCESS\n"));
break;
}
case AGSA_RC_FAILURE:
{
TI_DBG1(("ossaFwProfileCB: FAIL\n"));
break;
}
default:
{
TI_DBG1(("ossaFwProfileCB: !!! default, status %d\n", status));
break;
}
}
ostiFWProfileIOCTLRsp(tiRoot, status, len);
return;
}
#endif
osGLOBAL void ossaFwFlashUpdateCB(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 status
)
{
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
TI_DBG2(("ossaFwFlashUpdateCB: start\n"));
smTraceFuncEnter(hpDBG_VERY_LOUD,"Yh");
switch (status)
{
case OSSA_FLASH_UPDATE_COMPLETE_PENDING_REBOOT:
{
TI_DBG2(("ossaFwFlashUpdateCB: OSSA_FLASH_UPDATE_COMPLETE_PENDING_REBOOT\n"));
break;
}
case OSSA_FLASH_UPDATE_IN_PROGRESS:
{
TI_DBG2(("ossaFwFlashUpdateCB: OSSA_FLASH_UPDATE_IN_PROGRESS\n"));
break;
}
case OSSA_FLASH_UPDATE_HDR_ERR:
{
TI_DBG1(("ossaFwFlashUpdateCB: OSSA_FLASH_UPDATE_HDR_ERR\n"));
break;
}
case OSSA_FLASH_UPDATE_OFFSET_ERR:
{
TI_DBG1(("ossaFwFlashUpdateCB: OSSA_FLASH_UPDATE_OFFSET_ERR\n"));
break;
}
case OSSA_FLASH_UPDATE_CRC_ERR:
{
TI_DBG1(("ossaFwFlashUpdateCB: OSSA_FLASH_UPDATE_CRC_ERR\n"));
break;
}
case OSSA_FLASH_UPDATE_LENGTH_ERR:
{
TI_DBG1(("ossaFwFlashUpdateCB: OSSA_FLASH_UPDATE_LENGTH_ERR\n"));
break;
}
case OSSA_FLASH_UPDATE_HW_ERR:
{
TI_DBG1(("ossaFwFlashUpdateCB: OSSA_FLASH_UPDATE_HW_ERR\n"));
break;
}
case OSSA_FLASH_UPDATE_DNLD_NOT_SUPPORTED:
{
TI_DBG1(("ossaFwFlashUpdateCB: OSSA_FLASH_UPDATE_DNLD_NOT_SUPPORTED\n"));
break;
}
case OSSA_FLASH_UPDATE_DISABLED:
{
TI_DBG1(("ossaFwFlashUpdateCB: OSSA_FLASH_UPDATE_DISABLED\n"));
break;
}
case OSSA_FLASH_FWDNLD_DEVICE_UNSUPPORT:
{
TI_DBG1(("ossaFwFlashUpdateCB: OSSA_FLASH_FWDNLD_DEVICE_UNSUPPORT\n"));
break;
}
case OSSA_MPI_ERR_IO_RESOURCE_UNAVAILABLE:
{
TI_DBG1(("ossaFwFlashUpdateCB: OSSA_MPI_ERR_IO_RESOURCE_UNAVAILABLE\n"));
break;
}
case OSSA_FLASH_UPDATE_HMAC_ERR:
{
TI_DBG1(("ossaFwFlashUpdateCB: OSSA_FLASH_UPDATE_HMAC_ERR\n"));
break;
}
default:
{
TI_DBG1(("ossaFwFlashUpdateCB: !!! default, status 0x%X\n", status));
break;
}
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yh");
ostiCOMMgntIOCTLRsp(tiRoot, status);
return;
}
GLOBAL void ossaFlashExtExecuteCB(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 status,
bit32 command,
agsaFlashExtResponse_t *agFlashExtRsp)
{
TI_DBG1(("ossaFlashExtExecuteCB: command 0x%X status 0x%X\n",command, status));
}
osGLOBAL void ossaGetNVMDResponseCB(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 status,
bit8 indirectPayload,
bit32 agInfoLen,
agsaFrameHandle_t agFrameHandle
)
{
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
TI_DBG2(("ossaGetNVMDResponseCB: start\n"));
TI_DBG2(("ossaGetNVMDResponseCB: agInfoLen %d\n", agInfoLen));
smTraceFuncEnter(hpDBG_VERY_LOUD,"Yi");
if (status == OSSA_SUCCESS)
{
TI_DBG2(("ossaGetNVMDResponseCB: Success status\n"));
if (indirectPayload == 0 && agInfoLen != 0)
{
TI_DBG2(("ossaGetNVMDResponseCB: direct\n"));
tdhexdump("ossaGetNVMDResponseCB", (bit8 *)agFrameHandle, agInfoLen);
}
}
else
{
TI_DBG1(("ossaGetNVMDResponseCB: Status 0x%x\n", status));
}
if (indirectPayload == 0)
{
TI_DBG2(("ossaGetNVMDResponseCB: direct\n"));
}
else
{
TI_DBG2(("ossaGetNVMDResponseCB: indirect\n"));
}
ostiGetNVMDIOCTLRsp(tiRoot, status);
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yi");
return;
}
osGLOBAL void ossaSetNVMDResponseCB(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 status
)
{
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
TI_DBG2(("ossaSetNVMDResponseCB: start\n"));
smTraceFuncEnter(hpDBG_VERY_LOUD,"Yj");
if (status == OSSA_SUCCESS)
{
TI_DBG2(("ossaSetNVMDResponseCB: success\n"));
}
else
{
TI_DBG1(("ossaSetNVMDResponseCB: fail or undefined staus %d\n", status));
}
ostiSetNVMDIOCTLRsp(tiRoot, status);
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yj");
return;
}
#ifdef REMOVED
osGLOBAL void ossaGetVPDResponseCB(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 status,
bit8 indirectMode,
bit32 agInfoLen,
agsaFrameHandle_t agFrameHandle
)
{
bit8 VPDData[48];
TI_DBG2(("ossaGetVPDResponseCB: start\n"));
smTraceFuncEnter(hpDBG_VERY_LOUD,"Yk");
if (status == OSSA_SUCCESS)
{
TI_DBG2(("ossaGetVPDResponseCB: agInfoLen %d\n", agInfoLen));
osti_memset(VPDData, 0, 48);
saFrameReadBlock(agRoot, agFrameHandle, 0, VPDData, agInfoLen);
tdhexdump("ossaGetVPDResponseCB", (bit8 *)VPDData, agInfoLen);
}
else
{
TI_DBG1(("ossaGetVPDResponseCB: fail or undefined staus %d\n", status));
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yk");
return;
}
osGLOBAL void ossaSetVPDResponseCB(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 status
)
{
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
TI_DBG2(("ossaSetVPDResponseCB: start\n"));
smTraceFuncEnter(hpDBG_VERY_LOUD,"Yl");
if (status == OSSA_SUCCESS)
{
TI_DBG2(("ossaSetVPDResponseCB: success\n"));
ostiCOMMgntVPDSetIOCTLRsp(tiRoot, 0);
#ifdef VPD_TESTING
tdsaVPDGet(tiRoot);
#endif
}
else
{
TI_DBG1(("ossaSetVPDResponseCB: fail or undefined staus %d\n", status));
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yl");
return;
}
#endif
osGLOBAL void ossaEchoCB(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
void *echoPayload
)
{
#ifdef ECHO_TESTING
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
bit8 payload[56];
#endif
TI_DBG2(("ossaEchoCB: start\n"));
smTraceFuncEnter(hpDBG_VERY_LOUD,"Ym");
tdhexdump("ossaEchoCB: echoPayload", (bit8 *)(echoPayload), 56);
#ifdef ECHO_TESTING
osti_memset(payload,0, sizeof(payload));
payload[0] = gEcho;
payload[55] = gEcho;
TI_DBG2(("ossaEchoCB: gEcho %d\n", gEcho));
saEchoCommand(agRoot, agNULL, tdsaRotateQnumber(tiRoot, agNULL), (void *)&payload);
if (gEcho == 0xFF)
{
gEcho = 0;
}
else
{
gEcho++;
}
#endif
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Ym");
return;
}
osGLOBAL void ossaGpioResponseCB(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 status,
bit32 gpioReadValue,
agsaGpioPinSetupInfo_t *gpioPinSetupInfo,
agsaGpioEventSetupInfo_t *gpioEventSetupInfo
)
{
TI_DBG2(("ossaGpioResponseCB: start\n"));
smTraceFuncEnter(hpDBG_VERY_LOUD,"Yn");
if (status == OSSA_SUCCESS)
{
TI_DBG2(("ossaGpioResponseCB: Success\n"));
TI_DBG2(("ossaGpioResponseCB: gpioReadValue 0x%x\n", gpioReadValue));
TI_DBG2(("ossaGpioResponseCB: PinSetupInfo gpioInputEnabled 0x%x\n", gpioPinSetupInfo->gpioInputEnabled));
TI_DBG2(("ossaGpioResponseCB: PinSetupInfo gpioTypePart1 0x%x\n", gpioPinSetupInfo->gpioTypePart1));
TI_DBG2(("ossaGpioResponseCB: PinSetupInfo gpioTypePart2 0x%x\n", gpioPinSetupInfo->gpioTypePart2));
TI_DBG2(("ossaGpioResponseCB: EventSetupInfo gpioEventLevel 0x%x\n", gpioEventSetupInfo->gpioEventLevel));
TI_DBG2(("ossaGpioResponseCB: EventSetupInfo gpioEventRisingEdge 0x%x\n", gpioEventSetupInfo->gpioEventRisingEdge));
TI_DBG2(("ossaGpioResponseCB: EventSetupInfo gpioEventFallingEdge 0x%x\n", gpioEventSetupInfo->gpioEventFallingEdge));
}
else
{
TI_DBG1(("ossaGpioResponseCB: Failure\n"));
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yn");
return;
}
osGLOBAL void ossaGpioEvent(
agsaRoot_t *agRoot,
bit32 gpioEvent
)
{
TI_DBG2(("ossaGpioEvent: start\n"));
TI_DBG2(("ossaGpioEvent: gpioEvent 0x%x\n", gpioEvent));
smTraceFuncEnter(hpDBG_VERY_LOUD,"Yo");
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yo");
return;
}
osGLOBAL void ossaSASDiagExecuteCB(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 status,
bit32 command,
bit32 reportData)
{
smTraceFuncEnter(hpDBG_VERY_LOUD,"Yq");
TI_DBG2(("ossaSASDiagExecuteCB: start\n"));
TI_DBG2(("ossaSASDiagExecuteCB: status %d\n", status));
TI_DBG2(("ossaSASDiagExecuteCB: command %d\n", command));
TI_DBG2(("ossaSASDiagExecuteCB: reportData %d\n", reportData));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yq");
return;
}
osGLOBAL void ossaSASDiagStartEndCB(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 status)
{
TI_DBG2(("ossaSASDiagStartEndCB: start\n"));
TI_DBG2(("ossaSASDiagStartEndCB: status %d\n", status));
smTraceFuncEnter(hpDBG_VERY_LOUD,"Yr");
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yr");
return;
}
osGLOBAL void ossaReconfigSASParamsCB(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 status,
agsaSASReconfig_t *agSASConfig)
{
TI_DBG2(("ossaReconfigSASParamsCB: status %d\n", status));
return;
}
GLOBAL void ossaPCIeDiagExecuteCB(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 status,
bit32 command,
agsaPCIeDiagResponse_t *resp )
{
TI_DBG2(("ossaPCIeDiagExecuteCB: status %d\n", status));
TI_DBG2(("ossaPCIeDiagExecuteCB: ERR_BLKH 0x%X\n",resp->ERR_BLKH ));
TI_DBG2(("ossaPCIeDiagExecuteCB: ERR_BLKL 0x%X\n",resp->ERR_BLKL ));
TI_DBG2(("ossaPCIeDiagExecuteCB: DWord8 0x%X\n",resp->DWord8 ));
TI_DBG2(("ossaPCIeDiagExecuteCB: DWord9 0x%X\n",resp->DWord9 ));
TI_DBG2(("ossaPCIeDiagExecuteCB: DWord10 0x%X\n",resp->DWord10 ));
TI_DBG2(("ossaPCIeDiagExecuteCB: DWord11 0x%X\n",resp->DWord11 ));
TI_DBG2(("ossaPCIeDiagExecuteCB: DIF_ERR 0x%X\n",resp->DIF_ERR ));
return;
}
#ifndef BIOS
GLOBAL void ossaSGpioCB(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
agsaSGpioReqResponse_t *pSgpioResponse
)
{
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
TI_DBG2(("ossaSGpioCB: smpFrameType: 0x%02x \n", pSgpioResponse->smpFrameType));
TI_DBG2(("ossaSGpioCB: function: 0x%02x \n", pSgpioResponse->function));
TI_DBG2(("ossaSGpioCB: functionResult: 0x%02x \n", pSgpioResponse->functionResult));
tdhexdump("ossaSGpioCB Response", (bit8 *)pSgpioResponse, sizeof(agsaSGpioReqResponse_t));
ostiSgpioIoctlRsp(tiRoot, pSgpioResponse);
}
#endif
GLOBAL void ossaLogDebugString(
agsaRoot_t *agRoot,
bit32 level,
char *string,
void *ptr1,
void *ptr2,
bit32 value1,
bit32 value2
)
{
#if defined(SALLSDK_DEBUG)
TIDEBUG_MSG(gLLDebugLevel, level, ("%s %p %p %d %d\n", string, ptr1, ptr2, value1, value2));
#endif
return;
}
GLOBAL void ossaHwEventAckCB(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 status
)
{
TI_DBG3(("ossaHwEventAckCB: start\n"));
smTraceFuncEnter(hpDBG_VERY_LOUD,"Ys");
if (status == tiSuccess)
{
TI_DBG3(("ossaHwEventAckCB: SUCCESS status\n"));
}
else
{
TI_DBG1(("ossaHwEventAckCB: FAIL status 0x%X\n", status));
TI_DBG1(("ossaHwEventAckCB: invalid event status bit0 %d\n", status & 0x01));
TI_DBG1(("ossaHwEventAckCB: invalid phyid status bit1 %d\n", (status & 0x02) >> 1 ));
TI_DBG1(("ossaHwEventAckCB: invalid portcontext status bit2 %d\n", (status & 0x04) >> 2));
TI_DBG1(("ossaHwEventAckCB: invalid param0 status bit3 %d\n", (status & 0x08) >> 3));
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Ys");
return;
}
GLOBAL void ossaGetTimeStampCB(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 timeStampLower,
bit32 timeStampUpper
)
{
smTraceFuncEnter(hpDBG_VERY_LOUD,"Yt");
TI_DBG4(("ossaGetTimeStampCB: start\n"));
TI_DBG4(("ossaGetTimeStampCB: timeStampUpper 0x%x timeStampLower 0x%x\n", timeStampUpper, timeStampLower));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yt");
return;
}
GLOBAL void ossaSMPAbortCB(
agsaRoot_t *agRoot,
agsaIORequest_t *agIORequest,
bit32 flag,
bit32 status)
{
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
tdIORequestBody_t *tdAbortIORequestBody = agNULL;
tdsaDeviceData_t *oneDeviceData = agNULL;
tiDeviceHandle_t *tiDeviceHandle = agNULL;
TI_DBG4(("ossaSMPAbortCB: start\n"));
TI_DBG4(("ossaSMPAbortCB: flag %d\n", flag));
TI_DBG4(("ossaSMPAbortCB: status %d\n", status));
smTraceFuncEnter(hpDBG_VERY_LOUD,"Yu");
tdAbortIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
if (tdAbortIORequestBody == agNULL)
{
TI_DBG1(("ossaSMPAbortCB: tdAbortIORequestBody is NULL warning!!!!\n"));
return;
}
if (flag == 2)
{
TI_DBG2(("ossaSMPAbortCB: abort per port\n"));
}
else if (flag == 1)
{
TI_DBG2(("ossaSMPAbortCB: abort all\n"));
tiDeviceHandle = (tiDeviceHandle_t *)tdAbortIORequestBody->tiDevHandle;
if (tiDeviceHandle == agNULL)
{
TI_DBG1(("ossaSMPAbortCB: tiDeviceHandle is NULL warning!!!!\n"));
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
return;
}
oneDeviceData = (tdsaDeviceData_t *)tiDeviceHandle->tdData;
if (oneDeviceData == agNULL)
{
TI_DBG1(("ossaSMPAbortCB: oneDeviceData is NULL warning!!!!\n"));
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
return;
}
if (status == OSSA_IO_SUCCESS)
{
TI_DBG2(("ossaSMPAbortCB: OSSA_IO_SUCCESS\n"));
TI_DBG3(("ossaSMPAbortCB: calling saDeregisterDeviceHandle\n"));
saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
TI_DBG2(("ossaSMPAbortCB: did %d\n", oneDeviceData->id));
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
}
else if (status == OSSA_IO_NOT_VALID)
{
TI_DBG1(("ossaSMPAbortCB: OSSA_IO_NOT_VALID\n"));
TI_DBG1(("ossaSMPAbortCB: calling saDeregisterDeviceHandle\n"));
saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
TI_DBG1(("ossaSMPAbortCB: did %d\n", oneDeviceData->id));
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
}
else if (status == OSSA_IO_NO_DEVICE)
{
TI_DBG1(("ossaSMPAbortCB: OSSA_IO_NO_DEVICE\n"));
TI_DBG1(("ossaSMPAbortCB: calling saDeregisterDeviceHandle\n"));
saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
TI_DBG1(("ossaSMPAbortCB: did %d\n", oneDeviceData->id));
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
}
else if (status == OSSA_IO_ABORT_IN_PROGRESS)
{
TI_DBG1(("ossaSMPAbortCB: OSSA_IO_ABORT_IN_PROGRESS\n"));
TI_DBG1(("ossaSMPAbortCB: calling saDeregisterDeviceHandle\n"));
saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
TI_DBG1(("ossaSMPAbortCB: did %d\n", oneDeviceData->id));
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
}
#ifdef REMOVED
else if (status == OSSA_IO_ABORT_DELAYED)
{
TI_DBG1(("ossaSMPAbortCB: OSSA_IO_ABORT_DELAYED\n"));
TI_DBG1(("ossaSMPAbortCB: calling saDeregisterDeviceHandle\n"));
saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
TI_DBG1(("ossaSMPAbortCB: did %d\n", oneDeviceData->id));
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
}
#endif
else
{
TI_DBG1(("ossaSMPAbortCB: other status %d\n", status));
TI_DBG1(("ossaSMPAbortCB: calling saDeregisterDeviceHandle\n"));
saDeregisterDeviceHandle(agRoot, agNULL, oneDeviceData->agDevHandle, tdsaRotateQnumber(tiRoot, oneDeviceData));
TI_DBG1(("ossaSMPAbortCB: did %d\n", oneDeviceData->id));
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
}
}
else if (flag == 0)
{
TI_DBG2(("ossaSMPAbortCB: abort one\n"));
if (status == OSSA_IO_SUCCESS)
{
TI_DBG2(("ossaSMPAbortCB: OSSA_IO_SUCCESS\n"));
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
}
else if (status == OSSA_IO_NOT_VALID)
{
TI_DBG1(("ossaSMPAbortCB: OSSA_IO_NOT_VALID\n"));
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
}
else if (status == OSSA_IO_NO_DEVICE)
{
TI_DBG1(("ossaSMPAbortCB: OSSA_IO_NO_DEVICE\n"));
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
}
else if (status == OSSA_IO_ABORT_IN_PROGRESS)
{
TI_DBG1(("ossaSMPAbortCB: OSSA_IO_ABORT_IN_PROGRESS\n"));
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
}
#ifdef REMOVED
else if (status == OSSA_IO_ABORT_DELAYED)
{
TI_DBG1(("ossaSMPAbortCB: OSSA_IO_ABORT_DELAYED\n"));
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
}
#endif
else
{
TI_DBG1(("ossaSMPAbortCB: other status %d\n", status));
ostiFreeMemory(
tiRoot,
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
}
}
else
{
TI_DBG1(("ossaSMPAbortCB: wrong flag %d\n", flag));
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yu");
return;
}
GLOBAL void ossaGeneralEvent(
agsaRoot_t *agRoot,
bit32 status,
agsaContext_t *agContext,
bit32 *msg)
{
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
TI_DBG1(("ossaGeneralEvent: start\n"));
TI_DBG1(("ossaGeneralEvent: status %d\n", status));
if(msg)
{
TI_DBG1(("ossaGeneralEvent: *msg %X\n", *msg));
}
smTraceFuncEnter(hpDBG_VERY_LOUD,"Yv");
ostiGenEventIOCTLRsp(tiRoot, status);
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yv");
return;
}
GLOBAL void ossaGetForensicDataCB (
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 status,
agsaForensicData_t *forensicData)
{
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
ostiGetForensicDataIOCTLRsp(tiRoot, status, forensicData);
return;
}
#ifdef INITIATOR_DRIVER
GLOBAL void ossaGetIOErrorStatsCB (
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 status,
agsaIOErrorEventStats_t *stats)
{
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
ostiGetIoErrorStatsIOCTLRsp(tiRoot, status, stats);
}
#else
GLOBAL void ossaGetIOErrorStatsCB (
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 status,
agsaIOErrorEventStats_t *stats)
{
}
#endif
GLOBAL void ossaGetIOEventStatsCB (
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 status,
agsaIOErrorEventStats_t *stats)
{
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
ostiGetIoEventStatsIOCTLRsp(tiRoot, status, stats);
}
GLOBAL void ossaGetRegisterDumpCB(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 status
)
{
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
TI_DBG4(("ossaGetRegisterDumpCB: start\n"));
TI_DBG4(("ossaGetRegisterDumpCB: status %d\n", status));
smTraceFuncEnter(hpDBG_VERY_LOUD,"Yw");
ostiRegDumpIOCTLRsp(tiRoot, status);
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "Yw");
return;
}
GLOBAL void ossaSetDeviceStateCB(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
agsaDevHandle_t *agDevHandle,
bit32 status,
bit32 newDeviceState,
bit32 previousDeviceState
)
{
tdsaDeviceData_t *oneDeviceData = agNULL;
TI_DBG2(("ossaSetDeviceStateCB: start\n"));
TI_DBG2(("ossaSetDeviceStateCB: status %d\n", status));
TI_DBG2(("ossaSetDeviceStateCB: newDeviceState %d\n", newDeviceState));
TI_DBG2(("ossaSetDeviceStateCB: previousDeviceState %d\n", previousDeviceState));
if (agDevHandle == agNULL)
{
TI_DBG4(("ossaSetDeviceStateCB: agDevHandle is NULL\n"));
return;
}
oneDeviceData = (tdsaDeviceData_t *)agDevHandle->osData;
if (oneDeviceData == agNULL)
{
TI_DBG1(("ossaSetDeviceStateCB: wrong; oneDeviceData is NULL\n"));
}
else
{
TI_DBG2(("ossaSetDeviceStateCB: did %d\n", oneDeviceData->id));
}
return;
}
GLOBAL void ossaGetDeviceStateCB(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
agsaDevHandle_t *agDevHandle,
bit32 status,
bit32 deviceState
)
{
TI_DBG4(("ossaGetDeviceStateCB: start\n"));
TI_DBG4(("ossaGetDeviceStateCB: status %d\n", status));
TI_DBG4(("ossaGetDeviceStateCB: deviceState %d\n", deviceState));
return;
}
#ifdef INITIATOR_DRIVER
osGLOBAL void
ossaIniSetDeviceInfoCB(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
agsaDevHandle_t *agDevHandle,
bit32 status,
bit32 option,
bit32 param
)
{
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
itdsaIni_t *Initiator = (itdsaIni_t *)tdsaAllShared->itdsaIni;
bit32 intContext = osData->IntContext;
tdIORequestBody_t *tdIORequestBody = agNULL;
agsaIORequest_t *agIORequest = agNULL;
bit32 saStatus = AGSA_RC_FAILURE;
bit8 devType_S_Rate;
tdsaDeviceData_t *oneDeviceData = agNULL;
TI_DBG4(("ossaIniSetDeviceInfoCB: start\n"));
TI_DBG4(("ossaIniSetDeviceInfoCB: status 0x%x\n", status));
TI_DBG4(("ossaIniSetDeviceInfoCB: option 0x%x\n", option));
TI_DBG4(("ossaIniSetDeviceInfoCB: param 0x%x\n", param));
if (status != OSSA_SUCCESS)
{
TI_DBG1(("ossaIniSetDeviceInfoCB: status %d\n", status));
TI_DBG1(("ossaIniSetDeviceInfoCB: option 0x%x\n", option));
TI_DBG1(("ossaIniSetDeviceInfoCB: param 0x%x\n", param));
if (option == 32)
{
TI_DBG1(("ossaIniSetDeviceInfoCB: IO failure\n"));
agIORequest = (agsaIORequest_t *)agContext->osData;
tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
ostiInitiatorIOCompleted(
tiRoot,
tdIORequestBody->tiIORequest,
tiIOFailed,
tiDetailOtherError,
agNULL,
intContext
);
}
}
if (agDevHandle == agNULL)
{
TI_DBG4(("ossaIniSetDeviceInfoCB: agDevHandle is NULL\n"));
return;
}
oneDeviceData = (tdsaDeviceData_t *)agDevHandle->osData;
if (oneDeviceData == agNULL)
{
TI_DBG1(("ossaIniSetDeviceInfoCB: wrong; oneDeviceData is NULL\n"));
return;
}
else
{
TI_DBG4(("ossaIniSetDeviceInfoCB: did %d\n", oneDeviceData->id));
}
if (option == 32)
{
TI_DBG1(("ossaIniSetDeviceInfoCB: set connection rate option\n"));
agIORequest = (agsaIORequest_t *)agContext->osData;
tdIORequestBody = (tdIORequestBody_t *)agIORequest->osData;
devType_S_Rate = oneDeviceData->agDeviceInfo.devType_S_Rate;
devType_S_Rate = (devType_S_Rate & 0xF0) | (param >> 28);
oneDeviceData->agDeviceInfo.devType_S_Rate = devType_S_Rate;
TI_DBG1(("ossaIniSetDeviceInfoCB: new rate is 0x%x\n", DEVINFO_GET_LINKRATE(&oneDeviceData->agDeviceInfo)));
if (oneDeviceData->valid == agTRUE && oneDeviceData->registered == agTRUE &&
oneDeviceData->tdPortContext != agNULL )
{
saStatus = saSSPStart(agRoot,
agIORequest,
tdsaRotateQnumber(tiRoot, oneDeviceData),
agDevHandle,
tdIORequestBody->agRequestType,
&(tdIORequestBody->transport.SAS.agSASRequestBody),
agNULL,
&ossaSSPCompleted);
if (saStatus == AGSA_RC_SUCCESS)
{
TI_DBG1(("ossaIniSetDeviceInfoCB: retried\n"));
Initiator->NumIOsActive++;
tdIORequestBody->ioStarted = agTRUE;
tdIORequestBody->ioCompleted = agFALSE;
return;
}
else
{
TI_DBG1(("ossaIniSetDeviceInfoCB: retry failed\n"));
tdIORequestBody->ioStarted = agFALSE;
tdIORequestBody->ioCompleted = agTRUE;
ostiInitiatorIOCompleted(
tiRoot,
tdIORequestBody->tiIORequest,
tiIOFailed,
tiDetailOtherError,
agNULL,
intContext
);
}
}
}
return;
}
#endif
GLOBAL void ossaSetDeviceInfoCB(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
agsaDevHandle_t *agDevHandle,
bit32 status,
bit32 option,
bit32 param
)
{
tdsaDeviceData_t *oneDeviceData = agNULL;
TI_DBG4(("ossaSetDeviceInfoCB: start\n"));
TI_DBG4(("ossaSetDeviceInfoCB: status 0x%x\n", status));
TI_DBG4(("ossaSetDeviceInfoCB: option 0x%x\n", option));
TI_DBG4(("ossaSetDeviceInfoCB: param 0x%x\n", param));
if (status != OSSA_SUCCESS)
{
TI_DBG1(("ossaSetDeviceInfoCB: status %d\n", status));
TI_DBG1(("ossaSetDeviceInfoCB: option 0x%x\n", option));
TI_DBG1(("ossaSetDeviceInfoCB: param 0x%x\n", param));
}
if (agDevHandle == agNULL)
{
TI_DBG4(("ossaSetDeviceInfoCB: agDevHandle is NULL\n"));
return;
}
oneDeviceData = (tdsaDeviceData_t *)agDevHandle->osData;
if (oneDeviceData == agNULL)
{
TI_DBG1(("ossaSetDeviceInfoCB: wrong; oneDeviceData is NULL\n"));
}
else
{
TI_DBG4(("ossaSetDeviceInfoCB: did %d\n", oneDeviceData->id));
}
return;
}
GLOBAL void ossaGetDFEDataCB(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 status,
bit32 agInfoLen)
{
TI_DBG1(("ossaGetDFEDataCB: start\n"));
TI_DBG1(("ossaGetDFEDataCB: status 0x%x agInfoLen 0x%x\n", status, agInfoLen));
return;
}
void ossaVhistCaptureCB(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 status,
bit32 len)
{
TI_DBG1(("ossaVhistCaptureCB: start\n"));
TI_DBG1(("ossaVhistCaptureCB: status 0x%x agInfoLen 0x%x\n", status,len ));
return;
}
GLOBAL void ossaOperatorManagementCB(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 status,
bit32 eq
)
{
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
tiEncryptPort_t encryptEventData;
TI_DBG1(("ossaOperatorManagementCB: status 0x%x eq 0x%x\n", status, eq));
osti_memset(&encryptEventData, 0, sizeof(tiEncryptPort_t));
encryptEventData.encryptEvent = tiEncryptOperatorManagement;
encryptEventData.subEvent = eq;
encryptEventData.pData = agNULL;
ostiPortEvent(tiRoot,
tiEncryptOperation,
status,
&encryptEventData);
}
GLOBAL void ossaEncryptSelftestExecuteCB (
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 status,
bit32 type,
bit32 length,
void *TestResult
)
{
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
tiEncryptPort_t encryptEventData;
TI_DBG1(("ossaEncryptSelftestExecuteCB: status 0x%x type 0x%x length 0x%x\n", status, type, length));
osti_memset(&encryptEventData, 0, sizeof(tiEncryptPort_t));
encryptEventData.encryptEvent = tiEncryptSelfTest;
encryptEventData.subEvent = type;
encryptEventData.pData = (void*)TestResult;
ostiPortEvent(tiRoot,
tiEncryptOperation,
status,
&encryptEventData);
}
GLOBAL void ossaGetOperatorCB(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 status,
bit32 option,
bit32 num,
bit32 role,
agsaID_t *id
)
{
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
tiEncryptPort_t encryptEventData;
TI_DBG1(("ossaGetOperatorCB: status 0x%x option 0x%x num 0x%x role 0x%x\n",
status, option, num, role));
TI_DBG1(("ossaGetOperatorCB: agContext %p id %p\n",agContext,id));
osti_memset(&encryptEventData, 0, sizeof(tiEncryptPort_t));
encryptEventData.encryptEvent = tiEncryptGetOperator;
encryptEventData.subEvent = option;
encryptEventData.pData = agNULL;
switch(status)
{
case OSSA_IO_SUCCESS:
TI_DBG1(("ossaGetOperatorCB: OSSA_IO_SUCCESS option 0x%x\n", option));
if(option == 1)
{
TI_DBG2(("ossaGetOperatorCB: 0x%02x 0x%02x 0x%02x 0x%02x\n",id->ID[0], id->ID[1], id->ID[2], id->ID[3]));
TI_DBG2(("ossaGetOperatorCB: 0x%02x 0x%02x 0x%02x 0x%02x\n",id->ID[4], id->ID[5], id->ID[6], id->ID[7]));
TI_DBG2(("ossaGetOperatorCB: 0x%02x 0x%02x 0x%02x 0x%02x\n",id->ID[8], id->ID[9], id->ID[10],id->ID[11]));
TI_DBG2(("ossaGetOperatorCB: 0x%02x 0x%02x 0x%02x 0x%02x\n",id->ID[12],id->ID[13],id->ID[14],id->ID[15]));
TI_DBG2(("ossaGetOperatorCB: 0x%02x 0x%02x 0x%02x 0x%02x\n",id->ID[16],id->ID[17],id->ID[18],id->ID[19]));
TI_DBG2(("ossaGetOperatorCB: 0x%02x 0x%02x 0x%02x 0x%02x\n",id->ID[20],id->ID[21],id->ID[22],id->ID[23]));
TI_DBG2(("ossaGetOperatorCB: 0x%02x 0x%02x 0x%02x 0x%02x\n",id->ID[24],id->ID[25],id->ID[26],id->ID[27]));
TI_DBG2(("ossaGetOperatorCB: 0x%02x 0x%02x 0x%02x\n", id->ID[28],id->ID[29],id->ID[30]));
}else if(option == 2)
{
TI_DBG1(("ossaGetOperatorCB: number operators 0x%02x\n", num ));
}
encryptEventData.pData = id;
break;
case OSSA_MPI_ENC_ERR_UNSUPPORTED_OPTION:
TI_DBG1(("ossaGetOperatorCB: OSSA_MPI_ENC_ERR_UNSUPPORTED_OPTION 0x%x\n",option));
break;
case OSSA_MPI_ENC_ERR_ID_TRANSFER_FAILURE:
TI_DBG1(("ossaGetOperatorCB: OSSA_MPI_ENC_ERR_ID_TRANSFER_FAILURE 0x%x\n",option));
break;
default:
TI_DBG1(("ossaGetOperatorCB: Unknown status 0x%x\n",status));
}
ostiPortEvent(tiRoot,
tiEncryptOperation,
status,
&encryptEventData);
}
GLOBAL void ossaSetOperatorCB(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 status,
bit32 eq
)
{
tdsaRootOsData_t *osData = (tdsaRootOsData_t *)agRoot->osData;
tiRoot_t *tiRoot = (tiRoot_t *)osData->tiRoot;
tiEncryptPort_t encryptEventData;
TI_DBG1(("ossaSetOperatorCB: agContext %p status 0x%x eq 0x%x\n",agContext, status, eq));
osti_memset(&encryptEventData, 0, sizeof(tiEncryptPort_t));
encryptEventData.encryptEvent = tiEncryptSetOperator;
encryptEventData.subEvent = 0;
switch(status)
{
case OSSA_IO_SUCCESS:
TI_DBG1(("ossaSetOperatorCB: OSSA_IO_SUCCESS\n"));
encryptEventData.pData = agNULL;
break;
case OSSA_MPI_ENC_ERR_CONTROLLER_NOT_IDLE:
TI_DBG1(("ossaSetOperatorCB: OSSA_MPI_ENC_ERR_CONTROLLER_NOT_IDLE\n"));
break;
case OSSA_MPI_ENC_OPERATOR_AUTH_FAILURE:
TI_DBG1(("ossaSetOperatorCB: OSSA_MPI_ENC_OPERATOR_AUTH_FAILURE error qualifier 0x%x\n",eq));
break;
case OSSA_MPI_ENC_OPERATOR_OPERATOR_ALREADY_LOGGED_IN:
TI_DBG1(("ossaSetOperatorCB: OSSA_MPI_ENC_OPERATOR_OPERATOR_ALREADY_LOGGED_IN\n"));
break;
case OSSA_MPI_ENC_OPERATOR_ILLEGAL_PARAMETER:
TI_DBG1(("ossaSetOperatorCB: OSSA_MPI_ENC_OPERATOR_ILLEGAL_PARAMETER\n"));
break;
case OSSA_MPI_ENC_ERR_UNSUPPORTED_OPTION:
TI_DBG1(("ossaSetOperatorCB: OSSA_MPI_ENC_ERR_UNSUPPORTED_OPTION\n"));
break;
case OSSA_MPI_ENC_ERR_ID_TRANSFER_FAILURE:
TI_DBG1(("ossaSetOperatorCB: OSSA_MPI_ENC_ERR_ID_TRANSFER_FAILURE\n"));
break;
default:
TI_DBG1(("ossaGetOperatorCB: Unknown status 0x%x\n",status));
}
ostiPortEvent(tiRoot,
tiEncryptOperation,
status,
&encryptEventData);
}
GLOBAL void ossaDIFEncryptionOffloadStartCB(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 status,
agsaOffloadDifDetails_t *agsaOffloadDifDetails)
{
TI_DBG1(("ossaDIFEncryptionOffloadStartCB: start\n"));
TI_DBG1(("ossaDIFEncryptionOffloadStartCB: status 0x%x agsaOffloadDifDetails=%p\n", status, agsaOffloadDifDetails));
return;
}
GLOBAL bit32 ossaTimeStamp( agsaRoot_t *agRoot )
{
tdsaRootOsData_t *osData= agNULL;
tiRoot_t *tiRoot= agNULL;
if(agRoot)
{
osData = (tdsaRootOsData_t *)agRoot->osData;
}
if(osData)
{
tiRoot = (tiRoot_t *)osData->tiRoot;
}
return(ostiTimeStamp(tiRoot));
}
GLOBAL bit64 ossaTimeStamp64( agsaRoot_t *agRoot)
{
tdsaRootOsData_t *osData= agNULL;
tiRoot_t *tiRoot= agNULL;
if(agRoot)
{
osData = (tdsaRootOsData_t *)agRoot->osData;
}
if(osData)
{
tiRoot = (tiRoot_t *)osData->tiRoot;
}
return(ostiTimeStamp64(tiRoot));
}
#ifdef FDS_SM
osGLOBAL void
tdIDStartTimer(tiRoot_t *tiRoot,
smIORequest_t *smIORequest,
tdsaDeviceData_t *oneDeviceData
)
{
tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
itdsaIni_t *Initiator = (itdsaIni_t *)tdsaAllShared->itdsaIni;
TI_DBG1(("tdIDStartTimer: start\n"));
tdsaSingleThreadedEnter(tiRoot, TD_TIMER_LOCK);
if (oneDeviceData->tdIDTimer.timerRunning == agTRUE)
{
tdsaSingleThreadedLeave(tiRoot, TD_TIMER_LOCK);
tdsaKillTimer(
tiRoot,
&oneDeviceData->tdIDTimer
);
}
else
{
tdsaSingleThreadedLeave(tiRoot, TD_TIMER_LOCK);
}
tdsaSetTimerRequest(
tiRoot,
&oneDeviceData->tdIDTimer,
SATA_ID_DEVICE_DATA_TIMER_VALUE/Initiator->OperatingOption.UsecsPerTick,
tdIDStartTimerCB,
smIORequest,
oneDeviceData,
agNULL
);
tdsaAddTimer(
tiRoot,
&Initiator->timerlist,
&oneDeviceData->tdIDTimer
);
TI_DBG1(("tdIDStartTimer: end\n"));
return;
}
osGLOBAL void
tdIDStartTimerCB(
tiRoot_t * tiRoot,
void * timerData1,
void * timerData2,
void * timerData3
)
{
tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
smIORequest_t *smIORequest;
tdsaDeviceData_t *oneDeviceData;
smRoot_t *smRoot;
tdIORequestBody_t *tdIORequestBody;
smDeviceHandle_t *smDeviceHandle;
tdsaPortContext_t *onePortContext;
#ifdef REMOVED
agsaRoot_t *agRoot;
bit32 IDstatus;
agsaIORequest_t *agAbortIORequest = agNULL;
tdIORequestBody_t *tdAbortIORequestBody = agNULL;
bit32 PhysUpper32;
bit32 PhysLower32;
bit32 memAllocStatus;
void *osMemHandle;
#endif
#ifdef TD_DEBUG_ENABLE
bit32 status = AGSA_RC_FAILURE;
#endif
TI_DBG1(("tdIDStartTimerCB start\n"));
smIORequest = (smIORequest_t *)timerData1;
oneDeviceData = (tdsaDeviceData_t *)timerData2;
smRoot = &(tdsaAllShared->smRoot);
#ifdef REMOVED
agRoot = oneDeviceData->agRoot;
#endif
if (smIORequest == agNULL)
{
TI_DBG1(("tdIDStartTimerCB: smIORequest == agNULL !!!!!!\n"));
return;
}
if (oneDeviceData == agNULL)
{
TI_DBG1(("tdIDStartTimerCB: oneDeviceData == agNULL !!!!!!\n"));
return;
}
if (oneDeviceData->satDevData.IDPending == agFALSE || oneDeviceData->satDevData.IDDeviceValid == agTRUE)
{
return;
}
tdIORequestBody = (tdIORequestBody_t *)smIORequest->tdData;
smDeviceHandle = (smDeviceHandle_t *)&(oneDeviceData->smDeviceHandle);
onePortContext = oneDeviceData->tdPortContext;
if (tdIORequestBody == agNULL)
{
TI_DBG1(("tdIDStartTimerCB: tdIORequestBody == agNULL !!!!!!\n"));
return;
}
if (smDeviceHandle == agNULL)
{
TI_DBG1(("tdIDStartTimerCB: smDeviceHandle == agNULL !!!!!!\n"));
return;
}
if (onePortContext == agNULL)
{
TI_DBG1(("tdIDStartTimerCB: onePortContext == agNULL !!!!!!\n"));
return;
}
TI_DBG1(("tdIDStartTimerCB: did %d\n", oneDeviceData->id));
if (oneDeviceData->valid == agFALSE)
{
TI_DBG1(("tdIDStartTimerCB: invalid device\n"));
return;
}
#ifdef TD_DEBUG_ENABLE
status = smIOAbort( smRoot, smIORequest );
#else
smIOAbort( smRoot, smIORequest );
#endif
#ifdef REMOVED
memAllocStatus = ostiAllocMemory(
tiRoot,
&osMemHandle,
(void **)&tdAbortIORequestBody,
&PhysUpper32,
&PhysLower32,
8,
sizeof(tdIORequestBody_t),
agTRUE
);
if (memAllocStatus != tiSuccess)
{
TI_DBG1(("tdIDStartTimerCB: ostiAllocMemory failed...; can't retry ID data \n"));
return;
}
if (tdAbortIORequestBody == agNULL)
{
TI_DBG1(("tdIDStartTimerCB: ostiAllocMemory returned NULL tdAbortIORequestBody; can't retry ID data\n"));
return;
}
tdAbortIORequestBody->IOType.InitiatorTMIO.osMemHandle = osMemHandle;
tdAbortIORequestBody->IOCompletionFunc = agNULL;
tdAbortIORequestBody->tiDevHandle = (tiDeviceHandle_t *)&(oneDeviceData->tiDeviceHandle);
agAbortIORequest = &(tdAbortIORequestBody->agIORequest);
agAbortIORequest->osData = (void *) tdAbortIORequestBody;
agAbortIORequest->sdkData = agNULL;
status = saSATAAbort(agRoot,
agAbortIORequest,
0,
oneDeviceData->agDevHandle,
1,
agNULL,
ossaSATAIDAbortCB
);
status = saSATAAbort(agRoot,
agAbortIORequest,
0,
oneDeviceData->agDevHandle,
0,
agIORequest,
ossaSATAIDAbortCB
);
if (status != AGSA_RC_SUCCESS)
{
TI_DBG1(("tdIDStartTimerCB: saSATAAbort failed; can't retry ID data\n"));
}
if (oneDeviceData->satDevData.IDDeviceValid == agTRUE)
{
TI_DBG1(("tdIDStartTimerCB: IDDeviceValid is valid, no need to retry\n"));
return;
}
if (tdIORequestBody->reTries <= SM_RETRIES)
{
tdIORequestBody->tiIORequest = agNULL;
tdIORequestBody->pid = onePortContext->id;
smIORequest->tdData = tdIORequestBody;
smIORequest->smData = &tdIORequestBody->smIORequestBody;
smDeviceHandle->tdData = oneDeviceData;
IDstatus = smIDStart(smRoot, smIORequest, smDeviceHandle );
if (IDstatus == SM_RC_SUCCESS)
{
TI_DBG1(("tdIDStartTimerCB: being retried!!!\n"));
tdIORequestBody->reTries++;
tdIORequestBody->ioCompleted = agFALSE;
tdIORequestBody->ioStarted = agTRUE;
tdIDStartTimer(tiRoot, smIORequest, oneDeviceData);
}
else
{
TI_DBG1(("tdIDStartTimerCB: smIDStart fail or busy %d!!!\n", IDstatus));
tdIORequestBody->reTries = 0;
tdIORequestBody->ioCompleted = agTRUE;
tdIORequestBody->ioStarted = agFALSE;
ostiFreeMemory( tiRoot,
tdIORequestBody->osMemHandle,
sizeof(tdIORequestBody_t)
);
oneDeviceData->satDevData.IDDeviceValid = agFALSE;
smReportRemoval(tiRoot, agRoot, oneDeviceData, onePortContext);
return;
}
}
else
{
TI_DBG1(("tdIDStartTimerCB: retries are over!!!\n"));
if (oneDeviceData->tdIDTimer.timerRunning == agTRUE)
{
tdsaKillTimer( tiRoot, &oneDeviceData->tdIDTimer );
}
tdIORequestBody->reTries = 0;
tdIORequestBody->ioCompleted = agTRUE;
tdIORequestBody->ioStarted = agFALSE;
ostiFreeMemory(
tiRoot,
tdIORequestBody->osMemHandle,
sizeof(tdIORequestBody_t)
);
oneDeviceData->satDevData.IDDeviceValid = agFALSE;
if (oneDeviceData->SMNumOfID <= 0)
{
TI_DBG1(("tdIDStartTimerCB: fail; sending HARD_RESET\n"));
oneDeviceData->SMNumOfID++;
if (oneDeviceData->directlyAttached == agTRUE)
{
saLocalPhyControl(agRoot, agNULL, 0, oneDeviceData->phyID, AGSA_PHY_HARD_RESET, agNULL);
}
else
{
tdsaPhyControlSend(tiRoot,
oneDeviceData,
SMP_PHY_CONTROL_HARD_RESET,
agNULL);
}
}
else
{
TI_DBG1(("tdIDStartTimerCB: fail; but giving up sending HARD_RESET!!!\n"));
if (oneDeviceData->directlyAttached == agTRUE)
{
smReportRemovalDirect(tiRoot, agRoot, oneDeviceData);
}
else
{
smReportRemoval(tiRoot, agRoot, oneDeviceData, onePortContext);
}
}
}
#endif
TI_DBG1(("tdIDStartTimerCB: end, smIOAbort status %d\n", status));
return;
}
#endif
#if defined(FDS_DM) && defined(FDS_SM)
GLOBAL void
tdIDStart(
tiRoot_t *tiRoot,
agsaRoot_t *agRoot,
smRoot_t *smRoot,
tdsaDeviceData_t *oneDeviceData,
tdsaPortContext_t *onePortContext
)
{
tdsaRoot_t *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
tdsaContext_t *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
bit32 SMstatus = SM_RC_FAILURE;
tdIORequestBody_t *tdIORequestBody;
smIORequest_t *smIORequest;
smDeviceHandle_t *smDeviceHandle;
bit32 PhysUpper32;
bit32 PhysLower32;
bit32 memAllocStatus;
void *osMemHandle;
TI_DBG1(("tdIDStart: start, did %d\n",oneDeviceData->id));
if ( (DEVICE_IS_SATA_DEVICE(oneDeviceData)|| DEVICE_IS_STP_TARGET(oneDeviceData))
&&
oneDeviceData->satDevData.IDDeviceValid == agFALSE
&&
oneDeviceData->satDevData.IDPending == agFALSE
)
{
TI_DBG2(("tdIDStart: in loop, did %d\n", oneDeviceData->id));
memAllocStatus = ostiAllocMemory(
tiRoot,
&osMemHandle,
(void **)&tdIORequestBody,
&PhysUpper32,
&PhysLower32,
8,
sizeof(tdIORequestBody_t),
agTRUE
);
if (memAllocStatus != tiSuccess || tdIORequestBody == agNULL)
{
TI_DBG1(("tdIDStart: ostiAllocMemory failed... or ostiAllocMemory returned NULL tdIORequestBody!!!\n"));
oneDeviceData->satDevData.IDDeviceValid = agFALSE;
if (oneDeviceData->directlyAttached == agTRUE)
{
ostiPortEvent(
tiRoot,
tiPortLinkUp,
tiSuccess,
(void *)onePortContext->tiPortalContext
);
#ifdef INITIATOR_DRIVER
ostiPortEvent(
tiRoot,
tiPortDiscoveryReady,
tiSuccess,
(void *) onePortContext->tiPortalContext
);
#endif
}
}
else
{
osti_memset(tdIORequestBody, 0, sizeof(tdIORequestBody_t));
tdIORequestBody->osMemHandle = osMemHandle;
TI_DBG2(("tdIDStart: tdIORequestBody %p tdIORequestBody->osMemHandle %p\n", tdIORequestBody, tdIORequestBody->osMemHandle));
tdIORequestBody->IOCompletionFunc = agNULL;
tdIORequestBody->tiDevHandle = agNULL;
tdIORequestBody->tiIORequest = agNULL;
tdIORequestBody->pid = onePortContext->id;
tdIORequestBody->reTries = 0;
smIORequest = (smIORequest_t *)&(tdIORequestBody->smIORequest);
smIORequest->tdData = tdIORequestBody;
smIORequest->smData = &tdIORequestBody->smIORequestBody;
smDeviceHandle = (smDeviceHandle_t *)&(oneDeviceData->smDeviceHandle);
smDeviceHandle->tdData = oneDeviceData;
TI_DBG2(("tdIDStart: smIORequest %p\n", smIORequest));
SMstatus = smIDStart(smRoot,
smIORequest,
&(oneDeviceData->smDeviceHandle)
);
if (SMstatus == SM_RC_SUCCESS)
{
if (oneDeviceData->directlyAttached == agTRUE)
{
TI_DBG2(("tdIDStart: successfully sent identify device data\n"));
tdsaSingleThreadedEnter(tiRoot, TD_DEVICE_LOCK);
TDLIST_ENQUEUE_AT_TAIL(&(oneDeviceData->MainLink), &(tdsaAllShared->MainDeviceList));
tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK);
TI_DBG6(("tdIDStart: one case did %d \n", oneDeviceData->id));
}
oneDeviceData->satDevData.IDPending = agTRUE;
tdIDStartTimer(tiRoot, smIORequest, oneDeviceData);
}
else
{
TI_DBG1(("tdIDStart: smIDStart fail or busy %d\n", SMstatus));
ostiFreeMemory(
tiRoot,
tdIORequestBody->IOType.InitiatorTMIO.osMemHandle,
sizeof(tdIORequestBody_t)
);
oneDeviceData->satDevData.IDDeviceValid = agFALSE;
if (oneDeviceData->directlyAttached == agTRUE)
{
TI_DBG1(("tdIDStart: failed in sending identify device data\n"));
tdsaSingleThreadedEnter(tiRoot, TD_DEVICE_LOCK);
TDLIST_ENQUEUE_AT_TAIL(&(oneDeviceData->FreeLink), &(tdsaAllShared->FreeDeviceList));
tdsaSingleThreadedLeave(tiRoot, TD_DEVICE_LOCK);
ostiPortEvent(
tiRoot,
tiPortLinkUp,
tiSuccess,
(void *)onePortContext->tiPortalContext
);
#ifdef INITIATOR_DRIVER
ostiPortEvent(
tiRoot,
tiPortDiscoveryReady,
tiSuccess,
(void *) onePortContext->tiPortalContext
);
#endif
}
else
{
smReportRemoval(tiRoot, agRoot, oneDeviceData, onePortContext);
}
}
}
}
TI_DBG1(("tdIDStart: exit\n"));
return;
}
#endif
#ifdef SALLSDK_OS_IOMB_LOG_ENABLE
GLOBAL void ossaLogIomb(agsaRoot_t *agRoot,
bit32 queueNum,
agBOOLEAN isInbound,
void *pMsg,
bit32 msgLength)
{
return;
}
#endif
#ifndef SATA_ENABLE
osGLOBAL void ossaDiscoverSataCB( agsaRoot_t *agRoot,
agsaPortContext_t *agPortContext,
bit32 event,
void *pParm1,
void *pParm2
)
{
return;
}
GLOBAL void ossaSATACompleted(
agsaRoot_t *agRoot,
agsaIORequest_t *agIORequest,
bit32 agIOStatus,
void *agFirstDword,
bit32 agIOInfoLen,
void *agParam
)
{
return;
}
osGLOBAL void ossaSATAEvent(
agsaRoot_t *agRoot,
agsaIORequest_t *agIORequest,
agsaPortContext_t *agPortContext,
agsaDevHandle_t *agDevHandle,
bit32 event,
bit32 agIOInfoLen,
void *agParam
)
{
return;
}
osGLOBAL void ossaSATADeviceResetCB(
agsaRoot_t *agRoot,
agsaDevHandle_t *agDevHandle,
bit32 resetStatus,
void *resetparm)
{
return;
}
osGLOBAL void ossaDiscoverSasCB(agsaRoot_t *agRoot,
agsaPortContext_t *agPortContext,
bit32 event,
void *pParm1,
void *pParm2
)
{
return;
}
#endif
