/*******************************************************************************
*Copyright (c) 2014 PMC-Sierra, Inc. All rights reserved.
*
*Redistribution and use in source and binary forms, with or without modification, are permitted provided
*that the following conditions are met:
*1. Redistributions of source code must retain the above copyright notice, this list of conditions and the
*following disclaimer.
*2. Redistributions in binary form must reproduce the above copyright notice,
*this list of conditions and the following disclaimer in the documentation and/or other materials provided
*with the distribution.
*
*THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED
*WARRANTIES,INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
*FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
*FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
*NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
*BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
*LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
*SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
********************************************************************************/
/*******************************************************************************/
/*! \file sampirsp.c
* \brief The file implements the functions of MPI Outbound Response Message
*
*/
/******************************************************************************/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <dev/pms/config.h>
#include <dev/pms/RefTisa/sallsdk/spc/saglobal.h>
#ifdef SA_ENABLE_TRACE_FUNCTIONS
#ifdef siTraceFileID
#undef siTraceFileID
#endif
#define siTraceFileID 'J'
#endif
/******************************************************************************/
/* Protoytpes */
void saReturnRequestToFreePool(
agsaRoot_t *agRoot,
agsaIORequestDesc_t *pRequest
);
/******************************************************************************/
/*! \brief Process Outbound IOMB Message
*
* Process Outbound IOMB from SPC
*
* \param agRoot Handles for this instance of SAS/SATA LL Layer
* \param pMsg1 Pointer of Response IOMB message 1
* \param category category of outbpond IOMB header
* \param opcode Opcode of Outbound IOMB header
* \param bc buffer count of IOMB header
*
* \return success or fail
*
*/
/*******************************************************************************/
#if 0
FORCEINLINE bit32
mpiParseOBIomb(
agsaRoot_t *agRoot,
bit32 *pMsg1,
mpiMsgCategory_t category,
bit16 opcode
)
{
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
bit32 ret = AGSA_RC_SUCCESS;
bit32 parserStatus = AGSA_RC_SUCCESS;
smTraceFuncEnter(hpDBG_VERY_LOUD, "2f");
switch (opcode)
{
case OPC_OUB_COMBINED_SSP_COMP:
{
agsaSSPCoalescedCompletionRsp_t *pIomb = (agsaSSPCoalescedCompletionRsp_t *)pMsg1;
agsaIORequestDesc_t *pRequest = agNULL;
bit32 tag = 0;
bit32 sspTag = 0;
bit32 count = 0;
#ifdef SALL_API_TEST
saRoot->LLCounters.IOCounter.numSSPCompleted++;
SA_DBG3(("mpiParseOBIomb, SSP_COMP Response received IOMB=%p %d\n",
pMsg1, saRoot->LLCounters.IOCounter.numSSPCompleted));
#else
SA_DBG3(("mpiParseOBIomb, OPC_OUB_COMBINED_SSP_COMP Response received IOMB=%p\n", pMsg1));
#endif
/* get Tag */
for (count = 0; count < pIomb->coalescedCount; count++)
{
tag = pIomb->sspComplCxt[count].tag;
sspTag = pIomb->sspComplCxt[count].SSPTag;
pRequest = (agsaIORequestDesc_t *)saRoot->IOMap[tag].IORequest;
SA_ASSERT((pRequest), "pRequest");
if(pRequest == agNULL)
{
SA_DBG1(("mpiParseOBIomb,OPC_OUB_COMBINED_SSP_COMP Resp IOMB tag=0x%x, status=0x%x, param=0x%x, SSPTag=0x%x\n", tag, OSSA_IO_SUCCESS, 0, sspTag));
return(AGSA_RC_FAILURE);
}
SA_ASSERT((pRequest->valid), "pRequest->valid");
SA_DBG3(("mpiParseOBIomb, OPC_OUB_COMBINED_SSP_COMP IOMB tag=0x%x, status=0x%x, param=0x%x, SSPTag=0x%x\n", tag, OSSA_IO_SUCCESS, 0, sspTag));
/* Completion of SSP without Response Data */
siIODone( agRoot, pRequest, OSSA_IO_SUCCESS, sspTag);
}
}
break;
case OPC_OUB_SSP_COMP:
{
#ifdef SALL_API_TEST
saRoot->LLCounters.IOCounter.numSSPCompleted++;
SA_DBG3(("mpiParseOBIomb, SSP_COMP Response received IOMB=%p %d\n",
pMsg1, saRoot->LLCounters.IOCounter.numSSPCompleted));
#else
SA_DBG3(("mpiParseOBIomb, SSP_COMP Response received IOMB=%p\n", pMsg1));
#endif
/* process the SSP IO Completed response message */
mpiSSPCompletion(agRoot, pMsg1);
break;
}
case OPC_OUB_COMBINED_SATA_COMP:
{
agsaSATACoalescedCompletionRsp_t *pIomb;
agsaIORequestDesc_t *pRequest;
bit32 tag;
bit32 count;
#ifdef SALL_API_TEST
saRoot->LLCounters.IOCounter.numSSPCompleted++;
SA_DBG3(("mpiParseOBIomb, OPC_OUB_COMBINED_SATA_COMP Response received IOMB=%p %d\n",
pMsg1, saRoot->LLCounters.IOCounter.numSSPCompleted));
#else
SA_DBG3(("mpiParseOBIomb, OPC_OUB_COMBINED_SATA_COMP Response received IOMB=%p\n", pMsg1));
#endif
pIomb = (agsaSATACoalescedCompletionRsp_t *)pMsg1;
/* get Tag */
for (count = 0; count < pIomb->coalescedCount; count++)
{
tag = pIomb->stpComplCxt[count].tag;
pRequest = (agsaIORequestDesc_t *)saRoot->IOMap[tag].IORequest;
SA_ASSERT((pRequest), "pRequest");
if(pRequest == agNULL)
{
SA_DBG1(("mpiParseOBIomb,OPC_OUB_COMBINED_SATA_COMP Resp IOMB tag=0x%x, status=0x%x, param=0x%x\n", tag, OSSA_IO_SUCCESS, 0));
return(AGSA_RC_FAILURE);
}
SA_ASSERT((pRequest->valid), "pRequest->valid");
SA_DBG3(("mpiParseOBIomb, OPC_OUB_COMBINED_SATA_COMP IOMB tag=0x%x, status=0x%x, param=0x%x\n", tag, OSSA_IO_SUCCESS, 0));
/* Completion of SATA without Response Data */
siIODone( agRoot, pRequest, OSSA_IO_SUCCESS, 0);
}
break;
}
case OPC_OUB_SATA_COMP:
{
#ifdef SALL_API_TEST
saRoot->LLCounters.IOCounter.numSataCompleted++;
SA_DBG3(("mpiParseOBIomb, SATA_COMP Response received IOMB=%p %d\n",
pMsg1, saRoot->LLCounters.IOCounter.numSataCompleted));
#else
SA_DBG3(("mpiParseOBIomb, SATA_COMP Response received IOMB=%p\n", pMsg1));
#endif
/* process the response message */
mpiSATACompletion(agRoot, pMsg1);
break;
}
case OPC_OUB_SSP_ABORT_RSP:
{
#ifdef SALL_API_TEST
saRoot->LLCounters.IOCounter.numSSPAbortedCB++;
#else
SA_DBG3(("mpiParseOBIomb, SSP_ABORT Response received IOMB=%p\n", pMsg1));
#endif
/* process the response message */
parserStatus = mpiSSPAbortRsp(agRoot, (agsaSSPAbortRsp_t *)pMsg1);
if(parserStatus != AGSA_RC_SUCCESS)
{
SA_DBG3(("mpiParseOBIomb, mpiSSPAbortRsp FAIL IOMB=%p\n", pMsg1));
}
break;
}
case OPC_OUB_SATA_ABORT_RSP:
{
#ifdef SALL_API_TEST
saRoot->LLCounters.IOCounter.numSataAbortedCB++;
#else
SA_DBG3(("mpiParseOBIomb, SATA_ABORT Response received IOMB=%p\n", pMsg1));
#endif
/* process the response message */
mpiSATAAbortRsp(agRoot, (agsaSATAAbortRsp_t *)pMsg1);
break;
}
case OPC_OUB_SATA_EVENT:
{
SA_DBG3(("mpiParseOBIomb, SATA_EVENT Response received IOMB=%p\n", pMsg1));
/* process the response message */
mpiSATAEvent(agRoot, (agsaSATAEventRsp_t *)pMsg1);
break;
}
case OPC_OUB_SSP_EVENT:
{
SA_DBG3(("mpiParseOBIomb, SSP_EVENT Response received IOMB=%p\n", pMsg1));
/* process the response message */
mpiSSPEvent(agRoot, (agsaSSPEventRsp_t *)pMsg1);
break;
}
case OPC_OUB_SMP_COMP:
{
#ifdef SALL_API_TEST
saRoot->LLCounters.IOCounter.numSMPCompleted++;
SA_DBG3(("mpiParseOBIomb, SMP_COMP Response received IOMB=%p, %d\n",
pMsg1, saRoot->LLCounters.IOCounter.numSMPCompleted));
#else
SA_DBG3(("mpiParseOBIomb, SMP_COMP Response received IOMB=%p\n", pMsg1));
#endif
/* process the response message */
mpiSMPCompletion(agRoot, (agsaSMPCompletionRsp_t *)pMsg1);
break;
}
#ifndef BIOS
case OPC_OUB_ECHO:
{
#ifdef SALL_API_TEST
saRoot->LLCounters.IOCounter.numEchoCB++;
SA_DBG3(("mpiParseOBIomb, ECHO Response received %d\n", saRoot->LLCounters.IOCounter.numEchoCB));
#else
SA_DBG3(("mpiParseOBIomb, ECHO Response received\n"));
#endif
/* process the response message */
mpiEchoRsp(agRoot, (agsaEchoRsp_t *)pMsg1);
break;
}
#endif
case OPC_OUB_GET_NVMD_DATA:
{
SA_DBG3(("mpiParseOBIomb, OPC_OUB_GET_NVMD_DATA received IOMB=%p\n", pMsg1));
/* process the response message */
mpiGetNVMDataRsp(agRoot, (agsaGetNVMDataRsp_t *)pMsg1);
break;
}
case OPC_OUB_SPC_HW_EVENT:
{
SA_ASSERT((smIS_SPC(agRoot)), "smIS_SPC");
SA_DBG3(("mpiParseOBIomb, OPC_OUB_SPC_HW_EVENT Response received IOMB=%p\n", pMsg1));
/* process the response message */
mpiHWevent(agRoot, (agsaHWEvent_SPC_OUB_t *)pMsg1);
break;
}
case OPC_OUB_HW_EVENT:
{
SA_DBG3(("mpiParseOBIomb, HW_EVENT Response received IOMB=%p\n", pMsg1));
/* process the response message */
mpiHWevent(agRoot, (agsaHWEvent_SPC_OUB_t *)pMsg1);
break;
}
case OPC_OUB_PHY_START_RESPONSE:
{
SA_DBG1(("mpiParseOBIomb, OPC_OUB_PHY_START_RESPONSE Response received IOMB=%p\n", pMsg1));
/* process the response message */
mpiPhyStartEvent( agRoot, (agsaHWEvent_Phy_OUB_t *)pMsg1 );
break;
}
case OPC_OUB_PHY_STOP_RESPONSE:
{
SA_DBG1(("mpiParseOBIomb, OPC_OUB_PHY_STOP_RESPONSE Response received IOMB=%p\n", pMsg1));
/* process the response message */
mpiPhyStopEvent( agRoot, (agsaHWEvent_Phy_OUB_t *)pMsg1 );
break;
}
case OPC_OUB_LOCAL_PHY_CNTRL:
{
SA_DBG3(("mpiParseOBIomb, PHY CONTROL Response received IOMB=%p\n", pMsg1));
/* process the response message */
mpiPhyCntrlRsp(agRoot, (agsaLocalPhyCntrlRsp_t *)pMsg1);
break;
}
case OPC_OUB_SPC_DEV_REGIST:
{
SA_ASSERT((smIS_SPC(agRoot)), "smIS_SPC");
SA_DBG3(("mpiParseOBIomb, OPC_OUB_SPC_DEV_REGIST Response received IOMB=%p\n", pMsg1));
/* process the response message */
mpiDeviceRegRsp(agRoot, (agsaDeviceRegistrationRsp_t *)pMsg1);
break;
}
case OPC_OUB_DEV_REGIST:
{
SA_DBG2(("mpiParseOBIomb, DEV_REGISTRATION Response received IOMB=%p\n", pMsg1));
/* process the response message */
mpiDeviceRegRsp(agRoot, (agsaDeviceRegistrationRsp_t *)pMsg1);
break;
}
case OPC_OUB_DEREG_DEV:
{
SA_DBG3(("mpiParseOBIomb, DEREGISTRATION DEVICE Response received IOMB=%p\n", pMsg1));
/* process the response message */
mpiDeregDevHandleRsp(agRoot, (agsaDeregDevHandleRsp_t *)pMsg1);
break;
}
#ifndef BIOS
case OPC_OUB_GET_DEV_HANDLE:
{
SA_DBG3(("mpiParseOBIomb, GET_DEV_HANDLE Response received IOMB=%p\n", pMsg1));
/* process the response message */
mpiGetDevHandleRsp(agRoot, (agsaGetDevHandleRsp_t *)pMsg1);
break;
}
#endif
case OPC_OUB_SPC_DEV_HANDLE_ARRIV:
{
SA_DBG3(("mpiParseOBIomb, SPC_DEV_HANDLE_ARRIV Response received IOMB=%p\n", pMsg1));
/* process the response message */
mpiDeviceHandleArrived(agRoot, (agsaDeviceHandleArrivedNotify_t *)pMsg1);
break;
}
case OPC_OUB_DEV_HANDLE_ARRIV:
{
SA_DBG3(("mpiParseOBIomb, DEV_HANDLE_ARRIV Response received IOMB=%p\n", pMsg1));
/* process the response message */
mpiDeviceHandleArrived(agRoot, (agsaDeviceHandleArrivedNotify_t *)pMsg1);
break;
}
#if 0 //Sunitha
case OPC_OUB_THERM_HW_EVENT:
{
SA_DBG3(("mpiParseOBIomb, THERM_HW_EVENT Response received IOMB=%p\n", pMsg1));
ossaLogThermalEvent(agRoot, (agsaThermal_Hw_Event_Notify_t *)pMsg1);
break;
}
#endif //Sunitha
case OPC_OUB_SSP_RECV_EVENT:
{
SA_DBG3(("mpiParseOBIomb, SSP_RECV_EVENT Response received IOMB=%p\n", pMsg1));
/* process the response message */
mpiSSPReqReceivedNotify(agRoot, (agsaSSPReqReceivedNotify_t *)pMsg1);
break;
}
case OPC_OUB_DEV_INFO:
{
SA_ASSERT((smIS_SPCV(agRoot)), "smIS_SPCV");
SA_DBG3(("mpiParseOBIomb, DEV_INFO Response received IOMB=%p\n", pMsg1));
/* process the response message */
mpiGetDevInfoRsp(agRoot, (agsaGetDevInfoRspV_t *)pMsg1);
break;
}
#ifndef BIOS
case OPC_OUB_GET_PHY_PROFILE_RSP:
{
SA_ASSERT((smIS_SPCV(agRoot)), "smIS_SPCV");
SA_DBG2(("mpiParseOBIomb, OPC_OUB_GET_PHY_PROFILE_RSP Response received IOMB=%p\n", pMsg1));
/* process the response message */
mpiGetPhyProfileRsp(agRoot, (agsaGetPhyProfileRspV_t *)pMsg1);
break;
}
case OPC_OUB_SET_PHY_PROFILE_RSP:
{
SA_ASSERT((smIS_SPCV(agRoot)), "smIS_SPCV");
SA_DBG3(("mpiParseOBIomb, OPC_OUB_SET_PHY_PROFILE_RSP Response received IOMB=%p\n", pMsg1));
/* process the response message */
mpiSetPhyProfileRsp(agRoot, (agsaSetPhyProfileRspV_t *)pMsg1);
break;
}
#endif /* BIOS */
case OPC_OUB_SPC_DEV_INFO:
{
SA_ASSERT((smIS_SPC(agRoot)), "smIS_SPC");
SA_DBG3(("mpiParseOBIomb, DEV_INFO Response received IOMB=%p\n", pMsg1));
/* process the response message */
mpiGetDevInfoRspSpc(agRoot, (agsaGetDevInfoRsp_t *)pMsg1);
break;
}
case OPC_OUB_FW_FLASH_UPDATE:
{
SA_DBG3(("mpiParseOBIomb, OPC_OUB_FW_FLASH_UPDATE Response received IOMB=%p\n", pMsg1));
/* process the response message */
mpiFwFlashUpdateRsp(agRoot, (agsaFwFlashUpdateRsp_t *)pMsg1);
break;
}
case OPC_OUB_FLASH_OP_EXT_RSP:
{
SA_DBG3(("mpiParseOBIomb, OPC_OUB_FW_FLASH_UPDATE Response received IOMB=%p\n", pMsg1));
/* process the response message */
mpiFwExtFlashUpdateRsp(agRoot, (agsaFwFlashOpExtRsp_t *)pMsg1);
break;
}
#ifndef BIOS
#ifdef SPC_ENABLE_PROFILE
case OPC_OUB_FW_PROFILE:
{
SA_DBG3(("mpiParseOBIomb, OPC_OUB_FW_PROFILE Response received IOMB=%p\n", pMsg1));
/* process the response message */
mpiFwProfileRsp(agRoot, (agsaFwProfileRsp_t *)pMsg1);
break;
}
#endif
case OPC_OUB_SET_NVMD_DATA:
{
SA_DBG3(("mpiParseOBIomb, OPC_OUB_SET_NVMD_DATA received IOMB=%p\n", pMsg1));
/* process the response message */
mpiSetNVMDataRsp(agRoot, (agsaSetNVMDataRsp_t *)pMsg1);
break;
}
case OPC_OUB_GPIO_RESPONSE:
{
SA_DBG3(("mpiParseOBIomb, OPC_OUB_SET_GPIO_RESPONSE Response received IOMB=%p\n", pMsg1));
/* process the response message */
mpiGPIORsp(agRoot, (agsaGPIORsp_t *)pMsg1);
break;
}
case OPC_OUB_GPIO_EVENT:
{
SA_DBG3(("mpiParseOBIomb, OPC_OUB_SET_GPIO_RESPONSE Response received IOMB=%p\n", pMsg1));
/* process the response message */
mpiGPIOEventRsp(agRoot, (agsaGPIOEvent_t *)pMsg1);
break;
}
#endif /* BIOS */
case OPC_OUB_GENERAL_EVENT:
{
SA_DBG3(("mpiParseOBIomb, OPC_OUB_SET_GENERAL_EVENT Response received IOMB=%p\n", pMsg1));
/* process the response message */
mpiGeneralEventRsp(agRoot, (agsaGeneralEventRsp_t *)pMsg1);
break;
}
#ifndef BIOS
case OPC_OUB_SAS_DIAG_MODE_START_END:
{
SA_DBG3(("mpiParseOBIomb, OPC_OUB_SAS_DIAG_MODE_START_END Response received IOMB=%p\n", pMsg1));
/* process the response message */
mpiSASDiagStartEndRsp(agRoot, (agsaSASDiagStartEndRsp_t *)pMsg1);
break;
}
case OPC_OUB_SAS_DIAG_EXECUTE:
{
SA_DBG3(("mpiParseOBIomb, OPC_OUB_SAS_DIAG_EXECUTE_RSP Response received IOMB=%p\n", pMsg1));
/* process the response message */
mpiSASDiagExecuteRsp(agRoot, (agsaSASDiagExecuteRsp_t *)pMsg1);
break;
}
#endif /* BIOS */
case OPC_OUB_GET_TIME_STAMP:
{
SA_DBG3(("mpiParseOBIomb, OPC_OUB_GET_TIME_STAMP Response received IOMB=%p\n", pMsg1));
/* process the response message */
mpiGetTimeStampRsp(agRoot, (agsaGetTimeStampRsp_t *)pMsg1);
break;
}
case OPC_OUB_SPC_SAS_HW_EVENT_ACK:
{
SA_ASSERT((smIS_SPC(agRoot)), "smIS_SPC");
SA_DBG3(("mpiParseOBIomb,OPC_OUB_SPC_SAS_HW_EVENT_ACK Response received IOMB=%p\n", pMsg1));
/* process the response message */
mpiSASHwEventAckRsp(agRoot, (agsaSASHwEventAckRsp_t *)pMsg1);
break;
}
case OPC_OUB_SAS_HW_EVENT_ACK:
{
SA_ASSERT((smIS_SPCV(agRoot)), "smIS_SPCV");
SA_DBG3(("mpiParseOBIomb, OPC_OUB_SAS_HW_EVENT_ACK Response received IOMB=%p\n", pMsg1));
/* process the response message */
mpiSASHwEventAckRsp(agRoot, (agsaSASHwEventAckRsp_t *)pMsg1);
break;
}
case OPC_OUB_PORT_CONTROL:
{
SA_DBG3(("mpiParseOBIomb, OPC_OUB_PORT_CONTROL Response received IOMB=%p\n", pMsg1));
/* process the response message */
mpiPortControlRsp(agRoot, (agsaPortControlRsp_t *)pMsg1);
break;
}
case OPC_OUB_SMP_ABORT_RSP:
{
#ifdef SALL_API_TEST
saRoot->LLCounters.IOCounter.numSMPAbortedCB++;
SA_DBG3(("mpiParseOBIomb, SMP_ABORT Response received IOMB=%p, %d\n",
pMsg1, saRoot->LLCounters.IOCounter.numSMPAbortedCB));
#else
SA_DBG3(("mpiParseOBIomb, OPC_OUB_SMP_ABORT_RSP Response received IOMB=%p\n", pMsg1));
#endif
/* process the response message */
mpiSMPAbortRsp(agRoot, (agsaSMPAbortRsp_t *)pMsg1);
break;
}
case OPC_OUB_DEVICE_HANDLE_REMOVAL:
{
SA_DBG3(("mpiParseOBIomb, OPC_OUB_DEVICE_HANDLE_REMOVAL received IOMB=%p\n", pMsg1));
/* process the response message */
mpiDeviceHandleRemoval(agRoot, (agsaDeviceHandleRemoval_t *)pMsg1);
break;
}
case OPC_OUB_SET_DEVICE_STATE:
{
SA_DBG3(("mpiParseOBIomb, OPC_OUB_SET_DEVICE_STATE received IOMB=%p\n", pMsg1));
/* process the response message */
mpiSetDeviceStateRsp(agRoot, (agsaSetDeviceStateRsp_t *)pMsg1);
break;
}
#ifndef BIOS
case OPC_OUB_GET_DEVICE_STATE:
{
SA_DBG3(("mpiParseOBIomb, OPC_OUB_GET_DEVICE_STATE received IOMB=%p\n", pMsg1));
/* process the response message */
mpiGetDeviceStateRsp(agRoot, (agsaGetDeviceStateRsp_t *)pMsg1);
break;
}
#endif /* BIOS */
case OPC_OUB_SET_DEV_INFO:
{
SA_DBG3(("mpiParseOBIomb, OPC_OUB_SET_DEV_INFO received IOMB=%p\n", pMsg1));
/* process the response message */
mpiSetDevInfoRsp(agRoot, (agsaSetDeviceInfoRsp_t *)pMsg1);
break;
}
#ifndef BIOS_DEBUG
case OPC_OUB_SAS_RE_INITIALIZE:
{
SA_ASSERT((smIS_SPC(agRoot)), "smIS_SPC");
SA_DBG3(("mpiParseOBIomb, OPC_OUB_SAS_RE_INITIALIZE received IOMB=%p\n", pMsg1));
/* process the response message */
mpiSasReInitializeRsp(agRoot, (agsaSasReInitializeRsp_t *)pMsg1);
break;
}
#endif /* BIOS */
case OPC_OUB_SGPIO_RESPONSE:
{
SA_DBG3(("mpiParseOBIomb, OPC_OUB_SGPIO_RESPONSE Response received IOMB=%p\n", pMsg1));
/* process the response message */
mpiSGpioRsp(agRoot, (agsaSGpioRsp_t *)pMsg1);
break;
}
#ifndef BIOS
case OPC_OUB_PCIE_DIAG_EXECUTE:
{
SA_DBG3(("mpiParseOBIomb, OPC_OUB_PCIE_DIAG_EXECUTE Response received IOMB=%p\n", pMsg1));
/* process the response message */
mpiPCIeDiagExecuteRsp(agRoot, (agsaPCIeDiagExecuteRsp_t *)pMsg1);
break;
}
case 2104: //delray start
{
if(smIS_SPC6V(agRoot))
{
SA_DBG3(("mpiParseOBIomb, OPC_OUB_GET_DFE_DATA_RSP Response received IOMB=%p\n", pMsg1));
/* process the response message */
mpiGetDFEDataRsp(agRoot, (agsaGetDDEFDataRsp_t *)pMsg1);
}
if(smIS_SPC12V(agRoot))
{
SA_DBG3(("mpiParseOBIomb, OPC_INB_GET_VIST_CAP Response received IOMB=%p\n", pMsg1));
mpiGetVisRsp(agRoot, (agsaGetVisCapRsp_t *)pMsg1);
}
else
{
SA_DBG1(("mpiParseOBIomb, 2104 Response received IOMB=%p\n", pMsg1));
}
break;
}
#endif /* BIOS */
case OPC_OUB_SET_CONTROLLER_CONFIG:
{
SA_DBG3(("mpiParseOBIomb, OPC_OUB_SET_CONTROLLER_CONFIG Response received IOMB=%p\n", pMsg1));
mpiSetControllerConfigRsp(agRoot, (agsaSetControllerConfigRsp_t *)pMsg1);
break;
}
#ifndef BIOS
case OPC_OUB_GET_CONTROLLER_CONFIG:
{
SA_DBG3(("mpiParseOBIomb, OPC_OUB_GET_CONTROLLER_CONFIG Response received IOMB=%p\n", pMsg1));
mpiGetControllerConfigRsp(agRoot, (agsaGetControllerConfigRsp_t *)pMsg1);
break;
}
case OPC_OUB_KEK_MANAGEMENT:
{
SA_DBG3(("mpiParseOBIomb, OPC_OUB_KEK_MANAGEMENT Response received IOMB=%p\n", pMsg1));
mpiKekManagementRsp(agRoot, (agsaKekManagementRsp_t *)pMsg1);
break;
}
#endif /* BIOS */
#ifdef UN_USED_FUNC
case OPC_OUB_DEK_MANAGEMENT:
{
SA_DBG3(("mpiParseOBIomb, OPC_OUB_DEK_MANAGEMENT Response received IOMB=%p\n", pMsg1));
mpiDekManagementRsp(agRoot, (agsaDekManagementRsp_t *)pMsg1);
break;
}
#endif
#ifndef BIOS
case OPC_OUB_OPR_MGMT:
{
SA_DBG1(("mpiParseOBIomb, OPC_OUB_OPR_MGMT Response received IOMB=%p\n", pMsg1));
mpiOperatorManagementRsp(agRoot, (agsaOperatorMangmenRsp_t *)pMsg1);
break;
}
case OPC_OUB_ENC_TEST_EXECUTE:
{
SA_DBG1(("mpiParseOBIomb, OPC_OUB_ENC_TEST_EXECUTE Response received IOMB=%p\n", pMsg1));
mpiBistRsp(agRoot, (agsaEncryptBistRsp_t *)pMsg1);
break;
}
#endif /* BIOS */
case OPC_OUB_SET_OPERATOR:
{
SA_DBG1(("mpiParseOBIomb, OPC_OUB_SET_OPERATOR Response received IOMB=%p\n", pMsg1));
mpiSetOperatorRsp(agRoot, (agsaSetOperatorRsp_t *)pMsg1);
break;
}
case OPC_OUB_GET_OPERATOR:
{
SA_DBG1(("mpiParseOBIomb, OPC_OUB_GET_OPERATOR Response received IOMB=%p\n", pMsg1));
mpiGetOperatorRsp(agRoot, (agsaGetOperatorRsp_t *)pMsg1);
break;
}
case OPC_OUB_DIF_ENC_OFFLOAD_RSP://delray start
{
SA_ASSERT((smIS_SPCV(agRoot)), "smIS_SPCV");
SA_DBG1(("mpiParseOBIomb, OPC_OUB_DIF_ENC_OFFLOAD_RSP Response received IOMB=%p\n", pMsg1));
mpiDifEncOffloadRsp(agRoot, (agsaDifEncOffloadRspV_t *)pMsg1);
break;
} //delray end
default:
{
#ifdef SALL_API_TEST
saRoot->LLCounters.IOCounter.numUNKNWRespIOMB++;
SA_DBG1(("mpiParseOBIomb, UnKnown Response received IOMB=%p, %d\n",
pMsg1, saRoot->LLCounters.IOCounter.numUNKNWRespIOMB));
#else
SA_DBG1(("mpiParseOBIomb, Unknown IOMB Response received opcode 0x%X IOMB=%p\n",opcode, pMsg1));
#endif
break;
}
} /* switch */
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2f");
return ret;
}
#endif
#ifndef BIOS
#endif
/******************************************************************************/
/*! \brief ECHO Response
*
* This routine handles the response of ECHO Command
*
* \param agRoot Handles for this instance of SAS/SATA LLL
* \param pIomb Pointer of IOMB Mesage
*
* \return sucess or fail
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiEchoRsp(
agsaRoot_t *agRoot,
agsaEchoRsp_t *pIomb
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
agsaContext_t *agContext;
bit32 tag;
smTraceFuncEnter(hpDBG_VERY_LOUD, "2g");
SA_DBG3(("mpiEchoRsp: HTAG=0x%x\n", pIomb->tag));
/* get request from IOMap */
OSSA_READ_LE_32(agRoot, &tag, pIomb, OSSA_OFFSET_OF(agsaEchoRsp_t, tag));
pRequest = (agsaIORequestDesc_t *)saRoot->IOMap[tag].IORequest;
if (agNULL == pRequest)
{
SA_DBG1(("mpiEchoRsp: Bad Response IOMB!!! pRequest is NULL. TAG=0x%x\n", tag));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2g");
return AGSA_RC_FAILURE;
}
agContext = saRoot->IOMap[tag].agContext;
ossaEchoCB(agRoot, agContext, (void *)&pIomb->payload[0]);
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_ASSERT((pRequest->valid), "pRequest->valid");
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiEchoRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
/* return value */
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "2g");
return ret;
}
/******************************************************************************/
/*! \brief Get NVM Data Response
*
* This routine handles the response of GET NVM Data Response
*
* \param agRoot Handles for this instance of SAS/SATA LLL
* \param pIomb Pointer of IOMB Mesage
*
* \return sucess or fail
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiGetNVMDataRsp(
agsaRoot_t *agRoot,
agsaGetNVMDataRsp_t *pIomb
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
agsaContext_t *agContext;
bit32 i, dataLen;
bit32 DlenStatus, tag, iRTdaBnDpsAsNvm;
smTraceFuncEnter(hpDBG_VERY_LOUD, "2h");
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaGetNVMDataRsp_t, tag));
OSSA_READ_LE_32(AGROOT, &DlenStatus, pIomb, OSSA_OFFSET_OF(agsaGetNVMDataRsp_t, DlenStatus));
OSSA_READ_LE_32(AGROOT, &iRTdaBnDpsAsNvm, pIomb, OSSA_OFFSET_OF(agsaGetNVMDataRsp_t, iRTdaBnDpsAsNvm));
OSSA_READ_LE_32(AGROOT, &dataLen, pIomb, OSSA_OFFSET_OF(agsaGetNVMDataRsp_t, NVMData[10])) ;
SA_DBG1(("mpiGetNVMDataRsp: HTAG=0x%x\n", tag));
/* get request from IOMap */
pRequest = (agsaIORequestDesc_t *)saRoot->IOMap[tag].IORequest;
if (agNULL == pRequest)
{
SA_DBG1(("mpiGetNVMDataRsp: Bad Response IOMB!!! pRequest is NULL.\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2h");
return AGSA_RC_FAILURE;
}
agContext = saRoot->IOMap[tag].agContext;
if (iRTdaBnDpsAsNvm & IRMode)
{
/* indirect mode - IR bit set */
SA_DBG1(("mpiGetNVMDataRsp: OSSA_SUCCESS, IR=1, DataLen=%d\n", dataLen));
if (((iRTdaBnDpsAsNvm & NVMD_TYPE) == AGSA_NVMD_CONFIG_SEEPROM) ||
((iRTdaBnDpsAsNvm & NVMD_TYPE) == AGSA_NVMD_VPD_FLASH) ||
((iRTdaBnDpsAsNvm & NVMD_TYPE) == AGSA_NVMD_TWI_DEVICES) ||
((iRTdaBnDpsAsNvm & NVMD_TYPE) == AGSA_NVMD_EXPANSION_ROM) ||
((iRTdaBnDpsAsNvm & NVMD_TYPE) == AGSA_NVMD_IOP_REG_FLASH))
{
/* CB for NVMD */
//#ifdef UN_USED_FUNC
ossaGetNVMDResponseCB(agRoot, agContext, (DlenStatus & NVMD_STAT), INDIRECT_MODE, dataLen, agNULL);
//#endif
}
else if (((iRTdaBnDpsAsNvm & NVMD_TYPE) == AAP1_RDUMP) ||
((iRTdaBnDpsAsNvm & NVMD_TYPE) == IOP_RDUMP))
{
#ifdef UN_USED_FUNC
if ((DlenStatus & NVMD_STAT) == 0)
{
/* CB for Register Dump */
ossaGetRegisterDumpCB(agRoot, agContext, OSSA_SUCCESS);
}
else
{
/* CB for Register Dump */
ossaGetRegisterDumpCB(agRoot, agContext, OSSA_FAILURE);
}
#endif
}
else
{
/* Should not be happened */
SA_DBG1(("mpiGetNVMDataRsp: (IR=1)Wrong Device type 0x%x\n", iRTdaBnDpsAsNvm));
}
}
else /* direct mode */
{
SA_DBG1(("mpiGetNVMDataRsp: OSSA_SUCCESS, IR=0, DataLen=%d\n", ((DlenStatus & NVMD_LEN) >> SHIFT24)));
for (i = 0; i < (((DlenStatus & NVMD_LEN) >> SHIFT24)/4); i++)
{
SA_DBG1(("mpiGetNVMDataRsp: OSSA_SUCCESS, NVMDATA=0x%x\n", pIomb->NVMData[i]));
}
if (((iRTdaBnDpsAsNvm & NVMD_TYPE) == AGSA_NVMD_CONFIG_SEEPROM) ||
((iRTdaBnDpsAsNvm & NVMD_TYPE) == AGSA_NVMD_VPD_FLASH) ||
((iRTdaBnDpsAsNvm & NVMD_TYPE) == AGSA_NVMD_TWI_DEVICES))
{
/* CB for NVMD */
// char * safe_type_pun = (char *)(&pIomb->NVMData[0]);
#ifdef UN_USED_FUNC
ossaGetNVMDResponseCB(agRoot, agContext, (DlenStatus & NVMD_STAT), DIRECT_MODE,
((DlenStatus & NVMD_LEN) >> SHIFT24), (agsaFrameHandle_t *)safe_type_pun);
#endif
}
else if (((iRTdaBnDpsAsNvm & NVMD_TYPE) == AAP1_RDUMP) ||
((iRTdaBnDpsAsNvm & NVMD_TYPE) == IOP_RDUMP))
{
#ifdef UN_USED_FUNC
if ((DlenStatus & NVMD_STAT) == 0)
{
/* CB for Register Dump */
ossaGetRegisterDumpCB(agRoot, agContext, OSSA_SUCCESS);
}
else
{
/* CB for Register Dump */
ossaGetRegisterDumpCB(agRoot, agContext, OSSA_FAILURE);
}
#endif
}
else
{
/* Should not be happened */
SA_DBG1(("mpiGetNVMDataRsp: (IR=0)Wrong Device type 0x%x\n", iRTdaBnDpsAsNvm));
}
}
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_ASSERT((pRequest->valid), "pRequest->valid");
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiGetNVMDataRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "2h");
/* return value */
return ret;
}
/******************************************************************************/
/*! \brief Phy Event Response from SPCv
*
* Process Phy Event from SPC
*
* \param agRoot Handles for this instance of SAS/SATA LL Layer
* \param pIomb pointer of IOMB
*
* \return success or fail
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiPhyStartEvent(
agsaRoot_t *agRoot,
agsaHWEvent_Phy_OUB_t *pIomb
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
bit32 phyId;
bit32 IOMBStatus;
bit32 tag;
agsaIORequestDesc_t *pRequest;
agsaContext_t *agContext;
bit32 HwCBStatus;
if(saRoot == agNULL)
{
SA_DBG1(("mpiPhyStartEvent: saRoot == agNULL\n"));
return(AGSA_RC_FAILURE);
}
smTraceFuncEnter(hpDBG_VERY_LOUD, "2H");
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaHWEvent_Phy_OUB_t, tag)) ;
/* get request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
agContext = saRoot->IOMap[tag].agContext;
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
if (agNULL == pRequest)
{
SA_DBG1(("mpiPhyStartEvent: Bad Response IOMB!!! pRequest is NULL. TAG=0x%x \n", tag));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2H");
return AGSA_RC_FAILURE;
}
SA_DBG1(("mpiPhyStartEvent: Status 0x%X PhyId 0x%X\n",pIomb->Status,pIomb->ReservedPhyId));
OSSA_READ_LE_32(AGROOT, &IOMBStatus, pIomb, OSSA_OFFSET_OF(agsaHWEvent_Phy_OUB_t,Status ));
OSSA_READ_LE_32(AGROOT, &phyId, pIomb, OSSA_OFFSET_OF(agsaHWEvent_Phy_OUB_t,ReservedPhyId ));
switch (IOMBStatus)
{
case OSSA_MPI_IO_SUCCESS: /* PhyStart operation completed successfully */
HwCBStatus = 0;
saRoot->phys[phyId].linkstatus = 1;
SA_DBG1(("mpiPhyStartEvent:MPI_IO_SUCCESS IOMBStatus 0x%x for phyId 0x%x\n",IOMBStatus,phyId));
/* Callback with PHY_UP */
break;
case OSSA_MPI_ERR_INVALID_PHY_ID: /* identifier specified in the PHY_START command is invalid i.e out of supported range for this product. */
HwCBStatus = 1;
saRoot->phys[phyId].linkstatus = 0;
SA_DBG1(("mpiPhyStartEvent: MPI_ERR_INVALID_PHY_ID IOMBStatus 0x%x for phyId 0x%x\n",IOMBStatus,phyId));
ret = AGSA_RC_FAILURE;
break;
case OSSA_MPI_ERR_PHY_ALREADY_STARTED:
HwCBStatus = 2;
saRoot->phys[phyId].linkstatus = 1;
SA_DBG1(("mpiPhyStartEvent: MPI_ERR_PHY_ALREADY_STARTED IOMBStatus 0x%x for phyId 0x%x\n",IOMBStatus,phyId));
ret = AGSA_RC_FAILURE;
break;
case OSSA_MPI_ERR_INVALID_ANALOG_TBL_IDX:
HwCBStatus = 4;
saRoot->phys[phyId].linkstatus = 0;
SA_DBG1(("mpiPhyStartEvent: MPI_ERR_INVALID_ANALOG_TBL_IDX IOMBStatus 0x%x for phyId 0x%x\n",IOMBStatus,phyId));
ret = AGSA_RC_FAILURE;
break;
default:
HwCBStatus = 3;
saRoot->phys[phyId].linkstatus = 0;
SA_DBG1(("mpiPhyStartEvent: Unknown IOMBStatus 0x%x for phyId 0x%x\n",IOMBStatus,phyId));
ret = AGSA_RC_FAILURE;
break;
}
ossaHwCB(agRoot,agNULL, OSSA_HW_EVENT_PHY_START_STATUS ,((HwCBStatus << SHIFT8) | phyId) ,agContext, agNULL);
/* return the request to free pool */
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_ASSERT((pRequest->valid), "pRequest->valid");
pRequest->valid = agFALSE;
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiPhyStartEvent: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
return(ret);
}
GLOBAL bit32 mpiPhyStopEvent(
agsaRoot_t *agRoot,
agsaHWEvent_Phy_OUB_t *pIomb
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
bit32 phyId;
bit32 IOMBStatus;
bit32 HwCBStatus;
bit32 tag;
agsaIORequestDesc_t *pRequest;
agsaContext_t *agContext;
agsaPhy_t *pPhy;
agsaPort_t *pPort;
if(saRoot == agNULL)
{
SA_DBG1(("mpiPhyStopEvent: saRoot == agNULL\n"));
return(AGSA_RC_FAILURE);
}
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaHWEvent_Phy_OUB_t, tag)) ;
/* get request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
agContext = saRoot->IOMap[tag].agContext;
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
if (agNULL == pRequest)
{
SA_DBG1(("mpiPhyStopEvent: Bad Response IOMB!!! pRequest is NULL. TAG=0x%x \n", tag));
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "2H");
return AGSA_RC_FAILURE;
}
OSSA_READ_LE_32(AGROOT, &IOMBStatus, pIomb, OSSA_OFFSET_OF(agsaHWEvent_Phy_OUB_t,Status ));
OSSA_READ_LE_32(AGROOT, &phyId, pIomb, OSSA_OFFSET_OF(agsaHWEvent_Phy_OUB_t,ReservedPhyId ));
SA_DBG1(("mpiPhyStopEvent: Status %08X PhyId %08X\n",IOMBStatus,phyId));
if(smIS_SPCV(agRoot))
{
phyId &= 0xff; // SPCv PHY_ID is one byte wide
}
saRoot->phys[phyId].linkstatus = 0;
switch (IOMBStatus)
{
case OSSA_MPI_IO_SUCCESS: /* PhyStart operation completed successfully */
SA_DBG1(("mpiPhyStopEvent:MPI_IO_SUCCESS 0x%x for phyId 0x%x\n",IOMBStatus,phyId));
HwCBStatus = 0;
/* Callback with PHY_DOWN */
break;
case OSSA_MPI_ERR_INVALID_PHY_ID: /* identifier specified in the PHY_START command is invalid i.e out of supported range for this product. */
SA_DBG1(("mpiPhyStopEvent: MPI_ERR_INVALID_PHY_ID 0x%x for phyId 0x%x\n",IOMBStatus,phyId));
HwCBStatus = 1;
break;
case OSSA_MPI_ERR_PHY_NOT_STARTED: /* An attempt to stop a phy which is not started */
HwCBStatus = 4;
SA_DBG1(("mpiPhyStopEvent: 0x%x for phyId 0x%x\n",IOMBStatus,phyId));
break;
case OSSA_MPI_ERR_DEVICES_ATTACHED: /* All the devices in a port need to be deregistered if the PHY_STOP is for the last phy */
HwCBStatus = 2;
SA_DBG1(("mpiPhyStopEvent: 0x%x for phyId 0x%x\n",IOMBStatus,phyId));
break;
default:
HwCBStatus = 3;
SA_DBG1(("mpiPhyStopEvent: Unknown Status 0x%x for phyId 0x%x\n",IOMBStatus,phyId));
break;
}
if(HwCBStatus == 0)
{
pPhy = &(saRoot->phys[phyId]);
/* get the port of the phy */
pPort = pPhy->pPort;
if ( agNULL != pPort )
{
SA_DBG1(("siPhyStopCB: phy%d invalidating port\n", phyId));
/* invalid port state, remove the port */
pPort->status |= PORT_INVALIDATING;
saRoot->PortMap[pPort->portId].PortStatus |= PORT_INVALIDATING;
/* invalid the port */
siPortInvalid(agRoot, pPort);
/* map out the portmap */
saRoot->PortMap[pPort->portId].PortContext = agNULL;
saRoot->PortMap[pPort->portId].PortID = PORT_MARK_OFF;
saRoot->PortMap[pPort->portId].PortStatus |= PORT_INVALIDATING;
ossaHwCB(agRoot,&(pPort->portContext) , OSSA_HW_EVENT_PHY_STOP_STATUS, ((HwCBStatus << SHIFT8) | phyId ),agContext, agNULL);
}
else
{
SA_DBG1(("siPhyStopCB: phy%d - Port is not established\n", phyId));
ossaHwCB(agRoot, agNULL, OSSA_HW_EVENT_PHY_STOP_STATUS, ((HwCBStatus << SHIFT8) | phyId ) , agContext, agNULL);
}
/* set PHY_STOPPED status */
PHY_STATUS_SET(pPhy, PHY_STOPPED);
/* Exclude the phy from a port */
if ( agNULL != pPort )
{
/* Acquire port list lock */
ossaSingleThreadedEnter(agRoot, LL_PORT_LOCK);
/* Delete the phy from the port */
pPort->phyMap[phyId] = agFALSE;
saRoot->phys[phyId].pPort = agNULL;
/* Release port list lock */
ossaSingleThreadedLeave(agRoot, LL_PORT_LOCK);
}
}
else
{
SA_DBG1(("siPhyStopCB: Error phy%d - Port is not established\n", phyId));
ossaHwCB(agRoot, agNULL, OSSA_HW_EVENT_PHY_STOP_STATUS, ((HwCBStatus << SHIFT8) | phyId ) , agContext, agNULL);
}
/* return the request to free pool */
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_ASSERT((pRequest->valid), "pRequest->valid");
pRequest->valid = agFALSE;
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiPhyStartEvent: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
return(ret);
}
/******************************************************************************/
/*! \brief Hardware Event Response from SPC
*
* Process HW Event from SPC
*
* \param agRoot Handles for this instance of SAS/SATA LL Layer
* \param pIomb pointer of IOMB
*
* \return success or fail
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiHWevent(
agsaRoot_t *agRoot,
agsaHWEvent_SPC_OUB_t *pIomb
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
agsaPortContext_t *agPortContext;
agsaSASIdentify_t *IDframe;
agsaFisRegDeviceToHost_t *sataFis;
agsaContext_t *agContext;
agsaPort_t *pPort = agNULL;
bit32 phyId;
bit32 portId;
bit32 Event;
bit32 tag, status;
bit8 linkRate;
bit32 LREventPhyIdPortId;
bit32 npipps, eventParam,npip,port_state;
smTraceFuncEnter(hpDBG_VERY_LOUD,"2j");
SA_ASSERT((agNULL !=saRoot ), "");
if(saRoot == agNULL)
{
SA_DBG1(("mpiHWevent: saRoot == agNULL\n"));
return(AGSA_RC_FAILURE);
}
if(smIS_SPC(agRoot))
{
OSSA_READ_LE_32(AGROOT, &LREventPhyIdPortId, pIomb, OSSA_OFFSET_OF(agsaHWEvent_SPC_OUB_t, LRStatusEventPhyIdPortId));
OSSA_READ_LE_32(AGROOT, &npipps, pIomb, OSSA_OFFSET_OF(agsaHWEvent_SPC_OUB_t, NpipPortState));
OSSA_READ_LE_32(AGROOT, &eventParam, pIomb, OSSA_OFFSET_OF(agsaHWEvent_SPC_OUB_t, EVParam));
SA_DBG2(("mpiHWEvent: S, LREventPhyIdPortId 0x%08x npipps 0x%08x eventParam 0x%08x\n", LREventPhyIdPortId ,npipps ,eventParam ));
/* get port context */
portId = LREventPhyIdPortId & PORTID_MASK;
smTrace(hpDBG_VERY_LOUD,"QK",portId);
/* TP:QK portId */
/* get phyId */
phyId = (LREventPhyIdPortId & PHY_ID_BITS) >> SHIFT4;
smTrace(hpDBG_VERY_LOUD,"QK",npipps);
/* TP:QK npipps */
smTrace(hpDBG_VERY_LOUD,"QL",portId);
/* TP:QL portId */
smTrace(hpDBG_VERY_LOUD,"QM",phyId);
/* TP:QM phyId */
SA_DBG1(("mpiHWEvent:SPC, PhyID %d PortID %d NPIP 0x%x PS 0x%x\n",
phyId, portId, (npipps & PHY_IN_PORT_MASK) >> SHIFT4, (npipps & PORT_STATE_MASK)));
}
else
{
OSSA_READ_LE_32(AGROOT, &LREventPhyIdPortId, pIomb, OSSA_OFFSET_OF(agsaHWEvent_V_OUB_t, LRStatEventPortId));
OSSA_READ_LE_32(AGROOT, &npipps, pIomb, OSSA_OFFSET_OF(agsaHWEvent_V_OUB_t, RsvPhyIdNpipRsvPortState));
OSSA_READ_LE_32(AGROOT, &eventParam, pIomb, OSSA_OFFSET_OF(agsaHWEvent_V_OUB_t, EVParam));
SA_DBG2(("mpiHWEvent: V, LREventPhyIdPortId 0x%08x npipps 0x%08x eventParam 0x%08x\n", LREventPhyIdPortId ,npipps ,eventParam ));
smTrace(hpDBG_VERY_LOUD,"QN",npipps);
/* TP:QN npipps */
/* get port context */
portId = LREventPhyIdPortId & PORTID_MASK;
smTrace(hpDBG_VERY_LOUD,"QO",portId);
/* TP:QO portId */
/* get phyId */
phyId = (npipps & PHY_ID_V_BITS) >> SHIFT16;
smTrace(hpDBG_VERY_LOUD,"QP",phyId);
/* TP:QP phyId */
/* get npipps */
npip =(npipps & 0xFF00 ) >> SHIFT4;
port_state =(npipps & 0xF );
npipps = npip | port_state; // Make it look like SPCs nipps
SA_DBG1(("mpiHWEvent: V, PhyID 0x%x PortID 0x%x NPIP 0x%x PS 0x%x npipps 0x%x\n",
phyId, portId,npip,port_state,npipps));
}
Event = (LREventPhyIdPortId & HW_EVENT_BITS) >> SHIFT8;
/* get Link Rate */
linkRate = (bit8)((LREventPhyIdPortId & LINK_RATE_MASK) >> SHIFT28);
/* get status byte */
status = (LREventPhyIdPortId & STATUS_BITS) >> SHIFT24;
smTrace(hpDBG_VERY_LOUD,"HA",portId);
/* TP:HA portId */
smTrace(hpDBG_VERY_LOUD,"HB",linkRate);
/* TP:HB linkRate */
smTrace(hpDBG_VERY_LOUD,"HC",phyId);
/* TP:HC phyId */
smTrace(hpDBG_VERY_LOUD,"HD",npipps);
/* TP:HD npipps */
smTrace(hpDBG_VERY_LOUD,"HE",status);
/* TP:HE status */
if (portId > saRoot->phyCount)
{
if (OSSA_PORT_NOT_ESTABLISHED == (npipps & PORT_STATE_MASK))
{
/* out of range checking for portId */
SA_DBG1(("mpiHWEvent: PORT_ID is out of range, PhyID %d PortID %d\n",
phyId, portId));
/* port is not estiblished */
agPortContext = agNULL;
}
else
{
/* portId is bad and state is correct - should not happen */
SA_DBG1(("mpiHWEvent: PORT_ID is bad with correct Port State, PhyID %d PortID %d\n",
phyId, portId));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2j");
return AGSA_RC_FAILURE;
}
}
else
{
SA_DBG2(("mpiHWEvent:PortID 0x%x PortStatus 0x%x PortContext %p\n",saRoot->PortMap[portId & PORTID_MASK].PortID,saRoot->PortMap[portId & PORTID_MASK].PortStatus,saRoot->PortMap[portId & PORTID_MASK].PortContext));
agPortContext = (agsaPortContext_t *)saRoot->PortMap[portId].PortContext;
}
if(agPortContext == agNULL)
{
SA_DBG1(("mpiHWEvent: agPortContext is NULL, PhyID %d PortID %d\n",
phyId, portId));
}
smTrace(hpDBG_VERY_LOUD,"HF",Event);
/* TP:HF OSSA_HW_EVENT */
switch (Event)
{
case OSSA_HW_EVENT_SAS_PHY_UP:
{
SA_DBG1(("mpiHWEvent: OSSA_HW_EVENT_SAS_PHY_UP, PhyID %d PortID %d NPIP 0x%x PS 0x%x\n",
phyId, portId, (npipps & PHY_IN_PORT_MASK) >> SHIFT4, (npipps & PORT_STATE_MASK)));
/* get SAS Identify info */
IDframe = (agsaSASIdentify_t *)&pIomb->sasIdentify;
/* Callback about SAS link up */
saRoot->phys[phyId].linkstatus |= 2;
saRoot->phys[phyId].sasIdentify.phyIdentifier = IDframe->phyIdentifier;
saRoot->phys[phyId].sasIdentify.deviceType_addressFrameType = IDframe->deviceType_addressFrameType;
si_memcpy(&(saRoot->phys[phyId].sasIdentify.sasAddressHi),&(IDframe->sasAddressHi),4);
si_memcpy(&(saRoot->phys[phyId].sasIdentify.sasAddressLo),&(IDframe->sasAddressLo),4);
siEventPhyUpRcvd(agRoot, phyId, IDframe, portId, npipps, linkRate);
break;
}
case OSSA_HW_EVENT_SATA_PHY_UP:
{
SA_DBG1(("mpiHWEvent: OSSA_HW_EVENT_SATA_PHY_UP, PhyID %d PortID %d NPIP 0x%x PS 0x%x\n",
phyId, portId, (npipps & PHY_IN_PORT_MASK) >> SHIFT4, (npipps & PORT_STATE_MASK)));
/* get SATA FIS info */
saRoot->phys[phyId].linkstatus |= 2;
sataFis = (agsaFisRegDeviceToHost_t *)&pIomb->sataFis;
/* Callback about SATA Link Up */
siEventSATASignatureRcvd(agRoot, phyId, (void *)sataFis, portId, npipps, linkRate);
break;
}
case OSSA_HW_EVENT_SATA_SPINUP_HOLD:
{
SA_DBG1(("mpiHWEvent: OSSA_HW_EVENT_SATA_SPINUP_HOLD, PhyID %d\n", phyId));
ossaHwCB(agRoot, agNULL, OSSA_HW_EVENT_SATA_SPINUP_HOLD, phyId, agNULL, agNULL);
break;
}
case OSSA_HW_EVENT_PHY_DOWN:
{
agsaPhy_t *pPhy = &(saRoot->phys[phyId]);
if(pPhy) {
osti_memset(&pPhy->sasIdentify,0,sizeof(agsaSASIdentify_t));
}
saRoot->phys[phyId].linkstatus &= 1;
if (agNULL != agPortContext)
{
pPort = (agsaPort_t *) (agPortContext->sdkData);
}
SA_DBG1(("mpiHWEvent: OSSA_HW_EVENT_PHY_DOWN, PhyID %d PortID %d NPIP 0x%x PS 0x%x\n",
phyId, portId, (npipps & PHY_IN_PORT_MASK) >> SHIFT4, npipps & PORT_STATE_MASK));
/* callback */
if ( agNULL != pPort )
{
if (OSSA_PORT_VALID == (npipps & PORT_STATE_MASK))
{
pPort->status &= ~PORT_INVALIDATING;
saRoot->PortMap[portId].PortStatus &= ~PORT_INVALIDATING;
SA_DBG1(("mpiHWEvent: OSSA_HW_EVENT_PHY_DOWN, PhyID %d ~PORT_INVALIDATING \n", phyId));
}
else
{
if (OSSA_PORT_INVALID == (npipps & PORT_STATE_MASK))
{
/* set port invalid flag */
pPort->status |= PORT_INVALIDATING;
saRoot->PortMap[portId].PortStatus |= PORT_INVALIDATING;
SA_DBG1(("mpiHWEvent: OSSA_HW_EVENT_PHY_DOWN PortInvalid portID %d PortContext %p NPIP 0x%x\n", portId, agPortContext,npipps));
}
else
{
if (OSSA_PORT_IN_RESET == (npipps & PORT_STATE_MASK))
{
SA_DBG1(("mpiHWEvent: OSSA_HW_EVENT_PHY_DOWN PortInReset portID %d PortContext %p\n", portId, agPortContext));
}
else
{
SA_DBG1(("mpiHWEvent: OSSA_HW_EVENT_PHY_DOWN Not PortInReset portID %d PortContext %p\n", portId, agPortContext));
}
}
}
/* report PhyId, NPIP, PortState */
phyId |= (npipps & PHY_IN_PORT_MASK) | ((npipps & PORT_STATE_MASK) << SHIFT16);
/* Callback with PHY_DOWN */
ossaHwCB(agRoot, agPortContext, OSSA_HW_EVENT_PHY_DOWN, phyId, agNULL, agNULL);
}
else
{
/* no portcontext.- error */
SA_DBG1(("mpiHWEvent: OSSA_HW_EVENT_PHY_DOWN PhyDown pPort is NULL.\n"));
}
/* set PHY_DOWN status */
PHY_STATUS_SET(pPhy, PHY_DOWN);
break;
}
case OSSA_HW_EVENT_PHY_ERR_INBOUND_CRC:
{
agsaPhyErrCountersPage_t errorParam;
SA_DBG1(("mpiHWEvent: OSSA_HW_EVENT_PHY_ERR_INBOUND_CRC, PhyID %d PortID %d NPIP 0x%x PS 0x%x\n",
phyId, portId, (npipps & PHY_IN_PORT_MASK) >> SHIFT4, npipps & PORT_STATE_MASK));
si_memset(&errorParam, 0, sizeof(agsaPhyErrCountersPage_t));
errorParam.inboundCRCError = eventParam;
/* report PhyId, NPIP, PortState */
phyId |= (npipps & PHY_IN_PORT_MASK) | ((npipps & PORT_STATE_MASK) << SHIFT16);
ossaHwCB(agRoot, agPortContext, OSSA_HW_EVENT_PHY_ERR_INBOUND_CRC, phyId, (void *)&errorParam, agNULL);
break;
}
case OSSA_HW_EVENT_HARD_RESET_RECEIVED:
{
SA_DBG1(("mpiHWEvent: OSSA_HW_EVENT_HARD_RESET_RECEIVED, PhyID %d PortID %d NPIP 0x%x PS 0x%x\n",
phyId, portId, (npipps & PHY_IN_PORT_MASK) >> SHIFT4, npipps & PORT_STATE_MASK));
/* report PhyId, NPIP, PortState */
phyId |= (npipps & PHY_IN_PORT_MASK) | ((npipps & PORT_STATE_MASK) << SHIFT16);
ossaHwCB(agRoot, agPortContext, OSSA_HW_EVENT_HARD_RESET_RECEIVED, phyId, agNULL, agNULL);
break;
}
case OSSA_HW_EVENT_PHY_ERR_INVALID_DWORD:
{
agsaPhyErrCountersPage_t errorParam;
SA_DBG1(("mpiHWEvent: OSSA_HW_EVENT_LINK_ERR_INVALID_DWORD, PhyID %d PortID %d NPIP 0x%x PS 0x%x\n",
phyId, portId, (npipps & PHY_IN_PORT_MASK) >> SHIFT4, npipps & PORT_STATE_MASK));
si_memset(&errorParam, 0, sizeof(agsaPhyErrCountersPage_t));
errorParam.invalidDword = eventParam;
phyId |= (npipps & PHY_IN_PORT_MASK) | ((npipps & PORT_STATE_MASK) << SHIFT16);
ossaHwCB(agRoot, agPortContext, OSSA_HW_EVENT_PHY_ERR_INVALID_DWORD, phyId, (void *)&errorParam, agNULL);
break;
}
case OSSA_HW_EVENT_PHY_ERR_DISPARITY_ERROR:
{
agsaPhyErrCountersPage_t errorParam;
SA_DBG3(("mpiHWEvent: OSSA_HW_EVENT_LINK_ERR_DISPARITY_ERROR, PhyID %d PortID %d NPIP 0x%x PS 0x%x\n",
phyId, portId, (npipps & PHY_IN_PORT_MASK) >> SHIFT4, npipps & PORT_STATE_MASK));
/* report PhyId, NPIP, PortState */
si_memset(&errorParam, 0, sizeof(agsaPhyErrCountersPage_t));
errorParam.runningDisparityError = eventParam;
phyId |= (npipps & PHY_IN_PORT_MASK) | ((npipps & PORT_STATE_MASK) << SHIFT16);
ossaHwCB(agRoot, agPortContext, OSSA_HW_EVENT_PHY_ERR_DISPARITY_ERROR, phyId, (void *)&errorParam, agNULL);
break;
}
case OSSA_HW_EVENT_PHY_ERR_CODE_VIOLATION:
{
agsaPhyErrCountersPage_t errorParam;
SA_DBG1(("mpiHWEvent: OSSA_HW_EVENT_LINK_ERR_CODE_VIOLATION, PhyID %d PortID %d NPIP 0x%x PS 0x%x\n",
phyId, portId, (npipps & PHY_IN_PORT_MASK) >> SHIFT4, npipps & PORT_STATE_MASK));
/* report PhyId, NPIP, PortState */
si_memset(&errorParam, 0, sizeof(agsaPhyErrCountersPage_t));
errorParam.codeViolation = eventParam;
phyId |= (npipps & PHY_IN_PORT_MASK) | ((npipps & PORT_STATE_MASK) << SHIFT16);
ossaHwCB(agRoot, agPortContext, OSSA_HW_EVENT_PHY_ERR_CODE_VIOLATION, phyId, (void *)&errorParam, agNULL);
break;
}
case OSSA_HW_EVENT_PHY_ERR_LOSS_OF_DWORD_SYNCH:
{
agsaPhyErrCountersPage_t errorParam;
SA_DBG1(("mpiHWEvent: OSSA_HW_EVENT_LINK_ERR_LOSS_OF_DWORD_SYNCH, PhyID %d PortID %d NPIP 0x%x PS 0x%x\n",
phyId, portId, (npipps & PHY_IN_PORT_MASK) >> SHIFT4, npipps & PORT_STATE_MASK));
/* report PhyId, NPIP, PortState */
si_memset(&errorParam, 0, sizeof(agsaPhyErrCountersPage_t));
errorParam.lossOfDwordSynch = eventParam;
phyId |= (npipps & PHY_IN_PORT_MASK) | ((npipps & PORT_STATE_MASK) << SHIFT16);
ossaHwCB(agRoot, agPortContext, OSSA_HW_EVENT_PHY_ERR_LOSS_OF_DWORD_SYNCH, phyId, (void *)&errorParam, agNULL);
break;
}
case OSSA_HW_EVENT_PORT_RECOVERY_TIMER_TMO:
{
SA_DBG1(("mpiHWEvent: OSSA_HW_EVENT_PORT_RECOVERY_TIMER_TMO, PhyID %d PortID %d NPIP 0x%x PS 0x%x\n",
phyId, portId, (npipps & PHY_IN_PORT_MASK) >> SHIFT4, npipps & PORT_STATE_MASK));
if (agNULL != agPortContext)
{
pPort = (agsaPort_t *) (agPortContext->sdkData);
}
else
{
SA_ASSERT((agPortContext), "agPortContext agNULL was there a PHY UP?");
return(AGSA_RC_FAILURE);
}
/* report PhyId, NPIP, PortState */
phyId |= (npipps & PHY_IN_PORT_MASK) | ((npipps & PORT_STATE_MASK) << SHIFT16);
ossaHwCB(agRoot, agPortContext, OSSA_HW_EVENT_PORT_RECOVERY_TIMER_TMO, phyId, agNULL, agNULL);
if (OSSA_PORT_VALID == (npipps & PORT_STATE_MASK))
{
pPort->status &= ~PORT_INVALIDATING;
saRoot->PortMap[portId].PortStatus &= ~PORT_INVALIDATING;
SA_DBG1(("mpiHWEvent: OSSA_HW_EVENT_PORT_RECOVERY_TIMER_TMO NOT PORT_INVALIDATING portID %d PortContext %p\n", portId, agPortContext));
}
else
{
if (OSSA_PORT_INVALID == (npipps & PORT_STATE_MASK))
{
/* set port invalid flag */
pPort->status |= PORT_INVALIDATING;
saRoot->PortMap[portId].PortStatus |= PORT_INVALIDATING;
SA_DBG1(("mpiHWEvent: OSSA_HW_EVENT_PORT_RECOVERY_TIMER_TMO PORT_INVALIDATING portID %d PortContext %p\n", portId, agPortContext));
}
else
{
if (OSSA_PORT_IN_RESET == (npipps & PORT_STATE_MASK))
{
SA_DBG1(("mpiHWEvent: PortInReset portID %d PortContext %p\n", portId, agPortContext));
}
}
}
break;
}
case OSSA_HW_EVENT_PORT_RECOVER:
{
if (agNULL != agPortContext)
{
pPort = (agsaPort_t *) (agPortContext->sdkData);
}
SA_DBG1(("mpiHWEvent: OSSA_HW_EVENT_PORT_RECOVER, PhyID %d PortID %d NPIP 0x%x PS 0x%x\n",
phyId, portId, (npipps & PHY_IN_PORT_MASK) >> SHIFT4, npipps & PORT_STATE_MASK));
if (OSSA_PORT_VALID == (npipps & PORT_STATE_MASK))
{
if (agNULL != pPort)
{
/* reset port invalid flag */
pPort->status &= ~PORT_INVALIDATING;
SA_DBG1(("mpiHWEvent: OSSA_HW_EVENT_PORT_RECOVER NOT PORT_INVALIDATING portID %d PortContext %p\n", portId, agPortContext));
}
saRoot->PortMap[portId].PortStatus &= ~PORT_INVALIDATING;
}
/* get SAS Identify info */
IDframe = (agsaSASIdentify_t *)&pIomb->sasIdentify;
/* report PhyId, NPIP, PortState and LinkRate */
phyId |= (npipps & PHY_IN_PORT_MASK) | ((npipps & PORT_STATE_MASK) << SHIFT16) | (linkRate << SHIFT8);
ossaHwCB(agRoot, agPortContext, OSSA_HW_EVENT_PORT_RECOVER, phyId, agNULL, (void *)IDframe);
break;
}
case OSSA_HW_EVENT_PHY_STOP_STATUS:
{
SA_DBG1(("mpiHWEvent: OSSA_HW_EVENT_PHY_STOP_STATUS PhyId=0x%x, status=0x%x eventParam=0x%x\n", phyId, status,eventParam));
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaHWEvent_SPC_OUB_t, EVParam));
switch(eventParam)
{
case 0:
SA_DBG1(("mpiHWEvent: OSSA_HW_EVENT_PHY_STOP_STATUS Stopped 0\n" ));
break;
case 1:
SA_DBG1(("mpiHWEvent: OSSA_HW_EVENT_PHY_STOP_STATUS INVALID_PHY 1\n" ));
break;
case 2:
SA_DBG1(("mpiHWEvent: OSSA_HW_EVENT_PHY_STOP_STATUS DEVICES_ATTACHED 2\n" ));
break;
case 3:
SA_DBG1(("mpiHWEvent: OSSA_HW_EVENT_PHY_STOP_STATUS OTHER_FAILURE 3\n" ));
break;
case 4:
SA_DBG1(("mpiHWEvent: OSSA_HW_EVENT_PHY_STOP_STATUS PHY_NOT_ENABLED 4\n" ));
break;
default:
SA_DBG1(("mpiHWEvent: OSSA_HW_EVENT_PHY_STOP_STATUS Unknown code 0x%x\n", eventParam));
break;
}
SA_DBG1(("mpiHWEvent: OSSA_HW_EVENT_PHY_STOP_STATUS phyId 0x%x status 0x%x eventParam 0x%x\n", phyId, status,eventParam));
/* get request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
SA_ASSERT((pRequest), "pRequest NULL");
SA_ASSERT((pRequest->valid), "pRequest->valid");
agContext = saRoot->IOMap[tag].agContext;
siPhyStopCB(agRoot, phyId, status, agContext, portId, npipps);
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiHWevent: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
break;
}
case OSSA_HW_EVENT_BROADCAST_CHANGE:
{
SA_DBG1(("mpiHWEvent: OSSA_HW_EVENT_BROADCAST_CHANGE, PhyID %d PortID %d NPIP 0x%x PS 0x%x\n",
phyId, portId, (npipps & PHY_IN_PORT_MASK) >> SHIFT4, npipps & PORT_STATE_MASK));
/* report PhyId, NPIP, PortState */
phyId |= (npipps & PHY_IN_PORT_MASK) | ((npipps & PORT_STATE_MASK) << SHIFT16);
ossaHwCB(agRoot, agPortContext, OSSA_HW_EVENT_BROADCAST_CHANGE, phyId, agNULL, agNULL);
break;
}
case OSSA_HW_EVENT_BROADCAST_SES:
{
SA_DBG1(("mpiHWEvent: OSSA_HW_EVENT_BROADCAST_CHANGE_SES, PhyID %d PortID %d NPIP 0x%x PS 0x%x\n",
phyId, portId, (npipps & PHY_IN_PORT_MASK) >> SHIFT4, npipps & PORT_STATE_MASK));
/* report PhyId, NPIP, PortState */
phyId |= (npipps & PHY_IN_PORT_MASK) | ((npipps & PORT_STATE_MASK) << SHIFT16);
ossaHwCB(agRoot, agPortContext, OSSA_HW_EVENT_BROADCAST_SES, phyId, agNULL, agNULL);
break;
}
case OSSA_HW_EVENT_BROADCAST_EXP:
{
SA_DBG1(("mpiHWEvent: OSSA_HW_EVENT_BROADCAST_EXP, PhyID %d PortID %d NPIP 0x%x PS 0x%x\n",
phyId, portId, (npipps & PHY_IN_PORT_MASK) >> SHIFT4, npipps & PORT_STATE_MASK));
/* report PhyId, NPIP, PortState */
phyId |= (npipps & PHY_IN_PORT_MASK) | ((npipps & PORT_STATE_MASK) << SHIFT16);
ossaHwCB(agRoot, agPortContext, OSSA_HW_EVENT_BROADCAST_EXP, phyId, agNULL, agNULL);
break;
}
case OSSA_HW_EVENT_ID_FRAME_TIMEOUT:
{
SA_DBG1(("mpiHWEvent: OSSA_HW_EVENT_ID_FRAME_TIMEOUT, PhyID %d PortID %d NPIP 0x%x PS 0x%x\n",
phyId, portId, (npipps & PHY_IN_PORT_MASK) >> SHIFT4, npipps & PORT_STATE_MASK));
/* report PhyId, NPIP, PortState */
phyId |= (npipps & PHY_IN_PORT_MASK) | ((npipps & PORT_STATE_MASK) << SHIFT16);
ossaHwCB(agRoot, agPortContext, OSSA_HW_EVENT_ID_FRAME_TIMEOUT, phyId, agNULL, agNULL);
break;
}
case OSSA_HW_EVENT_PHY_START_STATUS:
{
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaHWEvent_SPC_OUB_t, EVParam)) ;
/* get request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
SA_ASSERT((pRequest), "pRequest");
if( pRequest == agNULL)
{
SA_DBG1(("mpiHWevent: pRequest (%p) NULL\n", pRequest));
ret = AGSA_RC_FAILURE;
break;
}
agContext = saRoot->IOMap[tag].agContext;
/* makeup for CB */
status = (status << 8) | phyId;
ossaHwCB(agRoot, agNULL, OSSA_HW_EVENT_PHY_START_STATUS, status, agContext, agNULL);
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_ASSERT((pRequest->valid), "pRequest->valid");
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiHWevent: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_DBG1(("mpiHWEvent: OSSA_HW_EVENT_PHY_START_STATUS, PhyID %d\n", phyId));
break;
}
case OSSA_HW_EVENT_PHY_ERR_PHY_RESET_FAILED:
{
agsaPhyErrCountersPage_t errorParam;
SA_DBG1(("mpiHWEvent: OSSA_HW_EVENT_PHY_ERR_PHY_RESET_FAILED, PhyID %d PortID %d NPIP 0x%x PS 0x%x\n",
phyId, portId, (npipps & PHY_IN_PORT_MASK) >> SHIFT4, npipps & PORT_STATE_MASK));
/* report PhyId, NPIP, PortState */
si_memset(&errorParam, 0, sizeof(agsaPhyErrCountersPage_t));
errorParam.phyResetProblem = eventParam;
phyId |= (npipps & PHY_IN_PORT_MASK) | ((npipps & PORT_STATE_MASK) << SHIFT16);
ossaHwCB(agRoot, agPortContext, OSSA_HW_EVENT_PHY_ERR_PHY_RESET_FAILED, phyId, (void *)&errorParam, agNULL);
break;
}
case OSSA_HW_EVENT_PORT_RESET_TIMER_TMO:
{
SA_DBG1(("mpiHWEvent: OSSA_HW_EVENT_PORT_RESET_TIMER_TMO, PhyID %d PortID %d\n", phyId, portId));
/* report PhyId, NPIP, PortState */
phyId |= (npipps & PHY_IN_PORT_MASK) | ((npipps & PORT_STATE_MASK) << SHIFT16);
ossaHwCB(agRoot, agPortContext, OSSA_HW_EVENT_PORT_RESET_TIMER_TMO, phyId, agNULL, agNULL);
break;
}
case OSSA_HW_EVENT_PORT_RESET_COMPLETE:
{
SA_DBG1(("mpiHWEvent: OSSA_HW_EVENT_PORT_RESET_COMPLETE, PhyID %d PortID %d\n", phyId, portId));
/* get SAS Identify info */
IDframe = (agsaSASIdentify_t *)&pIomb->sasIdentify;
/* report PhyId, NPIP, PortState and LinkRate */
phyId |= (npipps & PHY_IN_PORT_MASK) | ((npipps & PORT_STATE_MASK) << SHIFT16) | (linkRate << SHIFT8);
ossaHwCB(agRoot, agPortContext, OSSA_HW_EVENT_PORT_RESET_COMPLETE, phyId, agNULL, (void *)IDframe);
break;
}
case OSSA_HW_EVENT_BROADCAST_ASYNCH_EVENT:
{
SA_DBG1(("mpiHWEvent: OSSA_HW_EVENT_BROADCAST_ASYNCH_EVENT, PhyID %d PortID %d\n", phyId, portId));
/* report PhyId, NPIP, PortState */
phyId |= (npipps & PHY_IN_PORT_MASK) | ((npipps & PORT_STATE_MASK) << SHIFT16);
ossaHwCB(agRoot, agPortContext, OSSA_HW_EVENT_BROADCAST_ASYNCH_EVENT, phyId, agNULL, agNULL);
break;
}
case OSSA_HW_EVENT_IT_NEXUS_LOSS:
{
SA_DBG1(("mpiHWEvent: OSSA_HW_EVENT_IT_NEXUS_LOSS, PhyID %d PortID %d status 0x%X\n", phyId, portId,status));
break;
}
case OSSA_HW_EVENT_OPEN_RETRY_BACKOFF_THR_ADJUSTED:
{
SA_DBG1(("mpiHWEvent: OSSA_HW_EVENT_OPEN_RETRY_BACKOFF_THR_ADJUSTED, PhyID %d PortID %d status 0x%X\n", phyId, portId,status));
ossaHwCB(agRoot, agPortContext, OSSA_HW_EVENT_OPEN_RETRY_BACKOFF_THR_ADJUSTED, phyId, agNULL, agNULL);
break;
}
default:
{
SA_DBG1(("mpiHWEvent: Unknown HW Event 0x%x status 0x%X\n", Event ,status));
break;
}
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "2j");
return ret;
}
/******************************************************************************/
/*! \brief SPC MPI SMP Completion
*
* This function handles the SMP completion.
*
* \param agRoot Handles for this instance of SAS/SATA hardware
* \param pIomb pointer of Message1
* \param bc buffer count
*
* \return The read value
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiSMPCompletion(
agsaRoot_t *agRoot,
agsaSMPCompletionRsp_t *pIomb
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
bit32 status;
bit32 tag;
bit32 param;
agsaIORequestDesc_t *pRequest;
SA_DBG3(("mpiSMPCompletion: start, HTAG=0x%x\n", pIomb->tag));
smTraceFuncEnter(hpDBG_VERY_LOUD,"2k");
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaSMPCompletionRsp_t, tag)) ;
OSSA_READ_LE_32(AGROOT, &status, pIomb, OSSA_OFFSET_OF(agsaSMPCompletionRsp_t, status)) ;
OSSA_READ_LE_32(AGROOT, ¶m, pIomb, OSSA_OFFSET_OF(agsaSMPCompletionRsp_t, param)) ;
/* get SMP request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
if (agNULL == pRequest)
{
SA_DBG1(("mpiSMPCompletion: Bad Response IOMB!!! pRequest is NULL. TAG=0x%x STATUS=0x%x PARAM=0x%x\n", tag, status, param));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2k");
return AGSA_RC_FAILURE;
}
switch (status)
{
case OSSA_IO_SUCCESS:
SA_DBG3(("mpiSMPCompletion: OSSA_IO_SUCCESS HTAG = 0x%x\n", tag));
/* process message */
siSMPRespRcvd(agRoot, pIomb, param, tag);
break;
case OSSA_IO_OVERFLOW:
SA_DBG1(("mpiSMPCompletion: OSSA_IO_OVERFLOW HTAG = 0x%x\n", tag));
saRoot->IoErrorCount.agOSSA_IO_OVERFLOW++;
/* SMP failed */
siAbnormal(agRoot, pRequest, status, 0, 0);
break;
case OSSA_IO_ABORTED:
SA_DBG1(("mpiSMPCompletion: OSSA_IO_ABORTED HTAG = 0x%x\n", tag));
saRoot->IoErrorCount.agOSSA_IO_ABORTED++;
#ifdef SA_PRINTOUT_IN_WINDBG
#ifndef DBG
DbgPrint("agOSSA_IO_ABORTED %d\n", saRoot->IoErrorCount.agOSSA_IO_ABORTED);
#endif /* DBG */
#endif /* SA_PRINTOUT_IN_WINDBG */
/* SMP failed */
siAbnormal(agRoot, pRequest, status, 0, 0);
break;
case OSSA_IO_NO_DEVICE:
SA_DBG1(("mpiSMPCompletion: OSSA_IO_NO_DEVICE HTAG = 0x%x\n", tag));
saRoot->IoErrorCount.agOSSA_IO_NO_DEVICE++;
siAbnormal(agRoot, pRequest, status, 0, 0);
break;
case OSSA_IO_ERROR_HW_TIMEOUT:
SA_DBG1(("mpiSMPCompletion: OSSA_IO_ERROR_HW_TIMEOUT HTAG = 0x%x\n", tag));
saRoot->IoErrorCount.agOSSA_IO_ERROR_HW_TIMEOUT++;
siAbnormal(agRoot, pRequest, status, 0, 0);
break;
case OSSA_IO_XFER_ERROR_BREAK:
SA_DBG1(("mpiSMPCompletion: OSSA_IO_XFER_ERROR_BREAK HTAG = 0x%x\n", tag));
saRoot->IoErrorCount.agOSSA_IO_XFER_ERROR_BREAK++;
siAbnormal(agRoot, pRequest, status, 0, 0);
break;
case OSSA_IO_XFER_ERROR_PHY_NOT_READY:
SA_DBG1(("mpiSMPCompletion: OSSA_IO_XFER_ERROR_PHY_NOT_READY HTAG = 0x%x\n", tag));
saRoot->IoErrorCount.agOSSA_IO_XFER_ERROR_PHY_NOT_READY++;
siAbnormal(agRoot, pRequest, status, 0, 0);
break;
case OSSA_IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED:
SA_DBG1(("mpiSMPCompletion: OSSA_IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED HTAG = 0x%x\n", tag));
saRoot->IoErrorCount.agOSSA_IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED++;
siAbnormal(agRoot, pRequest, status, 0, 0);
break;
case OSSA_IO_OPEN_CNX_ERROR_ZONE_VIOLATION:
SA_DBG1(("mpiSMPCompletion: OSSA_IO_OPEN_CNX_ERROR_ZONE_VIOLATION HTAG = 0x%x\n", tag));
saRoot->IoErrorCount.agOSSA_IO_OPEN_CNX_ERROR_ZONE_VIOLATION++;
siAbnormal(agRoot, pRequest, status, 0, 0);
break;
case OSSA_IO_OPEN_CNX_ERROR_BREAK:
SA_DBG1(("mpiSMPCompletion: OSSA_IO_OPEN_CNX_ERROR_BREAK HTAG = 0x%x\n", tag));
saRoot->IoErrorCount.agOSSA_IO_OPEN_CNX_ERROR_BREAK++;
siAbnormal(agRoot, pRequest, status, 0, 0);
break;
case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS:
SA_DBG1(("mpiSMPCompletion: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS HTAG = 0x%x\n", tag));
saRoot->IoErrorCount.agOSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS++;
siAbnormal(agRoot, pRequest, status, 0, 0);
break;
case OSSA_IO_OPEN_CNX_ERROR_BAD_DESTINATION:
SA_DBG1(("mpiSMPCompletion: OSSA_IO_OPEN_CNX_ERROR_BAD_DESTINATION HTAG = 0x%x\n", tag));
saRoot->IoErrorCount.agOSSA_IO_OPEN_CNX_ERROR_BAD_DESTINATION++;
siAbnormal(agRoot, pRequest, status, 0, 0);
break;
case OSSA_IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED:
SA_DBG1(("mpiSMPCompletion: OSSA_IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED HTAG = 0x%x\n", tag));
saRoot->IoErrorCount.agOSSA_IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED++;
siAbnormal(agRoot, pRequest, status, 0, 0);
break;
case OSSA_IO_OPEN_CNX_ERROR_WRONG_DESTINATION:
SA_DBG1(("mpiSMPCompletion: OSSA_IO_OPEN_CNX_ERROR_WRONG_DESTINATION HTAG = 0x%x\n", tag));
saRoot->IoErrorCount.agOSSA_IO_OPEN_CNX_ERROR_WRONG_DESTINATION++;
siAbnormal(agRoot, pRequest, status, 0, 0);
break;
case OSSA_IO_XFER_ERROR_RX_FRAME:
SA_DBG1(("mpiSMPCompletion: OSSA_IO_XFER_ERROR_RX_FRAME HTAG = 0x%x\n", tag));
saRoot->IoErrorCount.agOSSA_IO_XFER_ERROR_RX_FRAME++;
siAbnormal(agRoot, pRequest, status, 0, 0);
break;
case OSSA_IO_XFER_OPEN_RETRY_TIMEOUT:
SA_DBG1(("mpiSMPCompletion: OSSA_IO_XFER_OPEN_RETRY_TIMEOUT HTAG = 0x%x\n", tag));
saRoot->IoErrorCount.agOSSA_IO_XFER_OPEN_RETRY_TIMEOUT++;
siAbnormal(agRoot, pRequest, status, 0, 0);
break;
case OSSA_IO_ERROR_INTERNAL_SMP_RESOURCE:
SA_DBG1(("mpiSMPCompletion: OSSA_IO_ERROR_INTERNAL_SMP_RESOURCE HTAG = 0x%x\n", tag));
saRoot->IoErrorCount.agOSSA_IO_ERROR_INTERNAL_SMP_RESOURCE++;
siAbnormal(agRoot, pRequest, status, 0, 0);
break;
case OSSA_IO_PORT_IN_RESET:
SA_DBG1(("mpiSMPCompletion: OSSA_IO_PORT_IN_RESET HTAG = 0x%x\n", tag));
saRoot->IoErrorCount.agOSSA_IO_PORT_IN_RESET++;
siAbnormal(agRoot, pRequest, status, 0, 0);
break;
case OSSA_IO_DS_NON_OPERATIONAL:
SA_DBG1(("mpiSMPCompletion: OSSA_IO_DS_NON_OPERATIONAL HTAG = 0x%x\n", tag));
saRoot->IoErrorCount.agOSSA_IO_DS_NON_OPERATIONAL++;
siAbnormal(agRoot, pRequest, status, 0, 0);
break;
case OSSA_IO_DS_IN_RECOVERY:
SA_DBG1(("mpiSMPCompletion: OSSA_IO_DS_IN_RECOVERY HTAG = 0x%x\n", tag));
saRoot->IoErrorCount.agOSSA_IO_DS_IN_RECOVERY++;
siAbnormal(agRoot, pRequest, status, 0, 0);
break;
case OSSA_IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY:
SA_DBG1(("mpiSMPCompletion: OSSA_IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY HTAG = 0x%x\n", tag));
saRoot->IoErrorCount.agOSSA_IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY++;
siAbnormal(agRoot, pRequest, status, 0, 0);
break;
case OSSA_IO_ABORT_IN_PROGRESS:
SA_DBG1(("mpiSMPCompletion: OSSA_IO_ABORT_IN_PROGRESS HTAG = 0x%x\n", tag));
saRoot->IoErrorCount.agOSSA_IO_ABORT_IN_PROGRESS++;
siAbnormal(agRoot, pRequest, status, 0, 0);
break;
case OSSA_IO_ABORT_DELAYED:
SA_DBG1(("mpiSMPCompletion:OSSA_IO_ABORT_DELAYED HTAG = 0x%x\n", tag));
saRoot->IoErrorCount.agOSSA_IO_ABORT_DELAYED++;
siAbnormal(agRoot, pRequest, status, 0, 0);
break;
case OSSA_IO_INVALID_LENGTH:
SA_DBG1(("mpiSMPCompletion: OSSA_IO_INVALID_LENGTH HTAG = 0x%x\n", tag));
saRoot->IoErrorCount.agOSSA_IO_INVALID_LENGTH++;
siAbnormal(agRoot, pRequest, status, 0, 0);
break;
case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED:
SA_DBG1(("mpiSMPCompletion: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED HTAG = 0x%x\n", tag));
saRoot->IoErrorCount.agOSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED++;
siAbnormal(agRoot, pRequest, status, 0, 0);
break;
case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_TMO:
SA_DBG1(("mpiSMPCompletion: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_TMO HTAG = 0x%x\n", tag));
saRoot->IoErrorCount.agOSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_TMO++;
siAbnormal(agRoot, pRequest, status, 0, 0);
break;
case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST:
SA_DBG1(("mpiSMPCompletion: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST HTAG = 0x%x\n", tag));
saRoot->IoErrorCount.agOSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST++;
siAbnormal(agRoot, pRequest, status, 0, 0);
break;
case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE:
SA_DBG1(("mpiSMPCompletion: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE HTAG = 0x%x\n", tag));
saRoot->IoErrorCount.agOSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST++;
siAbnormal(agRoot, pRequest, status, 0, 0);
break;
case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED:
SA_DBG1(("mpiSMPCompletion: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED HTAG = 0x%x\n", tag));
saRoot->IoErrorCount.agOSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED++;
siAbnormal(agRoot, pRequest, status, 0, 0);
break;
case OSSA_IO_DS_INVALID:
SA_DBG1(("mpiSMPCompletion: OSSA_IO_DS_INVALID HTAG = 0x%x\n", tag));
saRoot->IoErrorCount.agOSSA_IO_DS_INVALID++;
siAbnormal(agRoot, pRequest, status, 0, 0);
break;
case OSSA_IO_XFER_READ_COMPL_ERR:
SA_DBG1(("mpiSMPCompletion: OSSA_IO_XFER_READ_COMPL_ERR HTAG = 0x%x\n", tag));
saRoot->IoErrorCount.agOSSA_IO_XFER_READ_COMPL_ERR++;
siAbnormal(agRoot, pRequest, status, 0, 0);
break;
case OSSA_MPI_ERR_IO_RESOURCE_UNAVAILABLE:
SA_DBG1(("mpiSMPCompletion: OSSA_MPI_ERR_IO_RESOURCE_UNAVAILABLE HTAG = 0x%x\n", tag));
saRoot->IoErrorCount.agOSSA_MPI_ERR_IO_RESOURCE_UNAVAILABLE++;
siAbnormal(agRoot, pRequest, status, 0, 0);
break;
case OSSA_MPI_ERR_OFFLOAD_DIF_OR_ENC_NOT_ENABLED:
SA_DBG1(("mpiSMPCompletion: OSSA_MPI_ERR_IO_RESOURCE_UNAVAILABLE HTAG = 0x%x\n", tag));
saRoot->IoErrorCount.agOSSA_MPI_ERR_OFFLOAD_DIF_OR_ENC_NOT_ENABLED++;
siAbnormal(agRoot, pRequest, status, 0, 0);
break;
case OSSA_IO_OPEN_CNX_ERROR_OPEN_PREEMPTED:
SA_DBG1(("mpiSMPCompletion: OSSA_IO_OPEN_CNX_ERROR_OPEN_PREEMPTED HTAG = 0x%x\n", tag));
saRoot->IoErrorCount.agOSSA_IO_OPEN_CNX_ERROR_OPEN_PREEMPTED++;
siAbnormal(agRoot, pRequest, status, 0, 0);
break;
default:
SA_DBG1(("mpiSMPCompletion: Unknown Status = 0x%x Tag 0x%x\n", status, tag));
saRoot->IoErrorCount.agOSSA_IO_UNKNOWN_ERROR++;
/* not allowed case. Therefore, assert */
SA_ASSERT((agFALSE), "mpiSMPCompletion: Unknown Status");
break;
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "2k");
return ret;
}
/******************************************************************************/
/*! \brief SPC MPI Get Device Handle Command Response
*
* This function handles the response of Get Device Handle Command.
*
* \param agRoot Handles for this instance of SAS/SATA hardware
* \param pIomb pointer of Message
* \param bc buffer count
*
* \return The read value
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiGetDevHandleRsp(
agsaRoot_t *agRoot,
agsaGetDevHandleRsp_t *pIomb
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
agsaPortContext_t *agPortContext;
agsaContext_t *agContext;
agsaDeviceDesc_t *pDevice;
bit8 portId;
bit32 deviceid=0, deviceIdc, i;
bit32 DeviceIdcPortId, tag;
SA_DBG3(("mpiGetDevHandleRsp: start, HTAG=0x%x\n", pIomb->tag));
smTraceFuncEnter(hpDBG_VERY_LOUD,"2m");
OSSA_READ_LE_32(AGROOT, &DeviceIdcPortId, pIomb, OSSA_OFFSET_OF(agsaGetDevHandleRsp_t, DeviceIdcPortId)) ;
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaGetDevHandleRsp_t, tag)) ;
/* get request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
agContext = saRoot->IOMap[tag].agContext;
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
if (agNULL == pRequest)
{
SA_DBG1(("mpiGetDevHandleRsp: Bad Response IOMB!!! pRequest is NULL. TAG=0x%x DeviceIdcPortId=0x%x\n", tag, DeviceIdcPortId));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2m");
return AGSA_RC_FAILURE;
}
/* get port context */
portId = (bit8)(DeviceIdcPortId & PORTID_MASK);
SA_DBG2(("mpiGetDevHandleRsp:PortID 0x%x PortStatus 0x%x PortContext %p\n",saRoot->PortMap[portId & PORTID_MASK].PortID,saRoot->PortMap[portId & PORTID_MASK].PortStatus,saRoot->PortMap[portId & PORTID_MASK].PortContext));
agPortContext = (agsaPortContext_t *)saRoot->PortMap[portId].PortContext;
/* get Device ID count */
deviceIdc = (bit8)((DeviceIdcPortId & DEVICE_IDC_BITS) >> SHIFT8);
/* based on the deviceIDC to get all device handles */
for (i = 0; i < deviceIdc; i++)
{
OSSA_READ_LE_32(AGROOT, &deviceid, pIomb, OSSA_OFFSET_OF(agsaGetDevHandleRsp_t, deviceId[i])) ;
/* find device handle from device index */
pDevice = (agsaDeviceDesc_t *)saRoot->DeviceMap[deviceid & DEVICE_ID_BITS].DeviceHandle;
if (pDevice->targetDevHandle.sdkData)
saRoot->DeviceHandle[i] = &(pDevice->targetDevHandle);
else
saRoot->DeviceHandle[i] = &(pDevice->initiatorDevHandle);
}
SA_DBG1(("mpiGetDevHandleRsp:deviceid 0x%x 0x%x\n",deviceid, (deviceid & DEVICE_ID_BITS)));
/* call back oslayer */
ossaGetDeviceHandlesCB(agRoot, agContext, agPortContext, saRoot->DeviceHandle, deviceIdc);
/* return the request to free pool */
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_ASSERT((pRequest->valid), "pRequest->valid");
pRequest->valid = agFALSE;
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiGetDevHandleRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "2m");
return ret;
}
/******************************************************************************/
/*! \brief SPC MPI Phy Control Command Response
*
* This function handles the response of PHY Control Command.
*
* \param agRoot Handles for this instance of SAS/SATA hardware
* \param pIomb pointer of Message
*
* \return The read value
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiPhyCntrlRsp(
agsaRoot_t *agRoot,
agsaLocalPhyCntrlRsp_t *pIomb
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
agsaContext_t *agContext = agNULL;
bit32 phyId, operation, status, tag, phyOpId;
smTraceFuncEnter(hpDBG_VERY_LOUD,"2n");
SA_DBG3(("mpiPhyCntrlRsp: start, HTAG=0x%x,\n", pIomb->tag));
/* get tag */
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaLocalPhyCntrlRsp_t, tag)) ;
OSSA_READ_LE_32(AGROOT, &phyOpId, pIomb, OSSA_OFFSET_OF(agsaLocalPhyCntrlRsp_t, phyOpId)) ;
OSSA_READ_LE_32(AGROOT, &status, pIomb, OSSA_OFFSET_OF(agsaLocalPhyCntrlRsp_t, status)) ;
/* get request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
if (agNULL == pRequest)
{
SA_DBG1(("mpiPhyCntrlRsp: Bad Response IOMB!!! pRequest is NULL. TAG=0x%x STATUS=0x%x PhyOpId=0x%x\n", tag, status, phyOpId));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2n");
return AGSA_RC_FAILURE;
}
agContext = saRoot->IOMap[tag].agContext;
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
phyId = phyOpId & LOCAL_PHY_PHYID;
operation = (phyOpId & LOCAL_PHY_OP_BITS) >> SHIFT8;
SA_DBG3(("mpiPhyCntrlRsp: phyId=0x%x Operation=0x%x Status=0x%x\n", phyId, operation, status));
if( pRequest->completionCB == agNULL )
{
/* call back with the status */
ossaLocalPhyControlCB(agRoot, agContext, phyId, operation, status, agNULL);
}
else
{
(*(ossaLocalPhyControlCB_t)(pRequest->completionCB))(agRoot, agContext, phyId, operation, status, agNULL );
}
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_ASSERT((pRequest->valid), "pRequest->valid");
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiPhyCntrlRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "2n");
return ret;
}
/******************************************************************************/
/*! \brief SPC MPI Device Register Command Response
*
* This function handles the response of Device Register Command.
*
* \param agRoot Handles for this instance of SAS/SATA hardware
* \param pIomb pointer of Message
*
* \return The read value
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiDeviceRegRsp(
agsaRoot_t *agRoot,
agsaDeviceRegistrationRsp_t *pIomb
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = agNULL;
agsaIORequestDesc_t *pRequest;
agsaContext_t *agContext;
bit32 deviceId;
agsaDeviceDesc_t *pDevice = agNULL;
agsaDeviceDesc_t *pDeviceRemove = agNULL;
bit32 deviceIdx,status, tag;
smTraceFuncEnter(hpDBG_VERY_LOUD,"2p");
/* sanity check */
SA_ASSERT((agNULL != agRoot), "");
saRoot = (agsaLLRoot_t *) (agRoot->sdkData);
SA_ASSERT((agNULL != saRoot), "");
SA_DBG3(("mpiDeviceRegRsp: start, HTAG=0x%x\n", pIomb->tag));
SA_ASSERT((NULL != saRoot->DeviceRegistrationCB), "DeviceRegistrationCB can not be NULL");
OSSA_READ_LE_32(AGROOT, &deviceId, pIomb, OSSA_OFFSET_OF(agsaDeviceRegistrationRsp_t, deviceId)) ;
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaDeviceRegistrationRsp_t, tag)) ;
OSSA_READ_LE_32(AGROOT, &status, pIomb, OSSA_OFFSET_OF(agsaDeviceRegistrationRsp_t, status)) ;
SA_DBG1(("mpiDeviceRegRsp: deviceID 0x%x \n", deviceId));
/* get request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
if (agNULL == pRequest)
{
SA_DBG1(("mpiDeviceRegRsp: Bad IOMB!!! pRequest is NULL. TAG=0x%x, STATUS=0x%x DEVICEID=0x%x\n", tag, status, deviceId));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2p");
return AGSA_RC_FAILURE;
}
pDevice = pRequest->pDevice;
agContext = saRoot->IOMap[tag].agContext;
SA_ASSERT((pRequest->valid), "pRequest->valid");
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
/* get Device Id or status */
SA_DBG3(("mpiDeviceRegRsp: hosttag 0x%x\n", tag));
SA_DBG3(("mpiDeviceRegRsp: deviceID 0x%x Device Context %p\n", deviceId, pDevice));
if (agNULL == pDevice)
{
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiDeviceRegRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_DBG1(("mpiDeviceRegRsp: warning!!! no device is found\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "2p");
return AGSA_RC_FAILURE;
}
if (agNULL == saRoot->DeviceRegistrationCB)
{
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiDeviceRegRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_DBG1(("mpiDeviceRegRsp: warning!!! no DeviceRegistrationCB is found\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "2p");
return AGSA_RC_FAILURE;
}
if(smIS_SPCV(agRoot))
{
switch( status)
{
case 0:
status = OSSA_SUCCESS;
break;
case MPI_ERR_DEVICE_HANDLE_UNAVAILABLE:
status = OSSA_FAILURE_OUT_OF_RESOURCE;
break;
case MPI_ERR_DEVICE_ALREADY_REGISTERED:
status = OSSA_FAILURE_DEVICE_ALREADY_REGISTERED;
break;
case MPI_ERR_PHY_ID_INVALID:
status = OSSA_FAILURE_INVALID_PHY_ID;
break;
case MPI_ERR_PHY_ID_ALREADY_REGISTERED:
status = OSSA_FAILURE_PHY_ID_ALREADY_REGISTERED;
break;
case MPI_ERR_PORT_INVALID_PORT_ID:
status = OSSA_FAILURE_PORT_ID_OUT_OF_RANGE;
break;
case MPI_ERR_PORT_STATE_NOT_VALID:
status = OSSA_FAILURE_PORT_NOT_VALID_STATE;
break;
case MPI_ERR_DEVICE_TYPE_NOT_VALID:
status = OSSA_FAILURE_DEVICE_TYPE_NOT_VALID;
break;
default:
SA_ASSERT((0), "DeviceRegistration Unknown status");
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiDeviceRegRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
return AGSA_RC_FAILURE;
}
}
switch (status)
{
case OSSA_SUCCESS:
/* mapping the device handle and device id */
deviceIdx = deviceId & DEVICE_ID_BITS;
OS_ASSERT(deviceIdx < MAX_IO_DEVICE_ENTRIES, "deviceIdx MAX_IO_DEVICE_ENTRIES");
saRoot->DeviceMap[deviceIdx].DeviceIdFromFW = deviceId;
saRoot->DeviceMap[deviceIdx].DeviceHandle = (void *)pDevice;
pDevice->DeviceMapIndex = deviceId;
(*(ossaDeviceRegistrationCB_t)(saRoot->DeviceRegistrationCB))(agRoot,
agContext,
OSSA_SUCCESS,
&pDevice->targetDevHandle,
deviceId
);
break;
case OSSA_FAILURE_OUT_OF_RESOURCE:
SA_DBG1(("mpiDeviceRegRsp: OSSA_FAILURE_OUT_OF_RESOURCE\n"));
/* remove device from LL device list */
siPortDeviceRemove(agRoot, pDevice->pPort, pDevice, agFALSE);
/* call ossaDeviceRegistrationCB_t */
(*(ossaDeviceRegistrationCB_t)(saRoot->DeviceRegistrationCB))(agRoot,
agContext,
OSSA_FAILURE_OUT_OF_RESOURCE,
&pDevice->targetDevHandle,
deviceId
);
break;
case OSSA_FAILURE_DEVICE_ALREADY_REGISTERED:
/* get original device handle and device id */
pDeviceRemove = pDevice;
deviceIdx = deviceId & DEVICE_ID_BITS;
OS_ASSERT(deviceIdx < MAX_IO_DEVICE_ENTRIES, "deviceIdx MAX_IO_DEVICE_ENTRIES");
pDevice = (agsaDeviceDesc_t *)saRoot->DeviceMap[deviceIdx].DeviceHandle;
SA_DBG1(("mpiDeviceRegRsp: OSSA_FAILURE_DEVICE_ALREADY_REGISTERED, existing deviceContext %p\n", pDevice));
/* no auto registration */
if (pDevice != agNULL)
{
/* remove device from LL device list */
siPortDeviceListRemove(agRoot, pDevice->pPort, pDeviceRemove);
/* call ossaDeviceRegistrationCB_t */
(*(ossaDeviceRegistrationCB_t)(saRoot->DeviceRegistrationCB))(agRoot,
agContext,
OSSA_FAILURE_DEVICE_ALREADY_REGISTERED,
&pDevice->targetDevHandle,
deviceId
);
}
else
{
SA_DBG1(("mpiDeviceRegRsp: pDevice is NULL. TAG=0x%x, STATUS=0x%x DEVICEID=0x%x\n", tag, status, deviceId));
smTraceFuncExit(hpDBG_VERY_LOUD, 'd', "2p");
return AGSA_RC_FAILURE;
}
break;
case OSSA_FAILURE_INVALID_PHY_ID:
SA_DBG1(("mpiDeviceRegRsp: OSSA_FAILURE_INVALID_PHY_ID\n"));
/* remove device from LL device list */
siPortDeviceRemove(agRoot, pDevice->pPort, pDevice, agFALSE);
/* call ossaDeviceRegistrationCB_t */
(*(ossaDeviceRegistrationCB_t)(saRoot->DeviceRegistrationCB))(agRoot,
agContext,
OSSA_FAILURE_INVALID_PHY_ID,
&pDevice->targetDevHandle,
deviceId
);
break;
case OSSA_FAILURE_PHY_ID_ALREADY_REGISTERED:
/* get original device handle and device id */
pDeviceRemove = pDevice;
deviceIdx = deviceId & DEVICE_ID_BITS;
OS_ASSERT(deviceIdx < MAX_IO_DEVICE_ENTRIES, "deviceIdx MAX_IO_DEVICE_ENTRIES");
pDevice = (agsaDeviceDesc_t *)saRoot->DeviceMap[deviceIdx].DeviceHandle;
SA_DBG1(("mpiDeviceRegRsp: OSSA_FAILURE_PHY_ID_ALREADY_REGISTERED, existing deviceContext %p\n", pDevice));
/* no auto registration */
if (pDevice != agNULL)
{
/* remove device from LL device list */
siPortDeviceListRemove(agRoot, pDevice->pPort, pDeviceRemove);
/* call ossaDeviceRegistrationCB_t */
(*(ossaDeviceRegistrationCB_t)(saRoot->DeviceRegistrationCB))(agRoot,
agContext,
OSSA_FAILURE_PHY_ID_ALREADY_REGISTERED,
&pDevice->targetDevHandle,
deviceId
);
}
else
{
SA_DBG1(("mpiDeviceRegRsp: pDevice is NULL. TAG=0x%x, STATUS=0x%x DEVICEID=0x%x\n", tag, status, deviceId));
smTraceFuncExit(hpDBG_VERY_LOUD, 'e', "2p");
return AGSA_RC_FAILURE;
}
break;
case OSSA_FAILURE_PORT_ID_OUT_OF_RANGE:
SA_DBG1(("mpiDeviceRegRsp: OSSA_FAILURE_OUT_OF_RESOURCE\n"));
/* remove device from LL device list */
siPortDeviceRemove(agRoot, pDevice->pPort, pDevice, agFALSE);
/* call ossaDeviceRegistrationCB_t */
(*(ossaDeviceRegistrationCB_t)(saRoot->DeviceRegistrationCB))(agRoot,
agContext,
OSSA_FAILURE_PORT_ID_OUT_OF_RANGE,
&pDevice->targetDevHandle,
deviceId
);
break;
case OSSA_FAILURE_PORT_NOT_VALID_STATE:
SA_DBG1(("mpiDeviceRegRsp: OSSA_FAILURE_PORT_NOT_VALID_STATE\n"));
/* remove device from LL device list */
siPortDeviceRemove(agRoot, pDevice->pPort, pDevice, agFALSE);
/* call ossaDeviceRegistrationCB_t */
(*(ossaDeviceRegistrationCB_t)(saRoot->DeviceRegistrationCB))(agRoot,
agContext,
OSSA_FAILURE_PORT_NOT_VALID_STATE,
&pDevice->targetDevHandle,
deviceId
);
break;
case OSSA_FAILURE_DEVICE_TYPE_NOT_VALID:
SA_DBG1(("mpiDeviceRegRsp: OSSA_FAILURE_DEVICE_TYPE_NOT_VALID\n"));
/* remove device from LL device list */
siPortDeviceRemove(agRoot, pDevice->pPort, pDevice, agFALSE);
/* call ossaDeviceRegistrationCB_t */
(*(ossaDeviceRegistrationCB_t)(saRoot->DeviceRegistrationCB))(agRoot,
agContext,
OSSA_FAILURE_DEVICE_TYPE_NOT_VALID,
&pDevice->targetDevHandle,
deviceId
);
break;
default:
SA_DBG3(("mpiDeviceRegRsp, unknown status in response %d\n", status));
break;
}
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiDeviceRegRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
smTraceFuncExit(hpDBG_VERY_LOUD, 'f', "2p");
return ret;
}
/******************************************************************************/
/*! \brief SPC MPI Deregister Device Command Response
*
* This function handles the response of Deregister Command.
*
* \param agRoot Handles for this instance of SAS/SATA hardware
* \param pIomb pointer of Message
*
* \return The read value
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiDeregDevHandleRsp(
agsaRoot_t *agRoot,
agsaDeregDevHandleRsp_t *pIomb
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
agsaDevHandle_t *agDevHandle;
agsaContext_t *agContext;
agsaDeviceDesc_t *pDevice;
bit32 deviceIdx, status, tag;
smTraceFuncEnter(hpDBG_VERY_LOUD,"2r");
SA_ASSERT((NULL != saRoot->DeviceDeregistrationCB), "DeviceDeregistrationCB can not be NULL");
SA_DBG3(("mpiDeregDevHandleRsp: start, HTAG=0x%x\n", pIomb->tag));
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaDeregDevHandleRsp_t, tag)) ;
OSSA_READ_LE_32(AGROOT, &status, pIomb, OSSA_OFFSET_OF(agsaDeregDevHandleRsp_t, status)) ;
OSSA_READ_LE_32(AGROOT, &deviceIdx, pIomb, OSSA_OFFSET_OF(agsaDeregDevHandleRsp_t, deviceId)) ;
/* get request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
if (agNULL == pRequest)
{
SA_DBG1(("mpiDeregDevHandleRsp: Bad Response IOMB!!! pRequest is NULL. TAG=0x%x STATUS=0x%x deviceIdx 0x%x\n", tag, status,deviceIdx));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2r");
return AGSA_RC_FAILURE;
}
agContext = saRoot->IOMap[tag].agContext;
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
SA_ASSERT((pRequest->valid), "pRequest->valid");
pDevice = pRequest->pDevice;
if (pDevice != agNULL)
{
if (pDevice->targetDevHandle.sdkData)
{
agDevHandle = &(pDevice->targetDevHandle);
}
else
{
agDevHandle = &(pDevice->initiatorDevHandle);
}
}
else
{
SA_DBG1(("mpiDeregDevHandleRsp: pDevice is NULL"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "2r");
return AGSA_RC_FAILURE;
}
if (agNULL == agDevHandle)
{
SA_DBG1(("mpiDeregDevHandleRsp: warning!!! no deviceHandle is found"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "2r");
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiDeregDevHandleRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
return AGSA_RC_FAILURE;
}
SA_DBG1(("mpiDeregDevHandleRsp: deviceID 0x%x Device Context %p\n", pDevice->DeviceMapIndex, pDevice));
if (agNULL == saRoot->DeviceDeregistrationCB)
{
SA_DBG1(("mpiDeregDevHandleRsp: warning!!! no DeviceDeregistrationCB is found"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'd', "2r");
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiDeregDevHandleRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
return AGSA_RC_FAILURE;
}
switch (status)
{
case OSSA_SUCCESS:
(*(ossaDeregisterDeviceHandleCB_t)(saRoot->DeviceDeregistrationCB))(agRoot,
agContext,
agDevHandle,
OSSA_SUCCESS
);
siRemoveDevHandle(agRoot, agDevHandle);
break;
case OSSA_ERR_DEVICE_HANDLE_INVALID:
case OSSA_INVALID_HANDLE:
(*(ossaDeregisterDeviceHandleCB_t)(saRoot->DeviceDeregistrationCB))(agRoot,
agContext,
agDevHandle,
status
);
// already removed and no device to remove
// siRemoveDevHandle(agRoot, agDevHandle);
SA_DBG1(("mpiDeregDevRegRsp, OSSA_INVALID_HANDLE status in response %d\n", status));
break;
case OSSA_ERR_DEVICE_BUSY:
(*(ossaDeregisterDeviceHandleCB_t)(saRoot->DeviceDeregistrationCB))(agRoot,
agContext,
agDevHandle,
status
);
SA_DBG1(("mpiDeregDevRegRsp, OSSA_ERR_DEVICE_BUSY status in response %d\n", status));
ret = AGSA_RC_BUSY;
break;
default:
SA_DBG1(("mpiDeregDevRegRsp, unknown status in response 0x%X\n", status));
break;
}
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiDeregDevHandleRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
smTraceFuncExit(hpDBG_VERY_LOUD, 'e', "2r");
return ret;
}
/******************************************************************************/
/*! \brief Get Phy Profile Response SPCv
*
* This routine handles the response of Get Phy Profile Command Response
*
* \param agRoot Handles for this instance of SAS/SATA LLL
* \param pIomb Pointer of IOMB Message
*
* \return sucess or fail
* SPC only
*/
/*******************************************************************************/
GLOBAL bit32 mpiGetPhyProfileRsp(
agsaRoot_t *agRoot,
agsaGetPhyProfileRspV_t *pIomb
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
agsaContext_t *agContext;
bit32 status, tag;
bit32 Reserved_SOP_PHYID;
bit32 PhyId;
bit32 SOP;
smTraceFuncEnter(hpDBG_VERY_LOUD,"2J");
OSSA_READ_LE_32(agRoot, &status, pIomb, OSSA_OFFSET_OF(agsaGetPhyProfileRspV_t, status));
OSSA_READ_LE_32(agRoot, &tag, pIomb, OSSA_OFFSET_OF(agsaGetPhyProfileRspV_t, tag));
/* get TAG */
SA_DBG1(("mpiGetPhyProfileRsp: HTag=0x%x\n", tag));
/* get request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
if (agNULL == pRequest)
{
SA_DBG1(("mpiGetPhyProfileRsp: Bad Response IOMB!!! pRequest is NULL. TAG=0x%x STATUS=0x%x\n", tag, status));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2J");
return AGSA_RC_FAILURE;
}
agContext = saRoot->IOMap[tag].agContext;
OSSA_READ_LE_32(agRoot, &Reserved_SOP_PHYID, pIomb, OSSA_OFFSET_OF(agsaGetPhyProfileRspV_t,Reserved_Ppc_SOP_PHYID ));
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
SA_ASSERT((pRequest->valid), "pRequest->valid");
SA_DBG1(("mpiGetPhyProfileRsp: %p\n",pIomb));
SA_DBG1(("mpiGetPhyProfileRsp: completionCB %p\n",pRequest->completionCB ));
SOP = (Reserved_SOP_PHYID & 0xFF00) >> SHIFT8;
PhyId = Reserved_SOP_PHYID & 0xFF;
/* check status success or failure */
if (status)
{
/* status is FAILED */
SA_DBG1(("mpiGetPhyProfileRsp:AGSA_RC_FAILURE 0x%08X\n", status));
switch(SOP)
{
case AGSA_SAS_PHY_ERR_COUNTERS_PAGE:
{
SA_DBG1(("mpiGetPhyProfileRsp: AGSA_SAS_PHY_ERR_COUNTERS_PAGE SOP 0x%x\n", SOP));
ossaGetPhyProfileCB(agRoot, agContext, status, SOP, PhyId , agNULL );
break;
}
case AGSA_SAS_PHY_ERR_COUNTERS_CLR_PAGE:
{
SA_DBG1(("mpiGetPhyProfileRsp: AGSA_SAS_PHY_ERR_COUNTERS_CLR_PAGE SOP 0x%x\n", SOP));
ossaGetPhyProfileCB(agRoot, agContext, status, SOP, PhyId , agNULL );
break;
}
case AGSA_SAS_PHY_BW_COUNTERS_PAGE:
{
SA_DBG1(("mpiGetPhyProfileRsp: GET_SAS_PHY_BW_COUNTERS SOP 0x%x\n", SOP));
ossaGetPhyProfileCB(agRoot, agContext, status, SOP, PhyId , agNULL );
break;
}
case AGSA_SAS_PHY_ANALOG_SETTINGS_PAGE:
{
SA_DBG1(("mpiGetPhyProfileRsp: AGSA_SAS_PHY_ANALOG_SETTINGS_PAGE SOP 0x%x\n", SOP));
ossaGetPhyProfileCB(agRoot, agContext, status, SOP, PhyId , agNULL );
break;
}
case AGSA_SAS_PHY_GENERAL_STATUS_PAGE:
{
SA_DBG1(("mpiGetPhyProfileRsp: AGSA_SAS_PHY_GENERAL_STATUS_PAGE SOP 0x%x\n", SOP));
ossaGetPhyProfileCB(agRoot, agContext, status, SOP, PhyId , agNULL );
break;
}
case AGSA_PHY_SNW3_PAGE:
{
SA_DBG1(("mpiGetPhyProfileRsp: AGSA_PHY_SNW3_PAGE SOP 0x%x\n", SOP));
ossaGetPhyProfileCB(agRoot, agContext, status, SOP, PhyId , agNULL );
break;
}
case AGSA_PHY_RATE_CONTROL_PAGE:
{
SA_DBG1(("mpiGetPhyProfileRsp: AGSA_PHY_RATE_CONTROL_PAGE SOP 0x%x\n", SOP));
ossaGetPhyProfileCB(agRoot, agContext, status, SOP, PhyId , agNULL );
break;
}
case AGSA_SAS_PHY_OPEN_REJECT_RETRY_BACKOFF_THRESHOLD_PAGE:
{
SA_DBG1(("mpiGetPhyProfileRsp: AGSA_SAS_PHY_OPEN_REJECT_RETRY_BACKOFF_THRESHOLD_PAGE SOP 0x%x\n", SOP));
ossaGetPhyProfileCB(agRoot, agContext, status, SOP, PhyId , agNULL );
break;
}
default:
{
SA_DBG1(("mpiGetPhyProfileRsp: undefined SOP 0x%x\n", SOP));
break;
}
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "2J");
return AGSA_RC_FAILURE;
}
else
{
SA_DBG1(("mpiGetPhyProfileRsp: SUCCESS type 0x%X\n",SOP ));
switch(SOP)
{
case AGSA_SAS_PHY_ERR_COUNTERS_CLR_PAGE:
/* call back with the status */
SA_DBG1(("mpiGetPhyProfileRsp: AGSA_SAS_PHY_ERR_COUNTERS_CLR_PAGE PhyId %d\n",PhyId));
ossaGetPhyProfileCB(agRoot, agContext, status, SOP, PhyId , agNULL);
break;
case AGSA_SAS_PHY_ERR_COUNTERS_PAGE:
{
agsaPhyErrCountersPage_t Errors;
OSSA_READ_LE_32(agRoot, &Errors.invalidDword, pIomb, OSSA_OFFSET_OF(agsaGetPhyProfileRspV_t,PageSpecificArea[0] ));
OSSA_READ_LE_32(agRoot, &Errors.runningDisparityError, pIomb, OSSA_OFFSET_OF(agsaGetPhyProfileRspV_t,PageSpecificArea[1] ));
OSSA_READ_LE_32(agRoot, &Errors.codeViolation, pIomb, OSSA_OFFSET_OF(agsaGetPhyProfileRspV_t,PageSpecificArea[2] ));
OSSA_READ_LE_32(agRoot, &Errors.lossOfDwordSynch, pIomb, OSSA_OFFSET_OF(agsaGetPhyProfileRspV_t,PageSpecificArea[3] ));
OSSA_READ_LE_32(agRoot, &Errors.phyResetProblem, pIomb, OSSA_OFFSET_OF(agsaGetPhyProfileRspV_t,PageSpecificArea[4] ));
OSSA_READ_LE_32(agRoot, &Errors.inboundCRCError, pIomb, OSSA_OFFSET_OF(agsaGetPhyProfileRspV_t,PageSpecificArea[5] ));
/* call back with the status */
ossaGetPhyProfileCB(agRoot, agContext, status, SOP, PhyId , &Errors);
/* status is SUCCESS */
SA_DBG3(("mpiGetPhyProfileRsp: pIomb %p\n",pIomb));
SA_DBG1(("mpiGetPhyProfileRsp: Reserved_SOP_PHYID 0x%08X\n",Reserved_SOP_PHYID));
SA_DBG1(("mpiGetPhyProfileRsp: invalidDword 0x%08X\n",Errors.invalidDword ));
SA_DBG1(("mpiGetPhyProfileRsp: runningDisparityError 0x%08X\n",Errors.runningDisparityError ));
SA_DBG1(("mpiGetPhyProfileRsp: codeViolation 0x%08X\n",Errors.codeViolation ));
SA_DBG1(("mpiGetPhyProfileRsp: lossOfDwordSynch 0x%08X\n",Errors.lossOfDwordSynch ));
SA_DBG1(("mpiGetPhyProfileRsp: phyResetProblem 0x%08X\n",Errors.phyResetProblem ));
SA_DBG1(("mpiGetPhyProfileRsp: inboundCRCError 0x%08X\n",Errors.inboundCRCError ));
break;
}
case AGSA_SAS_PHY_BW_COUNTERS_PAGE:
{
agsaPhyBWCountersPage_t bw_counts;
OSSA_READ_LE_32(agRoot, &bw_counts.TXBWCounter, pIomb, OSSA_OFFSET_OF(agsaGetPhyProfileRspV_t,PageSpecificArea[0] ));
OSSA_READ_LE_32(agRoot, &bw_counts.RXBWCounter, pIomb, OSSA_OFFSET_OF(agsaGetPhyProfileRspV_t,PageSpecificArea[1] ));
SA_DBG1(("mpiGetPhyProfileRsp: GET_SAS_PHY_BW_COUNTERS TX 0x%08X RX 0x%08X\n",bw_counts.TXBWCounter,bw_counts.RXBWCounter));
/* call back with the status */
ossaGetPhyProfileCB(agRoot, agContext, status, SOP, PhyId, &bw_counts);
break;
}
case AGSA_SAS_PHY_ANALOG_SETTINGS_PAGE:
{
agsaPhyAnalogSettingsPage_t analog;
SA_DBG1(("mpiGetPhyProfileRsp: AGSA_SAS_PHY_ANALOG_SETTINGS_PAGE 0x%X\n",SOP));
OSSA_READ_LE_32(agRoot, &analog.Dword0, pIomb, OSSA_OFFSET_OF(agsaGetPhyProfileRspV_t,PageSpecificArea[0] ));
OSSA_READ_LE_32(agRoot, &analog.Dword1, pIomb, OSSA_OFFSET_OF(agsaGetPhyProfileRspV_t,PageSpecificArea[1] ));
OSSA_READ_LE_32(agRoot, &analog.Dword2, pIomb, OSSA_OFFSET_OF(agsaGetPhyProfileRspV_t,PageSpecificArea[2] ));
OSSA_READ_LE_32(agRoot, &analog.Dword3, pIomb, OSSA_OFFSET_OF(agsaGetPhyProfileRspV_t,PageSpecificArea[3] ));
OSSA_READ_LE_32(agRoot, &analog.Dword4, pIomb, OSSA_OFFSET_OF(agsaGetPhyProfileRspV_t,PageSpecificArea[4] ));
/* call back with the status */
ossaGetPhyProfileCB(agRoot, agContext, status, SOP, PhyId, &analog);
break;
}
case AGSA_SAS_PHY_GENERAL_STATUS_PAGE:
{
agsaSASPhyGeneralStatusPage_t GenStatus;
OSSA_READ_LE_32(agRoot, &GenStatus.Dword0, pIomb, OSSA_OFFSET_OF(agsaGetPhyProfileRspV_t,PageSpecificArea[0] ));
OSSA_READ_LE_32(agRoot, &GenStatus.Dword1, pIomb, OSSA_OFFSET_OF(agsaGetPhyProfileRspV_t,PageSpecificArea[1] ));
SA_DBG1(("mpiGetPhyProfileRsp: AGSA_SAS_PHY_GENERAL_STATUS_PAGE SOP 0x%x 0x%x 0x%x\n", SOP,GenStatus.Dword0,GenStatus.Dword1));
ossaGetPhyProfileCB(agRoot, agContext, status, SOP, PhyId , &GenStatus );
break;
}
case AGSA_PHY_SNW3_PAGE:
{
agsaPhySNW3Page_t Snw3;
OSSA_READ_LE_32(agRoot, &Snw3.LSNW3, pIomb, OSSA_OFFSET_OF(agsaGetPhyProfileRspV_t,PageSpecificArea[0] ));
OSSA_READ_LE_32(agRoot, &Snw3.RSNW3, pIomb, OSSA_OFFSET_OF(agsaGetPhyProfileRspV_t,PageSpecificArea[1] ));
SA_DBG1(("mpiGetPhyProfileRsp: AGSA_PHY_SNW3_PAGE SOP 0x%x\n", SOP));
ossaGetPhyProfileCB(agRoot, agContext, status, SOP, PhyId , &Snw3 );
break;
}
case AGSA_PHY_RATE_CONTROL_PAGE:
{
agsaPhyRateControlPage_t RateControl;
OSSA_READ_LE_32(agRoot, &RateControl.Dword0, pIomb, OSSA_OFFSET_OF(agsaGetPhyProfileRspV_t,PageSpecificArea[0] ));
OSSA_READ_LE_32(agRoot, &RateControl.Dword1, pIomb, OSSA_OFFSET_OF(agsaGetPhyProfileRspV_t,PageSpecificArea[1] ));
OSSA_READ_LE_32(agRoot, &RateControl.Dword2, pIomb, OSSA_OFFSET_OF(agsaGetPhyProfileRspV_t,PageSpecificArea[2] ));
SA_DBG1(("mpiGetPhyProfileRsp: AGSA_PHY_RATE_CONTROL_PAGE SOP 0x%x\n", SOP));
ossaGetPhyProfileCB(agRoot, agContext, status, SOP, PhyId , &RateControl );
break;
}
case AGSA_SAS_PHY_OPEN_REJECT_RETRY_BACKOFF_THRESHOLD_PAGE:
{
agsaSASPhyOpenRejectRetryBackOffThresholdPage_t Backoff;
OSSA_READ_LE_32(agRoot, &Backoff.Dword0, pIomb, OSSA_OFFSET_OF(agsaGetPhyProfileRspV_t,PageSpecificArea[0] ));
OSSA_READ_LE_32(agRoot, &Backoff.Dword1, pIomb, OSSA_OFFSET_OF(agsaGetPhyProfileRspV_t,PageSpecificArea[1] ));
OSSA_READ_LE_32(agRoot, &Backoff.Dword2, pIomb, OSSA_OFFSET_OF(agsaGetPhyProfileRspV_t,PageSpecificArea[2] ));
OSSA_READ_LE_32(agRoot, &Backoff.Dword3, pIomb, OSSA_OFFSET_OF(agsaGetPhyProfileRspV_t,PageSpecificArea[3] ));
SA_DBG1(("mpiGetPhyProfileRsp: AGSA_SAS_PHY_OPEN_REJECT_RETRY_BACKOFF_THRESHOLD_PAGE SOP 0x%x\n", SOP));
ossaGetPhyProfileCB(agRoot, agContext, status, SOP, PhyId , &Backoff );
break;
}
default:
{
SA_DBG1(("mpiGetPhyProfileRsp: undefined successful SOP 0x%x\n", SOP));
break;
}
}
}
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiGetPhyProfileRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
/* return value */
smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "2J");
return ret;
}
GLOBAL bit32 mpiSetPhyProfileRsp(
agsaRoot_t *agRoot,
agsaSetPhyProfileRspV_t *pIomb
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
agsaContext_t *agContext;
bit32 status, tag;
bit32 Reserved_Ppc_PHYID;
bit32 PhyId;
bit16 SOP;
smTraceFuncEnter(hpDBG_VERY_LOUD,"2Q");
OSSA_READ_LE_32(agRoot, &status, pIomb, OSSA_OFFSET_OF(agsaSetPhyProfileRspV_t, status));
OSSA_READ_LE_32(agRoot, &tag, pIomb, OSSA_OFFSET_OF(agsaSetPhyProfileRspV_t, tag));
OSSA_READ_LE_32(agRoot, &Reserved_Ppc_PHYID, pIomb, OSSA_OFFSET_OF(agsaSetPhyProfileRspV_t, Reserved_Ppc_PHYID));
/* get TAG */
SA_DBG1(("mpiSetPhyProfileRsp: HTag=0x%x\n", tag));
/* get request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
if (agNULL == pRequest)
{
SA_DBG1(("mpiSetPhyProfileRsp: Bad Response IOMB!!! pRequest is NULL. TAG=0x%x STATUS=0x%x\n", tag, status));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2Q");
return AGSA_RC_FAILURE;
}
agContext = saRoot->IOMap[tag].agContext;
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
SA_DBG1(("mpiSetPhyProfileRsp: %p\n",pIomb));
SOP = pRequest->SOP;
PhyId = Reserved_Ppc_PHYID & 0xFF;
/* check status success or failure */
if (status)
{
/* status is FAILED */
SA_DBG1(("mpiSetPhyProfileRsp:AGSA_RC_FAILURE 0x%08X\n", status));
switch(SOP)
{
case AGSA_SAS_PHY_ANALOG_SETTINGS_PAGE:
{
SA_DBG1(("mpiSetPhyProfileRsp: AGSA_SAS_PHY_ANALOG_SETTINGS_PAGE SOP 0x%x\n", SOP));
ossaSetPhyProfileCB(agRoot, agContext, status, SOP, PhyId, agNULL );
break;
}
case AGSA_PHY_SNW3_PAGE:
{
SA_DBG1(("mpiSetPhyProfileRsp: AGSA_PHY_SNW3_PAGE SOP 0x%x\n", SOP));
ossaSetPhyProfileCB(agRoot, agContext, status, SOP, PhyId, agNULL );
break;
}
case AGSA_PHY_RATE_CONTROL_PAGE:
{
SA_DBG1(("mpiSetPhyProfileRsp: AGSA_PHY_RATE_CONTROL_PAGE SOP 0x%x\n", SOP));
ossaSetPhyProfileCB(agRoot, agContext, status, SOP, PhyId, agNULL );
break;
}
case AGSA_SAS_PHY_MISC_PAGE:
{
SA_DBG1(("mpiSetPhyProfileRsp: AGSA_SAS_PHY_MISC_PAGE SOP 0x%x\n", SOP));
ossaSetPhyProfileCB(agRoot, agContext, status, SOP, PhyId, agNULL );
break;
}
default:
{
SA_DBG1(("mpiSetPhyProfileRsp: undefined SOP 0x%x\n", SOP));
break;
}
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "2Q");
return AGSA_RC_FAILURE;
}
else
{
SA_DBG1(("mpiSetPhyProfileRsp: SUCCESS type 0x%X\n",SOP ));
switch(SOP)
{
case AGSA_PHY_SNW3_PAGE:
case AGSA_PHY_RATE_CONTROL_PAGE:
{
SA_DBG1(("mpiSetPhyProfileRsp: Status 0x%x SOP 0x%x PhyId %d\n",status, SOP, PhyId));
ossaSetPhyProfileCB(agRoot, agContext, status, SOP, PhyId, agNULL );
break;
}
case AGSA_SAS_PHY_ANALOG_SETTINGS_PAGE:
{
agsaPhyAnalogSettingsPage_t analog;
SA_DBG1(("mpiSetPhyProfileRsp: AGSA_SAS_PHY_ANALOG_SETTINGS_PAGE 0x%X\n",SOP));
OSSA_READ_LE_32(agRoot, &analog.Dword0, pIomb, OSSA_OFFSET_OF(agsaSetPhyProfileRspV_t,PageSpecificArea[0] ));
OSSA_READ_LE_32(agRoot, &analog.Dword1, pIomb, OSSA_OFFSET_OF(agsaSetPhyProfileRspV_t,PageSpecificArea[1] ));
OSSA_READ_LE_32(agRoot, &analog.Dword2, pIomb, OSSA_OFFSET_OF(agsaSetPhyProfileRspV_t,PageSpecificArea[2] ));
OSSA_READ_LE_32(agRoot, &analog.Dword3, pIomb, OSSA_OFFSET_OF(agsaSetPhyProfileRspV_t,PageSpecificArea[3] ));
OSSA_READ_LE_32(agRoot, &analog.Dword4, pIomb, OSSA_OFFSET_OF(agsaSetPhyProfileRspV_t,PageSpecificArea[4] ));
/* call back with the status */
ossaSetPhyProfileCB(agRoot, agContext, status, SOP, PhyId, &analog );
break;
}
default:
{
SA_DBG1(("mpiSetPhyProfileRsp: undefined successful SOP 0x%x\n", SOP));
break;
}
}
}
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_ASSERT((pRequest->valid), "pRequest->valid");
SA_DBG1(("mpiSetPhyProfileRsp: completionCB %p\n",pRequest->completionCB ));
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiSetPhyProfileRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
/* return value */
smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "2Q");
return ret;
}
/******************************************************************************/
/*! \brief Get Device Information Response
*
* This routine handles the response of Get Device Info Command Response
*
* \param agRoot Handles for this instance of SAS/SATA LLL
* \param pIomb Pointer of IOMB Message
*
* \return sucess or fail
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiGetDevInfoRsp(
agsaRoot_t *agRoot,
agsaGetDevInfoRspV_t *pIomb
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
agsaDevHandle_t *agDevHandle;
agsaDeviceDesc_t *pDevice;
agsaContext_t *agContext;
agsaDeviceInfo_t commonDevInfo;
bit32 ARSrateSMPTimeOutPortID, IRMcnITNexusTimeOut, status, tag;
bit32 deviceid;
bit32 sasAddrHi;
bit32 sasAddrLow;
#if defined(SALLSDK_DEBUG)
bit32 option;
#endif /* SALLSDK_DEBUG */
smTraceFuncEnter(hpDBG_VERY_LOUD,"2M");
OSSA_READ_LE_32(AGROOT, &status, pIomb, OSSA_OFFSET_OF(agsaGetDevInfoRspV_t, status));
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaGetDevInfoRspV_t, tag));
/* get TAG */
SA_DBG3(("mpiGetDevInfoRsp: HTag=0x%x\n", tag));
/* get request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
if (agNULL == pRequest)
{
SA_DBG1(("mpiGetDevInfoRsp: Bad Response IOMB!!! pRequest is NULL. TAG=0x%x STATUS=0x%x\n", tag, status));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2M");
return AGSA_RC_FAILURE;
}
agContext = saRoot->IOMap[tag].agContext;
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
SA_ASSERT((pRequest->valid), "pRequest->valid");
/* check status success or failure */
if (status)
{
/* status is FAILED */
ossaGetDeviceInfoCB(agRoot, agContext, agNULL, OSSA_DEV_INFO_INVALID_HANDLE, agNULL);
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "2M");
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
#if defined(SALLSDK_DEBUG)
option = (bit32)pRequest->DeviceInfoCmdOption;
#endif /* SALLSDK_DEBUG */
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiGetDevInfoRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
return AGSA_RC_FAILURE;
}
/* status is SUCCESS */
OSSA_READ_LE_32(AGROOT, &deviceid, pIomb, OSSA_OFFSET_OF(agsaGetDevInfoRspV_t, deviceId));
OSSA_READ_LE_32(AGROOT, &ARSrateSMPTimeOutPortID, pIomb, OSSA_OFFSET_OF(agsaGetDevInfoRspV_t, ARSrateSMPTimeOutPortID));
OSSA_READ_LE_32(AGROOT, &IRMcnITNexusTimeOut, pIomb, OSSA_OFFSET_OF(agsaGetDevInfoRspV_t, IRMcnITNexusTimeOut));
OSSA_READ_LE_32(AGROOT, &sasAddrHi, pIomb, OSSA_OFFSET_OF(agsaGetDevInfoRspV_t,sasAddrHi[0] ));
OSSA_READ_LE_32(AGROOT, &sasAddrLow, pIomb, OSSA_OFFSET_OF(agsaGetDevInfoRspV_t,sasAddrLow[0] ));
/* find device handle from device index */
pDevice = (agsaDeviceDesc_t *)saRoot->DeviceMap[deviceid & DEVICE_ID_BITS].DeviceHandle;
if (pDevice != agNULL)
{
if (pDevice->targetDevHandle.sdkData)
{
agDevHandle = &(pDevice->targetDevHandle);
}
else
{
agDevHandle = &(pDevice->initiatorDevHandle);
}
}
else
{
SA_DBG1(("mpiGetDevInfoRsp: pDevice is NULL"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "2M");
return AGSA_RC_FAILURE;
}
if (agDevHandle == agNULL)
{
SA_DBG1(("mpiGetDevInfoRsp: warning!!! no deviceHandle is found"));
ossaGetDeviceInfoCB(agRoot, agContext, agNULL, OSSA_DEV_INFO_INVALID_HANDLE, agNULL);
smTraceFuncExit(hpDBG_VERY_LOUD, 'd', "2M");
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
#if defined(SALLSDK_DEBUG)
option = (bit32)pRequest->DeviceInfoCmdOption;
#endif /* SALLSDK_DEBUG */
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiGetDevInfoRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
return AGSA_RC_FAILURE;
}
/* setup common device information */
si_memset(&commonDevInfo, 0, sizeof(agsaDeviceInfo_t));
commonDevInfo.smpTimeout = (bit16)((ARSrateSMPTimeOutPortID >> SHIFT8 ) & SMPTO_VBITS);
commonDevInfo.it_NexusTimeout = (bit16)(IRMcnITNexusTimeOut & NEXUSTO_VBITS);
commonDevInfo.firstBurstSize = (bit16)((IRMcnITNexusTimeOut >> SHIFT16) & FIRST_BURST_MCN);
commonDevInfo.devType_S_Rate = (bit8)((ARSrateSMPTimeOutPortID >> SHIFT24) & 0x3f);
commonDevInfo.flag = (bit32)((ARSrateSMPTimeOutPortID >> SHIFT30 ) & FLAG_VBITS);
commonDevInfo.flag |= IRMcnITNexusTimeOut & 0xf0000;
if (IRMcnITNexusTimeOut & 0x1000000)
{
commonDevInfo.flag |= 0x100000;
}
/* check SAS device then copy SAS Address */
if ( ((ARSrateSMPTimeOutPortID & DEV_TYPE_BITS) >> SHIFT28 == 0x00) ||
((ARSrateSMPTimeOutPortID & DEV_TYPE_BITS) >> SHIFT28 == 0x01))
{
/* copy the sasAddressHi byte-by-byte : no endianness */
commonDevInfo.sasAddressHi[0] = pIomb->sasAddrHi[0];
commonDevInfo.sasAddressHi[1] = pIomb->sasAddrHi[1];
commonDevInfo.sasAddressHi[2] = pIomb->sasAddrHi[2];
commonDevInfo.sasAddressHi[3] = pIomb->sasAddrHi[3];
/* copy the sasAddressLow byte-by-byte : no endianness */
commonDevInfo.sasAddressLo[0] = pIomb->sasAddrLow[0];
commonDevInfo.sasAddressLo[1] = pIomb->sasAddrLow[1];
commonDevInfo.sasAddressLo[2] = pIomb->sasAddrLow[2];
commonDevInfo.sasAddressLo[3] = pIomb->sasAddrLow[3];
}
/* copy common device information to SAS and SATA device common header*/
si_memcpy(&pDevice->devInfo.sasDeviceInfo.commonDevInfo, &commonDevInfo, sizeof(agsaDeviceInfo_t));
si_memcpy(&pDevice->devInfo.sataDeviceInfo.commonDevInfo, &commonDevInfo, sizeof(agsaDeviceInfo_t));
/* setup device firstBurstSize infomation */
pDevice->devInfo.sataDeviceInfo.commonDevInfo.firstBurstSize =
(bit16)((IRMcnITNexusTimeOut >> SHIFT16) & FIRST_BURST);
/* Display Device Information */
SA_DBG3(("mpiGetDevInfoRsp: smpTimeout=0x%x\n", pDevice->devInfo.sasDeviceInfo.commonDevInfo.smpTimeout));
SA_DBG3(("mpiGetDevInfoRsp: it_NexusTimeout=0x%x\n", pDevice->devInfo.sasDeviceInfo.commonDevInfo.it_NexusTimeout));
SA_DBG3(("mpiGetDevInfoRsp: firstBurstSize=0x%x\n", pDevice->devInfo.sasDeviceInfo.commonDevInfo.firstBurstSize));
SA_DBG3(("mpiGetDevInfoRsp: devType_S_Rate=0x%x\n", pDevice->devInfo.sasDeviceInfo.commonDevInfo.devType_S_Rate));
/*
D518 P2I[15-12]: Disk HP DG0146FAMWL , HPDE, WWID=5000c500:17459a31, 6.0G
*/
SA_DBG1(("mpiGetDevInfoRsp: Device 0x%08X flag 0x%08X %s WWID= %02x%02x%02x%02x:%02x%02x%02x%02x, %s\n",
deviceid,
pDevice->devInfo.sasDeviceInfo.commonDevInfo.flag,
(pDevice->devInfo.sasDeviceInfo.commonDevInfo.devType_S_Rate & 0xF0) == 0x20 ? "SATA DA" :
(pDevice->devInfo.sasDeviceInfo.commonDevInfo.devType_S_Rate & 0xF0) == 0x10 ? "SSP/SMP" :
(pDevice->devInfo.sasDeviceInfo.commonDevInfo.devType_S_Rate & 0xF0) == 0x0 ? " STP " : "Unknown",
pDevice->devInfo.sasDeviceInfo.commonDevInfo.sasAddressHi[3],
pDevice->devInfo.sasDeviceInfo.commonDevInfo.sasAddressHi[2],
pDevice->devInfo.sasDeviceInfo.commonDevInfo.sasAddressHi[1],
pDevice->devInfo.sasDeviceInfo.commonDevInfo.sasAddressHi[0],
pDevice->devInfo.sasDeviceInfo.commonDevInfo.sasAddressLo[3],
pDevice->devInfo.sasDeviceInfo.commonDevInfo.sasAddressLo[2],
pDevice->devInfo.sasDeviceInfo.commonDevInfo.sasAddressLo[1],
pDevice->devInfo.sasDeviceInfo.commonDevInfo.sasAddressLo[0],
(pDevice->devInfo.sasDeviceInfo.commonDevInfo.devType_S_Rate & 0xF) == 8 ? " 1.5G" :
(pDevice->devInfo.sasDeviceInfo.commonDevInfo.devType_S_Rate & 0xF) == 9 ? " 3.0G" :
(pDevice->devInfo.sasDeviceInfo.commonDevInfo.devType_S_Rate & 0xF) == 10 ? " 6.0G" :
(pDevice->devInfo.sasDeviceInfo.commonDevInfo.devType_S_Rate & 0xF) == 11 ? "12.0G" : "????" ));
ossaGetDeviceInfoCB(agRoot, agContext, agDevHandle, OSSA_DEV_INFO_NO_EXTENDED_INFO, &commonDevInfo);
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
#if defined(SALLSDK_DEBUG)
option = (bit32)pRequest->DeviceInfoCmdOption;
#endif /* SALLSDK_DEBUG */
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiGetDevInfoRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
/* return value */
smTraceFuncExit(hpDBG_VERY_LOUD, 'e', "2M");
return ret;
}
/******************************************************************************/
/*! \brief Get Device Information Response
*
* This routine handles the response of Get Device Info Command Response
*
* \param agRoot Handles for this instance of SAS/SATA LLL
* \param pIomb Pointer of IOMB Message
*
* \return sucess or fail
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiGetDevInfoRspSpc(
agsaRoot_t *agRoot,
agsaGetDevInfoRsp_t *pIomb
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
agsaDevHandle_t *agDevHandle;
agsaDeviceDesc_t *pDevice;
agsaContext_t *agContext;
bit32 dTypeSrateSMPTOPortID, FirstBurstSizeITNexusTimeOut, status, tag;
bit32 deviceid;
bit32 sasAddrHi;
bit32 sasAddrLow;
bit32 Info_avail = 0;
smTraceFuncEnter(hpDBG_VERY_LOUD,"2t");
OSSA_READ_LE_32(AGROOT, &status, pIomb, OSSA_OFFSET_OF(agsaGetDevInfoRsp_t, status));
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaGetDevInfoRsp_t, tag));
/* get TAG */
SA_DBG3(("mpiGetDevInfoRspSpc: HTag=0x%x\n", tag));
/* get request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
if (agNULL == pRequest)
{
SA_DBG1(("mpiGetDevInfoRspSpc: Bad Response IOMB!!! pRequest is NULL. TAG=0x%x STATUS=0x%x\n", tag, status));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2t");
return AGSA_RC_FAILURE;
}
agContext = saRoot->IOMap[tag].agContext;
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
SA_ASSERT((pRequest->valid), "pRequest->valid");
/* check status success or failure */
if (status)
{
/* status is FAILED */
ossaGetDeviceInfoCB(agRoot, agContext, agNULL, OSSA_DEV_INFO_INVALID_HANDLE, agNULL);
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "2t");
return AGSA_RC_FAILURE;
}
/* status is SUCCESS */
OSSA_READ_LE_32(AGROOT, &deviceid, pIomb, OSSA_OFFSET_OF(agsaGetDevInfoRsp_t, deviceId));
OSSA_READ_LE_32(AGROOT, &dTypeSrateSMPTOPortID, pIomb, OSSA_OFFSET_OF(agsaGetDevInfoRsp_t, dTypeSrateSMPTOArPortID));
OSSA_READ_LE_32(AGROOT, &FirstBurstSizeITNexusTimeOut, pIomb, OSSA_OFFSET_OF(agsaGetDevInfoRsp_t, FirstBurstSizeITNexusTimeOut));
OSSA_READ_LE_32(AGROOT, &sasAddrHi, pIomb, OSSA_OFFSET_OF(agsaGetDevInfoRsp_t, sasAddrHi[0]));
OSSA_READ_LE_32(AGROOT, &sasAddrLow, pIomb, OSSA_OFFSET_OF(agsaGetDevInfoRsp_t, sasAddrLow[0]));
SA_DBG2(("mpiGetDevInfoRspSpc:deviceid 0x%08X\n",deviceid));
SA_DBG2(("mpiGetDevInfoRspSpc:dTypeSrateSMPTOPortID 0x%08X\n",dTypeSrateSMPTOPortID));
SA_DBG2(("mpiGetDevInfoRspSpc:FirstBurstSizeITNexusTimeOut 0x%08X\n",FirstBurstSizeITNexusTimeOut));
SA_DBG2(("mpiGetDevInfoRspSpc:sasAddrHi 0x%08X\n",sasAddrHi));
SA_DBG2(("mpiGetDevInfoRspSpc:sasAddrLow 0x%08X\n",sasAddrLow));
/* find device handle from device index */
pDevice = (agsaDeviceDesc_t *)saRoot->DeviceMap[deviceid & DEVICE_ID_BITS].DeviceHandle;
if (pDevice != agNULL)
{
if (pDevice->targetDevHandle.sdkData)
{
agDevHandle = &(pDevice->targetDevHandle);
}
else
{
agDevHandle = &(pDevice->initiatorDevHandle);
}
}
else
{
SA_DBG1(("mpiGetDevInfoRspSpc: pDevice is NULL"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "2t");
return AGSA_RC_FAILURE;
}
if (agDevHandle == agNULL)
{
SA_DBG1(("mpiGetDevInfoRspSpc: warning!!! no deviceHandle is found"));
ossaGetDeviceInfoCB(agRoot, agContext, agNULL, OSSA_DEV_INFO_INVALID_HANDLE, agNULL);
smTraceFuncExit(hpDBG_VERY_LOUD, 'd', "2t");
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiGetDevInfoRspSpc: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
return AGSA_RC_FAILURE;
}
Info_avail = OSSA_DEV_INFO_NO_EXTENDED_INFO;
/* setup device common infomation */
pDevice->devInfo.sasDeviceInfo.commonDevInfo.smpTimeout =
(bit16)((dTypeSrateSMPTOPortID >> SHIFT8 ) & SMPTO_BITS);
pDevice->devInfo.sataDeviceInfo.commonDevInfo.smpTimeout =
(bit16)((dTypeSrateSMPTOPortID >> SHIFT8 ) & SMPTO_BITS);
pDevice->devInfo.sasDeviceInfo.commonDevInfo.it_NexusTimeout =
(bit16)(FirstBurstSizeITNexusTimeOut & NEXUSTO_BITS);
pDevice->devInfo.sataDeviceInfo.commonDevInfo.it_NexusTimeout =
(bit16)(FirstBurstSizeITNexusTimeOut & NEXUSTO_BITS);
pDevice->devInfo.sasDeviceInfo.commonDevInfo.firstBurstSize =
(bit16)((FirstBurstSizeITNexusTimeOut >> SHIFT16) & FIRST_BURST);
pDevice->devInfo.sataDeviceInfo.commonDevInfo.firstBurstSize =
(bit16)((FirstBurstSizeITNexusTimeOut >> SHIFT16) & FIRST_BURST);
pDevice->devInfo.sasDeviceInfo.commonDevInfo.flag = (bit32)((dTypeSrateSMPTOPortID >> SHIFT4 ) & FLAG_BITS);
pDevice->devInfo.sataDeviceInfo.commonDevInfo.flag = (bit32)((dTypeSrateSMPTOPortID >> SHIFT4 ) & FLAG_BITS);
pDevice->devInfo.sasDeviceInfo.commonDevInfo.devType_S_Rate =
(bit8)((dTypeSrateSMPTOPortID >> SHIFT24) & LINK_RATE_BITS);
pDevice->devInfo.sataDeviceInfo.commonDevInfo.devType_S_Rate =
(bit8)((dTypeSrateSMPTOPortID >> SHIFT24) & LINK_RATE_BITS);
/* check SAS device then copy SAS Address */
if ( ((dTypeSrateSMPTOPortID & DEV_TYPE_BITS) >> SHIFT28 == 0x00) ||
((dTypeSrateSMPTOPortID & DEV_TYPE_BITS) >> SHIFT28 == 0x01))
{
/* copy the sasAddressHi byte-by-byte : no endianness */
pDevice->devInfo.sasDeviceInfo.commonDevInfo.sasAddressHi[0] = pIomb->sasAddrHi[0];
pDevice->devInfo.sasDeviceInfo.commonDevInfo.sasAddressHi[1] = pIomb->sasAddrHi[1];
pDevice->devInfo.sasDeviceInfo.commonDevInfo.sasAddressHi[2] = pIomb->sasAddrHi[2];
pDevice->devInfo.sasDeviceInfo.commonDevInfo.sasAddressHi[3] = pIomb->sasAddrHi[3];
/* copy the sasAddressLow byte-by-byte : no endianness */
pDevice->devInfo.sasDeviceInfo.commonDevInfo.sasAddressLo[0] = pIomb->sasAddrLow[0];
pDevice->devInfo.sasDeviceInfo.commonDevInfo.sasAddressLo[1] = pIomb->sasAddrLow[1];
pDevice->devInfo.sasDeviceInfo.commonDevInfo.sasAddressLo[2] = pIomb->sasAddrLow[2];
pDevice->devInfo.sasDeviceInfo.commonDevInfo.sasAddressLo[3] = pIomb->sasAddrLow[3];
}
/* Display Device Information */
SA_DBG3(("mpiGetDevInfoRspSpc: smpTimeout= 0x%x\n", pDevice->devInfo.sasDeviceInfo.commonDevInfo.smpTimeout));
SA_DBG3(("mpiGetDevInfoRspSpc: it_NexusTimeout=0x%x\n", pDevice->devInfo.sasDeviceInfo.commonDevInfo.it_NexusTimeout));
SA_DBG3(("mpiGetDevInfoRspSpc: firstBurstSize= 0x%x\n", pDevice->devInfo.sasDeviceInfo.commonDevInfo.firstBurstSize));
SA_DBG3(("mpiGetDevInfoRspSpc: devType_S_Rate= 0x%x\n", pDevice->devInfo.sasDeviceInfo.commonDevInfo.devType_S_Rate));
SA_DBG1(("Device SPC deviceid 0x%08X flag 0x%08X %s WWID= %02x%02x%02x%02x:%02x%02x%02x%02x, %s\n",
deviceid,
pDevice->devInfo.sasDeviceInfo.commonDevInfo.flag,
(pDevice->devInfo.sasDeviceInfo.commonDevInfo.devType_S_Rate & 0xF0) == 0x20 ? "SATA DA" :
(pDevice->devInfo.sasDeviceInfo.commonDevInfo.devType_S_Rate & 0xF0) == 0x10 ? "SSP/SMP" :
(pDevice->devInfo.sasDeviceInfo.commonDevInfo.devType_S_Rate & 0xF0) == 0x0 ? " STP " : "Unknown",
pDevice->devInfo.sasDeviceInfo.commonDevInfo.sasAddressHi[3],
pDevice->devInfo.sasDeviceInfo.commonDevInfo.sasAddressHi[2],
pDevice->devInfo.sasDeviceInfo.commonDevInfo.sasAddressHi[1],
pDevice->devInfo.sasDeviceInfo.commonDevInfo.sasAddressHi[0],
pDevice->devInfo.sasDeviceInfo.commonDevInfo.sasAddressLo[3],
pDevice->devInfo.sasDeviceInfo.commonDevInfo.sasAddressLo[2],
pDevice->devInfo.sasDeviceInfo.commonDevInfo.sasAddressLo[1],
pDevice->devInfo.sasDeviceInfo.commonDevInfo.sasAddressLo[0],
(pDevice->devInfo.sasDeviceInfo.commonDevInfo.devType_S_Rate & 0xF) == 8 ? " 1.5G" :
(pDevice->devInfo.sasDeviceInfo.commonDevInfo.devType_S_Rate & 0xF) == 9 ? " 3.0G" :
(pDevice->devInfo.sasDeviceInfo.commonDevInfo.devType_S_Rate & 0xF) == 10 ? " 6.0G" :
(pDevice->devInfo.sasDeviceInfo.commonDevInfo.devType_S_Rate & 0xF) == 11 ? "12.0G" : "????" ));
ossaGetDeviceInfoCB(agRoot, agContext, agDevHandle, Info_avail, &pDevice->devInfo.sasDeviceInfo.commonDevInfo);
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiGetDevInfoRspSpc: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
/* return value */
smTraceFuncExit(hpDBG_VERY_LOUD, 'e', "2t");
return ret;
}
/******************************************************************************/
/*! \brief Set Device Information Response
*
* This routine handles the response of Set Device Info Command Response
*
* \param agRoot Handles for this instance of SAS/SATA LLL
* \param pIomb Pointer of IOMB Message
*
* \return sucess or fail
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiSetDevInfoRsp(
agsaRoot_t *agRoot,
agsaSetDeviceInfoRsp_t *pIomb
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
agsaDevHandle_t *agDevHandle;
agsaDeviceDesc_t *pDevice;
agsaContext_t *agContext;
bit32 tag, status, deviceid, option, param;
smTraceFuncEnter(hpDBG_VERY_LOUD,"2v");
OSSA_READ_LE_32(AGROOT, &status, pIomb, OSSA_OFFSET_OF(agsaSetDeviceInfoRsp_t, status));
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaSetDeviceInfoRsp_t, tag));
/* get TAG */
SA_DBG3(("mpiSetDevInfoRsp: HTag=0x%x\n", tag));
/* get request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
if (agNULL == pRequest)
{
SA_DBG1(("mpiSetDevInfoRsp: Bad Response IOMB!!! pRequest is NULL. TAG=0x%x STATUS=0x%x\n", tag, status));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2v");
return AGSA_RC_FAILURE;
}
agContext = saRoot->IOMap[tag].agContext;
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
SA_ASSERT((pRequest->valid), "pRequest->valid");
/* check status success or failure */
if (status)
{
/* status is FAILED */
if (pRequest->completionCB == agNULL)
{
SA_DBG1(("mpiSetDevInfoRsp: status is FAILED pRequest->completionCB == agNULL\n" ));
ossaSetDeviceInfoCB(agRoot, agContext, agNULL, status, 0, 0);
}
else
{
SA_DBG1(("mpiSetDevInfoRsp: status is FAILED use CB\n" ));
(*(ossaSetDeviceInfoCB_t)(pRequest->completionCB))(agRoot, agContext, agNULL, status, 0, 0);
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "2v");
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
return AGSA_RC_FAILURE;
}
/* status is SUCCESS */
OSSA_READ_LE_32(AGROOT, &deviceid, pIomb, OSSA_OFFSET_OF(agsaSetDeviceInfoRsp_t, deviceId));
OSSA_READ_LE_32(AGROOT, &option, pIomb, OSSA_OFFSET_OF(agsaSetDeviceInfoRsp_t, SA_SR_SI));
OSSA_READ_LE_32(AGROOT, ¶m, pIomb, OSSA_OFFSET_OF(agsaSetDeviceInfoRsp_t, A_R_ITNT));
/* find device handle from device index */
pDevice = (agsaDeviceDesc_t *)saRoot->DeviceMap[deviceid & DEVICE_ID_BITS].DeviceHandle;
if (pDevice != agNULL)
{
if (pDevice->targetDevHandle.sdkData)
{
agDevHandle = &(pDevice->targetDevHandle);
}
else
{
agDevHandle = &(pDevice->initiatorDevHandle);
}
}
else
{
SA_DBG1(("mpiSetDevInfoRsp: pDevice is NULL"));
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "2v");
return AGSA_RC_FAILURE;
}
if (agDevHandle == agNULL)
{
SA_DBG1(("mpiSetDevInfoRsp: warning!!! no deviceHandle is found"));
if (pRequest->completionCB == agNULL)
{
ossaSetDeviceInfoCB(agRoot, agContext, agNULL, OSSA_IO_NO_DEVICE, 0, 0);
}
else
{
(*(ossaSetDeviceInfoCB_t)(pRequest->completionCB))(agRoot, agContext, agNULL, OSSA_IO_NO_DEVICE, 0, 0);
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'd', "2v");
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
return AGSA_RC_FAILURE;
}
SA_DBG2(("mpiSetDevInfoRsp:, option 0x%X param 0x%X\n", option, param));
if(smIS_SPCV(agRoot))
{
SA_DBG2(("mpiSetDevInfoRsp:was option 0x%X param 0x%X\n", option, param));
SA_DBG2(("mpiSetDevInfoRsp:pDevice->option 0x%X pDevice->param 0x%X\n", pDevice->option, pDevice->param));
option |= pDevice->option;
param |= pDevice->param;
SA_DBG2(("mpiSetDevInfoRsp:now option 0x%X param 0x%X\n", option, param));
if (pRequest->completionCB == agNULL)
{
ossaSetDeviceInfoCB(agRoot, agContext, agDevHandle, OSSA_SUCCESS, option, param);
}
else
{
(*(ossaSetDeviceInfoCB_t)(pRequest->completionCB))(agRoot, agContext, agDevHandle, OSSA_SUCCESS, option, param);
}
}
else
{
SA_DBG2(("mpiSetDevInfoRsp:, option 0x%X param 0x%X\n", option, param));
if (pRequest->completionCB == agNULL)
{
ossaSetDeviceInfoCB(agRoot, agContext, agDevHandle, OSSA_SUCCESS, option, param);
}
else
{
(*(ossaSetDeviceInfoCB_t)(pRequest->completionCB))(agRoot, agContext, agDevHandle, OSSA_SUCCESS, option, param);
}
}
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
/* return value */
smTraceFuncExit(hpDBG_VERY_LOUD, 'e', "2v");
return ret;
}
/******************************************************************************/
/*! \brief SPC MPI SSP Event
*
* This function handles the SAS Event.
*
* \param agRoot Handles for this instance of SAS/SATA LLL
* \param pIomb pointer of Message
*
* \return The read value
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiSSPEvent(
agsaRoot_t *agRoot,
agsaSSPEventRsp_t *pIomb
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
agsaPortContext_t *agPortContext;
agsaDevHandle_t *agDevHandle;
agsaDeviceDesc_t *pDevice;
bit32 event,deviceId;
bit32 deviceIdx, tag, portId_tmp;
bit32 SSPTag;
bit16 sspTag;
bit8 portId;
agsaDifDetails_t Dif_details;
smTraceFuncEnter(hpDBG_VERY_LOUD,"2u");
OSSA_READ_LE_32(AGROOT, &event, pIomb, OSSA_OFFSET_OF(agsaSSPEventRsp_t, event));
OSSA_READ_LE_32(AGROOT, &deviceId, pIomb, OSSA_OFFSET_OF(agsaSSPEventRsp_t, deviceId));
OSSA_READ_LE_32(AGROOT, &portId_tmp, pIomb, OSSA_OFFSET_OF(agsaSSPEventRsp_t, portId));
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaSSPEventRsp_t, tag));
OSSA_READ_LE_32(AGROOT, &SSPTag, pIomb, OSSA_OFFSET_OF(agsaSSPEventRsp_t, SSPTag));
sspTag = (bit16)(SSPTag & SSPTAG_BITS);
/* get IORequest from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
SA_ASSERT((pRequest), "pRequest");
if(agNULL == pRequest)
{
SA_DBG1(("mpiSSPEvent: agNULL == pRequest event 0x%X\n", event));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2u");
return AGSA_RC_FAILURE;
}
/* get port context */
portId = (bit8)(portId_tmp & PORTID_MASK);
SA_DBG2(("mpiSSPEvent:PortID 0x%x PortStatus 0x%x PortContext %p\n",saRoot->PortMap[portId & PORTID_MASK].PortID,saRoot->PortMap[portId & PORTID_MASK].PortStatus,saRoot->PortMap[portId & PORTID_MASK].PortContext));
agPortContext = (agsaPortContext_t *)saRoot->PortMap[portId].PortContext;
/* get device Id */
deviceIdx = deviceId & DEVICE_ID_BITS;
OS_ASSERT(deviceIdx < MAX_IO_DEVICE_ENTRIES, "deviceIdx MAX_IO_DEVICE_ENTRIES");
/* find device handle from device index */
pDevice = (agsaDeviceDesc_t *)saRoot->DeviceMap[deviceIdx].DeviceHandle;
if( agNULL == pDevice )
{
OS_ASSERT(pDevice, "pDevice");
agDevHandle = agNULL;
}
else
{
if (pDevice->targetDevHandle.sdkData)
{
agDevHandle = &(pDevice->targetDevHandle);
}
else
{
agDevHandle = &(pDevice->initiatorDevHandle);
}
}
switch (event)
{
case OSSA_IO_XFR_ERROR_DIF_APPLICATION_TAG_MISMATCH:
case OSSA_IO_XFR_ERROR_DIF_REFERENCE_TAG_MISMATCH:
case OSSA_IO_XFR_ERROR_DIF_CRC_MISMATCH:
case OSSA_IO_XFR_ERROR_DIF_MISMATCH:
{
SA_DBG1(("mpiSSPEvent: DIF Event 0x%x HTAG = 0x%x\n", event, tag));
OSSA_READ_LE_32(AGROOT, &Dif_details.UpperLBA, pIomb, OSSA_OFFSET_OF(agsaSSPEventRsp_t, EVT_PARAM0_or_LBAH));
OSSA_READ_LE_32(AGROOT, &Dif_details.LowerLBA, pIomb, OSSA_OFFSET_OF(agsaSSPEventRsp_t, EVT_PARAM1_or_LBAL));
OSSA_READ_LE_32(AGROOT, &Dif_details.sasAddressHi, pIomb, OSSA_OFFSET_OF(agsaSSPEventRsp_t, SAS_ADDRH));
OSSA_READ_LE_32(AGROOT, &Dif_details.sasAddressLo, pIomb, OSSA_OFFSET_OF(agsaSSPEventRsp_t, SAS_ADDRL));
OSSA_READ_LE_32(AGROOT, &Dif_details.ExpectedCRCUDT01, pIomb, OSSA_OFFSET_OF(agsaSSPEventRsp_t, UDT1_E_UDT0_E_CRC_E));
OSSA_READ_LE_32(AGROOT, &Dif_details.ExpectedUDT2345, pIomb, OSSA_OFFSET_OF(agsaSSPEventRsp_t, UDT5_E_UDT4_E_UDT3_E_UDT2_E));
OSSA_READ_LE_32(AGROOT, &Dif_details.ActualCRCUDT01, pIomb, OSSA_OFFSET_OF(agsaSSPEventRsp_t, UDT1_A_UDT0_A_CRC_A));
OSSA_READ_LE_32(AGROOT, &Dif_details.ActualUDT2345, pIomb, OSSA_OFFSET_OF(agsaSSPEventRsp_t, UDT5_A_UDT4_A_UDT3_A_UDT2_A));
OSSA_READ_LE_32(AGROOT, &Dif_details.DIFErrDevID, pIomb, OSSA_OFFSET_OF(agsaSSPEventRsp_t, HW_DEVID_Reserved_DIF_ERR));
OSSA_READ_LE_32(AGROOT, &Dif_details.ErrBoffsetEDataLen, pIomb, OSSA_OFFSET_OF(agsaSSPEventRsp_t, EDATA_LEN_ERR_BOFF));
SA_DBG2(("mpiSSPEvent: UpperLBA. 0x%08X LowerLBA. 0x%08X\n",Dif_details.UpperLBA, Dif_details.LowerLBA));
SA_DBG2(("mpiSSPEvent: sasAddressHi. 0x%02X%02X%02X%02X sasAddressLo. 0x%02X%02X%02X%02X\n",
Dif_details.sasAddressHi[0],Dif_details.sasAddressHi[1],Dif_details.sasAddressHi[2],Dif_details.sasAddressHi[3],
Dif_details.sasAddressLo[0],Dif_details.sasAddressLo[1],Dif_details.sasAddressLo[2],Dif_details.sasAddressLo[3]));
SA_DBG2(("mpiSSPEvent: ExpectedCRCUDT01. 0x%08X ExpectedUDT2345. 0x%08X\n",Dif_details.ExpectedCRCUDT01, Dif_details.ExpectedUDT2345));
SA_DBG2(("mpiSSPEvent: ActualCRCUDT01. 0x%08X ActualUDT2345. 0x%08X\n",Dif_details.ActualCRCUDT01, Dif_details.ActualUDT2345));
SA_DBG2(("mpiSSPEvent: DIFErrDevID. 0x%08X ErrBoffsetEDataLen. 0x%08X\n",Dif_details.DIFErrDevID, Dif_details.ErrBoffsetEDataLen));
}
default:
{
SA_DBG3(("mpiSSPEvent: Non DIF event"));
break;
}
}
/* get event */
switch (event)
{
case OSSA_IO_OVERFLOW:
{
SA_DBG1(("mpiSSPEvent: OSSA_IO_OVERFLOW tag 0x%x ssptag 0x%x\n", tag, sspTag));
saRoot->IoEventCount.agOSSA_IO_OVERFLOW++;
ossaSSPEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, sspTag, 0,agNULL);
break;
}
case OSSA_IO_XFER_ERROR_BREAK:
{
SA_DBG1(("mpiSSPEvent: OSSA_IO_XFER_ERROR_BREAK tag 0x%x ssptag 0x%x\n", tag, sspTag));
saRoot->IoEventCount.agOSSA_IO_XFER_ERROR_BREAK++;
ossaSSPEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, sspTag, 0,agNULL);
break;
}
case OSSA_IO_XFER_ERROR_PHY_NOT_READY:
{
SA_DBG1(("mpiSSPEvent: OSSA_IO_XFER_ERROR_PHY_NOT_READY tag 0x%x ssptag 0x%x\n", tag, sspTag));
saRoot->IoEventCount.agOSSA_IO_XFER_ERROR_PHY_NOT_READY++;
ossaSSPEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, sspTag, 0,agNULL);
break;
}
case OSSA_IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED:
{
SA_DBG1(("mpiSSPEvent: OSSA_IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED tag 0x%x ssptag 0x%x\n", tag, sspTag));
saRoot->IoEventCount.agOSSA_IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED++;
ossaSSPEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, sspTag, 0,agNULL);
break;
}
case OSSA_IO_OPEN_CNX_ERROR_ZONE_VIOLATION:
{
SA_DBG1(("mpiSSPEvent: OSSA_IO_OPEN_CNX_ERROR_ZONE_VIOLATION tag 0x%x ssptag 0x%x\n", tag, sspTag));
saRoot->IoEventCount.agOSSA_IO_OPEN_CNX_ERROR_ZONE_VIOLATION++;
ossaSSPEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, sspTag, 0,agNULL);
break;
}
case OSSA_IO_OPEN_CNX_ERROR_BREAK:
{
SA_DBG1(("mpiSSPEvent: OSSA_IO_OPEN_CNX_ERROR_BREAK tag 0x%x ssptag 0x%x\n", tag, sspTag));
saRoot->IoEventCount.agOSSA_IO_OPEN_CNX_ERROR_BREAK++;
ossaSSPEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, sspTag, 0,agNULL);
break;
}
case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS:
{
SA_DBG1(("mpiSSPEvent: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS tag 0x%x ssptag 0x%x\n", tag, sspTag));
saRoot->IoEventCount.agOSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS++;
ossaSSPEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, sspTag, 0,agNULL);
break;
}
case OSSA_IO_OPEN_CNX_ERROR_BAD_DESTINATION:
{
SA_DBG1(("mpiSSPEvent: OSSA_IO_OPEN_CNX_ERROR_BAD_DESTINATION tag 0x%x ssptag 0x%x\n", tag, sspTag));
saRoot->IoEventCount.agOSSA_IO_OPEN_CNX_ERROR_BAD_DESTINATION++;
ossaSSPEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, sspTag, 0,agNULL);
break;
}
case OSSA_IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED:
{
SA_DBG1(("mpiSSPEvent: OSSA_IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED tag 0x%x ssptag 0x%x\n", tag, sspTag));
saRoot->IoEventCount.agOSSA_IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED++;
ossaSSPEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, sspTag, 0,agNULL);
break;
}
case OSSA_IO_OPEN_CNX_ERROR_WRONG_DESTINATION:
{
SA_DBG1(("mpiSSPEvent: OSSA_IO_OPEN_CNX_ERROR_WRONG_DESTINATION tag 0x%x ssptag 0x%x\n", tag, sspTag));
saRoot->IoEventCount.agOSSA_IO_OPEN_CNX_ERROR_WRONG_DESTINATION++;
ossaSSPEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, sspTag, 0,agNULL);
break;
}
case OSSA_IO_XFER_ERROR_NAK_RECEIVED:
{
SA_DBG1(("mpiSSPEvent: OSSA_IO_XFER_ERROR_NAK_RECEIVED tag 0x%x ssptag 0x%x\n", tag, sspTag));
saRoot->IoEventCount.agOSSA_IO_XFER_ERROR_NAK_RECEIVED++;
ossaSSPEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, sspTag, 0,agNULL);
break;
}
case OSSA_IO_XFER_ERROR_ACK_NAK_TIMEOUT:
{
SA_DBG1(("mpiSSPEvent: OSSA_IO_XFER_ERROR_ACK_NAK_TIMEOUT tag 0x%x ssptag 0x%x\n", tag, sspTag));
saRoot->IoEventCount.agOSSA_IO_XFER_ERROR_ACK_NAK_TIMEOUT++;
ossaSSPEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, sspTag, 0,agNULL);
break;
}
case OSSA_IO_XFER_ERROR_OFFSET_MISMATCH:
{
SA_DBG1(("mpiSSPEvent: OSSA_IO_XFER_ERROR_OFFSET_MISMATCH tag 0x%x ssptag 0x%x\n", tag, sspTag));
#ifdef SA_ENABLE_PCI_TRIGGER
if( saRoot->swConfig.PCI_trigger & PCI_TRIGGER_OFFSET_MISMATCH )
{
siPCITriger(agRoot);
}
#endif /* SA_ENABLE_PCI_TRIGGER */
saRoot->IoEventCount.agOSSA_IO_XFER_ERROR_OFFSET_MISMATCH++;
ossaSSPEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, sspTag, 0,agNULL);
break;
}
case OSSA_IO_XFER_ERROR_XFER_ZERO_DATA_LEN:
{
SA_DBG1(("mpiSSPEvent: OSSA_IO_XFER_ERROR_XFER_ZERO_DATA_LEN tag 0x%x ssptag 0x%x\n", tag, sspTag));
saRoot->IoEventCount.agOSSA_IO_XFER_ERROR_XFER_ZERO_DATA_LEN++;
ossaSSPEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, sspTag, 0,agNULL);
break;
}
case OSSA_IO_XFER_ERROR_CMD_ISSUE_ACK_NAK_TIMEOUT:
{
SA_DBG1(("mpiSSPEvent: OSSA_IO_XFER_ERROR_CMD_ISSUE_ACK_NAK_TIMEOUT tag 0x%x ssptag 0x%x\n", tag, sspTag));
saRoot->IoEventCount.agOSSA_IO_XFER_ERROR_CMD_ISSUE_ACK_NAK_TIMEOUT++;
ossaSSPEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, sspTag, 0,agNULL);
break;
}
case OSSA_IO_XFER_OPEN_RETRY_TIMEOUT:
{
SA_DBG1(("mpiSSPEvent: OSSA_IO_XFER_OPEN_RETRY_TIMEOUT tag 0x%x ssptag 0x%x\n", tag, sspTag));
saRoot->IoEventCount.agOSSA_IO_XFER_OPEN_RETRY_TIMEOUT++;
ossaSSPEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, sspTag, 0,agNULL);
break;
}
case OSSA_IO_XFER_ERROR_XFER_RDY_OVERRUN:
{
SA_DBG1(("mpiSSPEvent: OSSA_IO_XFER_ERROR_XFER_RDY_OVERRUN tag 0x%x ssptag 0x%x\n", tag, sspTag));
saRoot->IoEventCount.agOSSA_IO_XFER_ERROR_XFER_RDY_OVERRUN++;
ossaSSPEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, sspTag, 0,agNULL);
break;
}
case OSSA_IO_XFER_ERROR_XFER_RDY_NOT_EXPECTED:
{
SA_DBG1(("mpiSSPEvent: OSSA_IO_XFER_ERROR_XFER_RDY_NOT_EXPECTED tag 0x%x ssptag 0x%x\n", tag, sspTag));
saRoot->IoEventCount.agOSSA_IO_XFER_ERROR_XFER_RDY_NOT_EXPECTED++;
ossaSSPEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, sspTag, 0,agNULL);
break;
}
case OSSA_IO_XFER_CMD_FRAME_ISSUED:
{
SA_DBG1(("mpiSSPEvent: OSSA_IO_XFER_CMD_FRAME_ISSUED tag 0x%x ssptag 0x%x\n", tag, sspTag));
saRoot->IoEventCount.agOSSA_IO_XFER_CMD_FRAME_ISSUED++;
ossaSSPEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, sspTag, 0,agNULL);
break;
}
case OSSA_IO_XFER_ERROR_UNEXPECTED_PHASE:
{
SA_DBG1(("mpiSSPEvent: OSSA_IO_XFER_ERROR_UNEXPECTED_PHASE tag 0x%x ssptag 0x%x\n", tag, sspTag));
saRoot->IoEventCount.agOSSA_IO_XFER_ERROR_UNEXPECTED_PHASE++;
ossaSSPEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, sspTag, 0,agNULL);
break;
}
case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED:
{
SA_DBG1(("mpiSSPEvent:OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED HTAG = 0x%x sspTag = 0x%x\n", tag, sspTag));
saRoot->IoEventCount.agOSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED++;
ossaSSPEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, sspTag, 0,agNULL);
break;
}
case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_TMO:
{
SA_DBG1(("mpiSSPEvent: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_TMO tag 0x%x ssptag 0x%x\n", tag, sspTag));
saRoot->IoEventCount.agOSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_TMO++;
ossaSSPEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, sspTag, 0,agNULL);
break;
}
case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST:
{
SA_DBG1(("mpiSSPEvent: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST tag 0x%x ssptag 0x%x\n", tag, sspTag));
saRoot->IoEventCount.agOSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST++;
ossaSSPEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, sspTag, 0,agNULL);
break;
}
case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE:
{
SA_DBG1(("mpiSSPEvent: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE tag 0x%x ssptag 0x%x\n", tag, sspTag));
saRoot->IoEventCount.agOSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE++;
ossaSSPEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, sspTag, 0,agNULL);
break;
}
case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED:
{
SA_DBG1(("mpiSSPEvent: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED tag 0x%x ssptag 0x%x\n", tag, sspTag));
saRoot->IoEventCount.agOSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED++;
ossaSSPEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, sspTag, 0,agNULL);
break;
}
case OSSA_IO_XFR_ERROR_DEK_KEY_CACHE_MISS:
{
SA_DBG1(("mpiSSPEvent: OSSA_IO_XFR_ERROR_DEK_KEY_CACHE_MISS tag 0x%x ssptag 0x%x\n", tag, sspTag));
saRoot->IoEventCount.agOSSA_IO_XFR_ERROR_DEK_KEY_CACHE_MISS++;
ossaSSPEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, sspTag, 0,agNULL);
break;
}
case OSSA_IO_XFR_ERROR_DEK_KEY_TAG_MISMATCH:
{
SA_DBG1(("mpiSSPEvent: OSSA_IO_XFR_ERROR_DEK_KEY_TAG_MISMATCH tag 0x%x ssptag 0x%x\n", tag, sspTag));
saRoot->IoEventCount.agOSSA_IO_XFR_ERROR_DEK_KEY_TAG_MISMATCH++;
ossaSSPEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, sspTag, 0,agNULL);
break;
}
case OSSA_IO_XFR_ERROR_INTERNAL_CRC_ERROR:
{
SA_DBG1(("mpiSSPEvent: OSSA_IO_XFR_ERROR_INTERNAL_CRC_ERROR HTAG = 0x%x\n", tag));
saRoot->IoEventCount.agOSSA_IO_XFR_ERROR_INTERNAL_CRC_ERROR++;
ossaSSPEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, sspTag, 0,agNULL);
break;
}
case OSSA_IO_XFR_ERROR_DIF_APPLICATION_TAG_MISMATCH:
{
SA_DBG1(("mpiSSPEvent: OSSA_IO_XFR_ERROR_DIF_APPLICATION_TAG_MISMATCH tag 0x%x ssptag 0x%x\n", tag, sspTag));
saRoot->IoEventCount.agOSSA_IO_XFR_ERROR_DIF_APPLICATION_TAG_MISMATCH++;
ossaSSPEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, sspTag,sizeof(agsaDifDetails_t),&Dif_details);
break;
}
case OSSA_IO_XFR_ERROR_DIF_REFERENCE_TAG_MISMATCH:
{
SA_DBG1(("mpiSSPEvent: OSSA_IO_XFR_ERROR_DIF_REFERENCE_TAG_MISMATCH tag 0x%x ssptag 0x%x\n", tag, sspTag));
saRoot->IoEventCount.agOSSA_IO_XFR_ERROR_DIF_REFERENCE_TAG_MISMATCH++;
ossaSSPEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, sspTag,sizeof(agsaDifDetails_t),&Dif_details);
break;
}
case OSSA_IO_XFR_ERROR_DIF_CRC_MISMATCH:
{
SA_DBG1(("mpiSSPEvent: OSSA_IO_XFR_ERROR_DIF_CRC_MISMATCH tag 0x%x ssptag 0x%x\n", tag, sspTag));
saRoot->IoEventCount.agOSSA_IO_XFR_ERROR_DIF_CRC_MISMATCH++;
ossaSSPEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, sspTag,sizeof(agsaDifDetails_t),&Dif_details);
break;
}
case OSSA_IO_XFR_ERROR_DIF_MISMATCH:
{
SA_DBG1(("mpiSSPEvent: OSSA_IO_XFR_ERROR_DIF_MISMATCH tag 0x%x ssptag 0x%x\n", tag, sspTag));
saRoot->IoEventCount.agOSSA_IO_XFR_ERROR_DIF_MISMATCH++;
ossaSSPEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, sspTag,sizeof(agsaDifDetails_t),&Dif_details);
break;
}
case OSSA_IO_XFER_ERR_EOB_DATA_OVERRUN:
{
SA_DBG1(("mpiSSPEvent: OSSA_IO_XFER_ERR_EOB_DATA_OVERRUN tag 0x%x ssptag 0x%x\n", tag, sspTag));
saRoot->IoEventCount.agOSSA_IO_XFER_ERR_EOB_DATA_OVERRUN++;
ossaSSPEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, sspTag, 0, agNULL);
break;
}
case OSSA_IO_XFER_READ_COMPL_ERR:
{
SA_DBG1(("mpiSSPEvent: OSSA_IO_XFER_READ_COMPL_ERR tag 0x%x ssptag 0x%x\n", tag, sspTag));
saRoot->IoEventCount.agOSSA_IO_XFER_READ_COMPL_ERR++;
ossaSSPEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, sspTag, 0, agNULL);
break;
}
default:
{
SA_DBG1(("mpiSSPEvent: Unknown Event 0x%x tag 0x%x ssptag 0x%x\n", event, tag, sspTag));
saRoot->IoEventCount.agOSSA_IO_UNKNOWN_ERROR++;
ossaSSPEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, sspTag, 0,agNULL);
break;
}
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "2u");
/* return value */
return ret;
}
/******************************************************************************/
/*! \brief SPC MPI SATA Event
*
* This function handles the SATA Event.
*
* \param agRoot Handles for this instance of SAS/SATA LLL
* \param pIomb pointer of Message
*
* \return The read value
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiSATAEvent(
agsaRoot_t *agRoot,
agsaSATAEventRsp_t *pIomb
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaIORequestDesc_t *pRequest = agNULL;
agsaPortContext_t *agPortContext;
agsaDevHandle_t *agDevHandle;
agsaDeviceDesc_t *pDevice;
bit32 deviceIdx, portId_tmp, event, tag, deviceId;
bit8 portId;
smTraceFuncEnter(hpDBG_VERY_LOUD,"2w");
/* get port context */
OSSA_READ_LE_32(AGROOT, &portId_tmp, pIomb, OSSA_OFFSET_OF(agsaSATAEventRsp_t, portId));
OSSA_READ_LE_32(AGROOT, &deviceId, pIomb, OSSA_OFFSET_OF(agsaSATAEventRsp_t, deviceId));
OSSA_READ_LE_32(AGROOT, &event, pIomb, OSSA_OFFSET_OF(agsaSATAEventRsp_t, event));
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaSATAEventRsp_t, tag));
if (OSSA_IO_XFER_ERROR_ABORTED_NCQ_MODE != event)
{
/* get IORequest from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
}
/* get port context - only for OSSA_IO_XFER_ERROR_ABORTED_NCQ_MODE */
portId = (bit8)(portId_tmp & PORTID_MASK);
SA_DBG2(("mpiSATAEvent:PortID 0x%x PortStatus 0x%x PortContext %p\n",saRoot->PortMap[portId & PORTID_MASK].PortID,saRoot->PortMap[portId & PORTID_MASK].PortStatus,saRoot->PortMap[portId & PORTID_MASK].PortContext));
agPortContext = (agsaPortContext_t *)saRoot->PortMap[portId].PortContext;
/* get device Id - only for OSSA_IO_XFER_ERROR_ABORTED_NCQ_MODE*/
deviceIdx = deviceId & DEVICE_ID_BITS;
OS_ASSERT(deviceIdx < MAX_IO_DEVICE_ENTRIES, "deviceIdx MAX_IO_DEVICE_ENTRIES");
/* find device handle from device index */
pDevice = (agsaDeviceDesc_t *)saRoot->DeviceMap[deviceIdx].DeviceHandle;
agDevHandle = &(pDevice->targetDevHandle);
/* get event */
switch (event)
{
case OSSA_IO_OVERFLOW:
{
SA_DBG1(("mpiSATAEvent: OSSA_IO_OVERFLOW HTAG = 0x%x\n", tag));
saRoot->IoEventCount.agOSSA_IO_OVERFLOW++;
ossaSATAEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, 0, agNULL);
break;
}
case OSSA_IO_XFER_ERROR_BREAK:
{
SA_DBG1(("mpiSATAEvent: OSSA_IO_XFER_ERROR_BREAK HTAG = 0x%x\n", tag));
saRoot->IoEventCount.agOSSA_IO_XFER_ERROR_BREAK++;
ossaSATAEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, 0, agNULL);
break;
}
case OSSA_IO_XFER_ERROR_PHY_NOT_READY:
{
SA_DBG1(("mpiSATAEvent: OSSA_IO_XFER_ERROR_PHY_NOT_READY HTAG = 0x%x\n", tag));
saRoot->IoEventCount.agOSSA_IO_XFER_ERROR_PHY_NOT_READY++;
ossaSATAEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, 0, agNULL);
break;
}
case OSSA_IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED:
{
SA_DBG1(("mpiSATAEvent: OSSA_IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED HTAG = 0x%x\n", tag));
saRoot->IoEventCount.agOSSA_IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED++;
ossaSATAEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, 0, agNULL);
break;
}
case OSSA_IO_OPEN_CNX_ERROR_ZONE_VIOLATION:
{
SA_DBG1(("mpiSATAEvent: OSSA_IO_OPEN_CNX_ERROR_ZONE_VIOLATION HTAG = 0x%x\n", tag));
saRoot->IoEventCount.agOSSA_IO_OPEN_CNX_ERROR_ZONE_VIOLATION++;
ossaSATAEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, 0, agNULL);
break;
}
case OSSA_IO_OPEN_CNX_ERROR_BREAK:
{
SA_DBG1(("mpiSATAEvent: OSSA_IO_OPEN_CNX_ERROR_BREAK HTAG = 0x%x\n", tag));
saRoot->IoEventCount.agOSSA_IO_OPEN_CNX_ERROR_BREAK++;
ossaSATAEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, 0, agNULL);
break;
}
case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST:
{
SA_DBG1(("mpiSATAEvent: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST HTAG = 0x%x\n", tag));
saRoot->IoEventCount.agOSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST++;
ossaSATAEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, 0, agNULL);
break;
}
case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE:
{
SA_DBG1(("mpiSATAEvent: HTAG = 0x%x\n", tag));
saRoot->IoEventCount.agOSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE++;
ossaSATAEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, 0, agNULL);
break;
}
case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED:
{
SA_DBG1(("mpiSATAEvent:OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED HTAG = 0x%x\n", tag));
saRoot->IoEventCount.agOSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED++;
ossaSATAEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, 0, agNULL);
break;
}
case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS:
{
SA_DBG1(("mpiSATAEvent: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS HTAG = 0x%x\n", tag));
saRoot->IoEventCount.agOSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS++;
ossaSATAEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, 0, agNULL);
break;
}
case OSSA_IO_OPEN_CNX_ERROR_BAD_DESTINATION:
{
SA_DBG1(("mpiSATAEvent: OSSA_IO_OPEN_CNX_ERROR_BAD_DESTINATION HTAG = 0x%x\n", tag));
saRoot->IoEventCount.agOSSA_IO_OPEN_CNX_ERROR_BAD_DESTINATION++;
ossaSATAEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, 0, agNULL);
break;
}
case OSSA_IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED:
{
SA_DBG1(("mpiSATAEvent: OSSA_IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED HTAG = 0x%x\n", tag));
saRoot->IoEventCount.agOSSA_IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED++;
ossaSATAEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, 0, agNULL);
break;
}
case OSSA_IO_OPEN_CNX_ERROR_WRONG_DESTINATION:
{
SA_DBG1(("mpiSATAEvent: OSSA_IO_OPEN_CNX_ERROR_WRONG_DESTINATION HTAG = 0x%x\n", tag));
saRoot->IoEventCount.agOSSA_IO_OPEN_CNX_ERROR_WRONG_DESTINATION++;
ossaSATAEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, 0, agNULL);
break;
}
case OSSA_IO_XFER_ERROR_NAK_RECEIVED:
{
SA_DBG1(("mpiSATAEvent: OSSA_IO_XFER_ERROR_NAK_RECEIVED HTAG = 0x%x\n", tag));
saRoot->IoEventCount.agOSSA_IO_XFER_ERROR_NAK_RECEIVED++;
ossaSATAEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, 0, agNULL);
break;
}
case OSSA_IO_XFER_ERROR_ABORTED_NCQ_MODE:
{
SA_DBG1(("mpiSATAEvent: OSSA_IO_XFER_ERROR_ABORTED_NCQ_MODE HTAG = 0x%x\n", tag));
saRoot->IoEventCount.agOSSA_IO_XFER_ERROR_ABORTED_NCQ_MODE++;
ossaSATAEvent(agRoot, agNULL, agPortContext, agDevHandle, event, 0, agNULL);
break;
}
case OSSA_IO_XFER_ERROR_OFFSET_MISMATCH:
{
SA_DBG1(("mpiSATAEvent: OSSA_IO_XFER_ERROR_OFFSET_MISMATCH HTAG = 0x%x\n", tag));
saRoot->IoEventCount.agOSSA_IO_XFER_ERROR_OFFSET_MISMATCH++;
ossaSATAEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, 0, agNULL);
break;
}
case OSSA_IO_XFER_ERROR_XFER_ZERO_DATA_LEN:
{
SA_DBG1(("mpiSATAEvent: OSSA_IO_XFER_ERROR_XFER_ZERO_DATA_LEN HTAG = 0x%x\n", tag));
saRoot->IoEventCount.agOSSA_IO_XFER_ERROR_XFER_ZERO_DATA_LEN++;
ossaSATAEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, 0, agNULL);
break;
}
case OSSA_IO_XFER_OPEN_RETRY_TIMEOUT:
{
SA_DBG1(("mpiSATAEvent: OSSA_IO_XFER_OPEN_RETRY_TIMEOUT HTAG = 0x%x\n", tag));
saRoot->IoEventCount.agOSSA_IO_XFER_OPEN_RETRY_TIMEOUT++;
ossaSATAEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, 0, agNULL);
break;
}
case OSSA_IO_XFER_ERROR_PEER_ABORTED:
{
SA_DBG1(("mpiSATAEvent: OSSA_IO_XFER_ERROR_PEER_ABORTED HTAG = 0x%x\n", tag));
saRoot->IoEventCount.agOSSA_IO_XFER_ERROR_PEER_ABORTED++;
ossaSATAEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, 0, agNULL);
break;
}
case OSSA_IO_XFER_CMD_FRAME_ISSUED:
{
SA_DBG1(("mpiSATAEvent: OSSA_IO_XFER_CMD_FRAME_ISSUED HTAG = 0x%x\n", tag));
saRoot->IoEventCount.agOSSA_IO_XFER_CMD_FRAME_ISSUED++;
ossaSATAEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, 0, agNULL);
break;
}
case OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY:
{
SA_DBG1(("mpiSATAEvent, OSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY HTAG = 0x%x\n", tag));
saRoot->IoEventCount.agOSSA_IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY++;
ossaSATAEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, 0, agNULL);
break;
}
case OSSA_IO_XFER_ERROR_UNEXPECTED_PHASE:
{
SA_DBG1(("mpiSATAEvent, OSSA_IO_XFER_ERROR_UNEXPECTED_PHASE HTAG = 0x%x\n", tag));
saRoot->IoEventCount.agOSSA_IO_XFER_ERROR_UNEXPECTED_PHASE++;
ossaSATAEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, 0, agNULL);
break;
}
case OSSA_IO_XFER_ERROR_XFER_RDY_OVERRUN:
{
SA_DBG1(("mpiSATAEvent, OSSA_IO_XFER_ERROR_XFER_RDY_OVERRUN HTAG = 0x%x\n", tag));
saRoot->IoEventCount.agOSSA_IO_XFER_ERROR_XFER_RDY_OVERRUN++;
ossaSATAEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, 0, agNULL);
break;
}
case OSSA_IO_XFER_ERROR_XFER_RDY_NOT_EXPECTED:
{
SA_DBG1(("mpiSATAEvent, OSSA_IO_XFER_ERROR_XFER_RDY_NOT_EXPECTED HTAG = 0x%x\n", tag));
saRoot->IoEventCount.agOSSA_IO_XFER_ERROR_XFER_RDY_NOT_EXPECTED++;
ossaSATAEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, 0, agNULL);
break;
}
case OSSA_IO_XFER_PIO_SETUP_ERROR:
{
SA_DBG1(("mpiSATAEvent: OSSA_IO_XFER_PIO_SETUP_ERROR HTAG = 0x%x\n", tag));
saRoot->IoEventCount.agOSSA_IO_XFER_PIO_SETUP_ERROR++;
ossaSATAEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, 0, agNULL);
break;
}
case OSSA_IO_XFR_ERROR_DIF_MISMATCH:
{
SA_DBG1(("mpiSATAEvent: OSSA_IO_XFR_ERROR_DIF_MISMATCH HTAG = 0x%x\n", tag));
saRoot->IoEventCount.agOSSA_IO_XFR_ERROR_DIF_MISMATCH++;
ossaSATAEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, 0, agNULL);
break;
}
case OSSA_IO_XFR_ERROR_INTERNAL_CRC_ERROR:
{
SA_DBG1(("mpiSATAEvent: OSSA_IO_XFR_ERROR_INTERNAL_CRC_ERROR HTAG = 0x%x\n", tag));
saRoot->IoEventCount.agOSSA_IO_XFR_ERROR_INTERNAL_CRC_ERROR++;
ossaSATAEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, 0, agNULL);
break;
}
case OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED:
{
SA_DBG1(("mpiSATAEvent: OSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED HTAG = 0x%x\n", tag));
saRoot->IoEventCount.agOSSA_IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED++;
ossaSATAEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, 0, agNULL);
break;
}
case OSSA_IO_XFER_ERR_EOB_DATA_OVERRUN:
{
SA_DBG1(("mpiSATAEvent: OSSA_IO_XFER_ERR_EOB_DATA_OVERRUN HTAG = 0x%x\n", tag));
saRoot->IoEventCount.agOSSA_IO_XFER_ERR_EOB_DATA_OVERRUN++;
ossaSATAEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, 0, agNULL);
break;
}
case OSSA_IO_XFER_ERROR_DMA_ACTIVATE_TIMEOUT:
{
SA_DBG1(("mpiSATAEvent: OSSA_IO_XFER_ERROR_DMA_ACTIVATE_TIMEOUT HTAG = 0x%x\n", tag));
saRoot->IoEventCount.agOSSA_IO_XFER_ERROR_DMA_ACTIVATE_TIMEOUT++;
ossaSATAEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, 0, agNULL);
break;
}
default:
{
SA_DBG1(("mpiSATAEvent: Unknown Event 0x%x HTAG = 0x%x\n", event, tag));
saRoot->IoEventCount.agOSSA_IO_UNKNOWN_ERROR++;
ossaSATAEvent(agRoot, pRequest->pIORequestContext, agPortContext, agDevHandle, event, 0, agNULL);
break;
}
}
/* return value */
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2w");
return ret;
}
/******************************************************************************/
/*! \brief Set NVM Data Response
*
* This routine handles the response of SET NVM Data Response
*
* \param agRoot Handles for this instance of SAS/SATA LLL
* \param pIomb Pointer of IOMB Mesage
*
* \return sucess or fail
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiSetNVMDataRsp(
agsaRoot_t *agRoot,
agsaSetNVMDataRsp_t *pIomb
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
agsaContext_t *agContext;
bit32 tag, status, iPTdaBnDpsAsNvm;
smTraceFuncEnter(hpDBG_VERY_LOUD,"2x");
SA_DBG1(("mpiSetNVMDataRsp: HTag=0x%x\n", pIomb->tag));
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaSetNVMDataRsp_t, tag));
OSSA_READ_LE_32(AGROOT, &iPTdaBnDpsAsNvm, pIomb, OSSA_OFFSET_OF(agsaSetNVMDataRsp_t, iPTdaBnDpsAsNvm));
OSSA_READ_LE_32(AGROOT, &status, pIomb, OSSA_OFFSET_OF(agsaSetNVMDataRsp_t, status));
/* get request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
if (agNULL == pRequest)
{
SA_DBG1(("mpiSetNVMDataRsp: Bad Response IOMB!!! pRequest is NULL. TAG=0x%x STATUS=0x%x\n", tag, status));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2x");
return AGSA_RC_FAILURE;
}
agContext = saRoot->IOMap[tag].agContext;
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
SA_ASSERT((pRequest->valid), "pRequest->valid");
if (((iPTdaBnDpsAsNvm & NVMD_TYPE) == AGSA_NVMD_CONFIG_SEEPROM) ||
((iPTdaBnDpsAsNvm & NVMD_TYPE) == AGSA_NVMD_VPD_FLASH) ||
((iPTdaBnDpsAsNvm & NVMD_TYPE) == AGSA_NVMD_TWI_DEVICES))
{
/* CB for VPD for SEEPROM-0, VPD_FLASH and TWI */
ossaSetNVMDResponseCB(agRoot, agContext, (status & NVMD_STAT));
}
else
{
/* should not happend */
SA_DBG1(("mpiSetNVMDataRsp: NVMD is wrong. TAG=0x%x STATUS=0x%x\n", tag, (iPTdaBnDpsAsNvm & NVMD_TYPE)));
ret = AGSA_RC_FAILURE;
}
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
/* return value */
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "2x");
return ret;
}
/******************************************************************************/
/*! \brief SPC MPI SSP ABORT Response
*
* This function handles the SSP Abort Response.
*
* \param agRoot Handles for this instance of SAS/SATA LLL
* \param pIomb pointer of Message
*
* \return The read value
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiSSPAbortRsp(
agsaRoot_t *agRoot,
agsaSSPAbortRsp_t *pIomb
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
agsaDeviceDesc_t *pDevice;
bit32 tag, status, scope;
smTraceFuncEnter(hpDBG_VERY_LOUD,"2y");
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaSSPAbortRsp_t, tag));
OSSA_READ_LE_32(AGROOT, &status, pIomb, OSSA_OFFSET_OF(agsaSSPAbortRsp_t, status));
OSSA_READ_LE_32(AGROOT, &scope, pIomb, OSSA_OFFSET_OF(agsaSSPAbortRsp_t, scp));
scope &= 3;
/* get IORequest from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
if (agNULL == pRequest)
{
/* remove the SSP_ABORT or SATA_ABORT request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
SA_ASSERT((pRequest), "pRequest");
SA_DBG1(("mpiSSPAbortRsp: the request is NULL. Tag=%x\n", tag));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2y");
return AGSA_RC_FAILURE;
}
if ( agTRUE == pRequest->valid )
{
pDevice = pRequest->pDevice;
SA_ASSERT((pRequest->pDevice), "pRequest->pDevice");
SA_DBG3(("mpiSSPAbortRsp: request abort is valid Htag 0x%x\n", tag));
/* remove the SSP_ABORT or SATA_ABORT request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
if( pRequest->completionCB == agNULL )
{
ossaSSPAbortCB(agRoot, pRequest->pIORequestContext, scope, status);
}
else
{
(*(ossaGenericAbortCB_t)(pRequest->completionCB))(agRoot, pRequest->pIORequestContext, scope, status);
}
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
/* Delete the request from the pendingIORequests */
saLlistIORemove(&(pDevice->pendingIORequests), &(pRequest->linkNode));
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiSSPAbortRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
if(scope)
{
siCountActiveIORequestsOnDevice( agRoot, pDevice->DeviceMapIndex );
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
}
else
{
ret = AGSA_RC_FAILURE;
SA_DBG1(("mpiSSPAbortRsp: the request is not valid any more. Tag=%x\n", pRequest->HTag));
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "2y");
return ret;
}
/******************************************************************************/
/*! \brief SPC MPI SATA ABORT Response
*
* This function handles the SATA Event.
*
* \param agRoot Handles for this instance of SAS/SATA LLL
* \param pIomb pointer of Message
*
* \return The read value
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiSATAAbortRsp(
agsaRoot_t *agRoot,
agsaSATAAbortRsp_t *pIomb
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
agsaDeviceDesc_t *pDevice;
bit32 tag, status, scope;
smTraceFuncEnter(hpDBG_VERY_LOUD,"3B");
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaSATAAbortRsp_t, tag));
OSSA_READ_LE_32(AGROOT, &status, pIomb, OSSA_OFFSET_OF(agsaSATAAbortRsp_t, status));
OSSA_READ_LE_32(AGROOT, &scope, pIomb, OSSA_OFFSET_OF(agsaSATAAbortRsp_t, scp));
/* get IORequest from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
if (agNULL == pRequest)
{
/* remove the SSP_ABORT or SATA_ABORT request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
SA_DBG1(("mpiSATAAbortRsp: the request is NULL. Tag=%x\n", tag));
SA_ASSERT((pRequest), "pRequest");
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "3B");
return AGSA_RC_FAILURE;
}
if ( agTRUE == pRequest->valid )
{
pDevice = pRequest->pDevice;
SA_ASSERT((pRequest->pDevice), "pRequest->pDevice");
SA_DBG3(("mpiSATAAbortRsp: request abort is valid Htag 0x%x\n", tag));
if( pRequest->completionCB == agNULL )
{
ossaSATAAbortCB(agRoot, pRequest->pIORequestContext, scope, status);
}
else
{
(*(ossaGenericAbortCB_t)(pRequest->completionCB))(agRoot, pRequest->pIORequestContext, scope, status);
}
/* remove the SATA_ABORT request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
/* Delete the request from the pendingIORequests */
saLlistIORemove(&(pDevice->pendingIORequests), &(pRequest->linkNode));
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
}
else
{
ret = AGSA_RC_FAILURE;
SA_DBG1(("mpiSATAAbortRsp: the request is not valid any more. Tag=%x\n", pRequest->HTag));
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "3B");
return ret;
}
/******************************************************************************/
/*! \brief Set GPIO Response
*
* This routine handles the response of GPIO Command
*
* \param agRoot Handles for this instance of SAS/SATA LLL
* \param pIomb Pointer of IOMB Mesage
*
* \return sucess or fail
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiGPIORsp(
agsaRoot_t *agRoot,
agsaGPIORsp_t *pIomb
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaContext_t *agContext;
agsaIORequestDesc_t *pRequest;
agsaGpioPinSetupInfo_t pinSetupInfo;
agsaGpioEventSetupInfo_t eventSetupInfo;
bit32 GpioIe, OT11_0, OT19_12, GPIEVChange, GPIEVFall, GPIEVRise, GpioRdVal, tag;
smTraceFuncEnter(hpDBG_VERY_LOUD,"5C");
SA_DBG3(("mpiGPIORsp: HTag=0x%x\n", pIomb->tag));
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaGPIORsp_t, tag));
/* get request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
if (agNULL == pRequest)
{
SA_DBG1(("mpiGPIORsp: Bad Response IOMB!!! pRequest is NULL. TAG=0x%x\n", tag));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "5C");
return AGSA_RC_FAILURE;
}
agContext = saRoot->IOMap[tag].agContext;
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
SA_ASSERT((pRequest->valid), "pRequest->valid");
/* set payload to zeros */
si_memset(&pinSetupInfo, 0, sizeof(agsaGpioPinSetupInfo_t));
si_memset(&eventSetupInfo, 0, sizeof(agsaGpioEventSetupInfo_t));
OSSA_READ_LE_32(AGROOT, &GpioIe, pIomb, OSSA_OFFSET_OF(agsaGPIORsp_t, GpioIe));
OSSA_READ_LE_32(AGROOT, &OT11_0, pIomb, OSSA_OFFSET_OF(agsaGPIORsp_t, OT11_0));
OSSA_READ_LE_32(AGROOT, &OT19_12, pIomb, OSSA_OFFSET_OF(agsaGPIORsp_t, OT19_12));
OSSA_READ_LE_32(AGROOT, &GPIEVChange, pIomb, OSSA_OFFSET_OF(agsaGPIORsp_t, GPIEVChange));
OSSA_READ_LE_32(AGROOT, &GPIEVFall, pIomb, OSSA_OFFSET_OF(agsaGPIORsp_t, GPIEVFall));
OSSA_READ_LE_32(AGROOT, &GPIEVRise, pIomb, OSSA_OFFSET_OF(agsaGPIORsp_t, GPIEVRise));
OSSA_READ_LE_32(AGROOT, &GpioRdVal, pIomb, OSSA_OFFSET_OF(agsaGPIORsp_t, GpioRdVal));
pinSetupInfo.gpioInputEnabled = GpioIe;
pinSetupInfo.gpioTypePart1 = OT11_0;
pinSetupInfo.gpioTypePart2 = OT19_12;
eventSetupInfo.gpioEventLevel = GPIEVChange;
eventSetupInfo.gpioEventFallingEdge = GPIEVFall;
eventSetupInfo.gpioEventRisingEdge = GPIEVRise;
ossaGpioResponseCB(agRoot, agContext, OSSA_IO_SUCCESS, GpioRdVal,
&pinSetupInfo,
&eventSetupInfo);
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiGPIORsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
/* return value */
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "5C");
return ret;
}
/******************************************************************************/
/*! \brief Set GPIO Event Response
*
* This routine handles the response of GPIO Event
*
* \param agRoot Handles for this instance of SAS/SATA LLL
* \param pIomb Pointer of IOMB Mesage
*
* \return sucess or fail
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiGPIOEventRsp(
agsaRoot_t *agRoot,
agsaGPIOEvent_t *pIomb
)
{
bit32 ret = AGSA_RC_SUCCESS;
bit32 GpioEvent;
smTraceFuncEnter(hpDBG_VERY_LOUD,"3D");
OSSA_READ_LE_32(AGROOT, &GpioEvent, pIomb, OSSA_OFFSET_OF(agsaGPIOEvent_t, GpioEvent));
ossaGpioEvent(agRoot, GpioEvent);
/* return value */
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "3D");
return ret;
}
/******************************************************************************/
/*! \brief SAS Diagnostic Start/End Response
*
* This routine handles the response of SAS Diagnostic Start/End Command
*
* \param agRoot Handles for this instance of SAS/SATA LLL
* \param pIomb Pointer of IOMB Mesage
*
* \return sucess or fail
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiSASDiagStartEndRsp(
agsaRoot_t *agRoot,
agsaSASDiagStartEndRsp_t *pIomb
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
agsaContext_t *agContext;
bit32 tag, Status;
smTraceFuncEnter(hpDBG_VERY_LOUD,"2F");
SA_DBG3(("mpiSASDiagStartEndRsp: HTAG=0x%x\n", pIomb->tag));
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaSASDiagStartEndRsp_t, tag));
OSSA_READ_LE_32(AGROOT, &Status, pIomb, OSSA_OFFSET_OF(agsaSASDiagStartEndRsp_t, Status));
/* get request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
if (agNULL == pRequest)
{
SA_DBG1(("mpiSASDiagStartEndRsp: Bad Response IOMB!!! pRequest is NULL. TAG=0x%x STATUS=0x%x\n", tag, Status));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2F");
return AGSA_RC_FAILURE;
}
agContext = saRoot->IOMap[tag].agContext;
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
SA_ASSERT((pRequest->valid), "pRequest->valid");
switch(Status)
{
case OSSA_DIAG_SE_SUCCESS:
SA_DBG3(("mpiSASDiagStartEndRsp: Status OSSA_DIAG_SE_SUCCESS 0x%X \n", Status));
break;
case OSSA_DIAG_SE_INVALID_PHY_ID:
SA_DBG1(("mpiSASDiagStartEndRsp: Status OSSA_DIAG_SE_INVALID_PHY_ID 0x%X \n", Status));
break;
case OSSA_DIAG_PHY_NOT_DISABLED:
SA_DBG1(("mpiSASDiagStartEndRsp: Status OSSA_DIAG_PHY_NOT_DISABLED Status 0x%X \n", Status));
break;
case OSSA_DIAG_OTHER_FAILURE:
if(smIS_SPCV(agRoot))
{
SA_DBG1(("mpiSASDiagStartEndRsp: Status OSSA_DIAG_OTHER_FAILURE Status 0x%X \n", Status));
}
else
{
SA_DBG1(("mpiSASDiagStartEndRsp: Status OSSA_DIAG_OPCODE_INVALID Status 0x%X \n", Status));
}
break;
default:
SA_DBG1(("mpiSASDiagStartEndRsp:Status UNKNOWN 0x%X \n", Status));
break;
}
ossaSASDiagStartEndCB(agRoot, agContext, Status);
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiSASDiagStartEndRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
/* return value */
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "2F");
return ret;
}
/******************************************************************************/
/*! \brief SAS Diagnostic Execute Response
*
* This routine handles the response of SAS Diagnostic Execute Command
*
* \param agRoot Handles for this instance of SAS/SATA LLL
* \param pIomb Pointer of IOMB Mesage
*
* \return sucess or fail
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiSASDiagExecuteRsp(
agsaRoot_t *agRoot,
agsaSASDiagExecuteRsp_t *pIomb
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
agsaContext_t *agContext;
bit32 tag, Status, CmdTypeDescPhyId, ReportData;
smTraceFuncEnter(hpDBG_VERY_LOUD,"3G");
SA_DBG3(("mpiSASDiagExecuteRsp: HTAG=0x%x\n", pIomb->tag));
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaSASDiagExecuteRsp_t, tag));
OSSA_READ_LE_32(AGROOT, &Status, pIomb, OSSA_OFFSET_OF(agsaSASDiagExecuteRsp_t, Status));
OSSA_READ_LE_32(AGROOT, &CmdTypeDescPhyId, pIomb, OSSA_OFFSET_OF(agsaSASDiagExecuteRsp_t, CmdTypeDescPhyId));
OSSA_READ_LE_32(AGROOT, &ReportData, pIomb, OSSA_OFFSET_OF(agsaSASDiagExecuteRsp_t, ReportData));
/* get request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
if (agNULL == pRequest)
{
SA_DBG1(("mpiSASDiagExecuteRsp: Bad Response IOMB!!! pRequest is NULL.TAG=0x%x STATUS=0x%x\n", tag, Status));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "3G");
return AGSA_RC_FAILURE;
}
switch(Status)
{
case OSSA_DIAG_SUCCESS:
SA_DBG3(("mpiSASDiagExecuteRsp: Status OSSA_DIAG_SUCCESS 0x%X \n", Status));
break;
case OSSA_DIAG_INVALID_COMMAND:
if(smIS_SPCV(agRoot))
{
SA_DBG1(("mpiSASDiagExecuteRsp: Status OSSA_DIAG_INVALID_COMMAND Status 0x%X \n", Status));
}
else
{
SA_DBG1(("mpiSASDiagExecuteRsp: Status OSSA_DIAG_FAIL Status 0x%X \n", Status));
}
break;
case OSSA_REGISTER_ACCESS_TIMEOUT:
SA_DBG1(("mpiSASDiagExecuteRsp: Status OSSA_REGISTER_ACCESS_TIMEOUT Status 0x%X \n", Status));
break;
case OSSA_DIAG_NOT_IN_DIAGNOSTIC_MODE:
SA_DBG1(("mpiSASDiagExecuteRsp: Status OSSA_DIAG_NOT_IN_DIAGNOSTIC_MODE Status 0x%X \n", Status));
break;
case OSSA_DIAG_INVALID_PHY:
SA_DBG1(("mpiSASDiagExecuteRsp: Status OSSA_DIAG_INVALID_PHY Status 0x%X \n", Status));
break;
case OSSA_MEMORY_ALLOC_FAILURE:
SA_DBG1(("mpiSASDiagExecuteRsp: Status Status 0x%X \n", Status));
break;
default:
SA_DBG1(("mpiSASDiagExecuteRsp:Status UNKNOWN 0x%X \n", Status));
break;
}
agContext = saRoot->IOMap[tag].agContext;
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
SA_ASSERT((pRequest->valid), "pRequest->valid");
ossaSASDiagExecuteCB(agRoot, agContext, Status, CmdTypeDescPhyId, ReportData);
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiSASDiagExecuteRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "3G");
/* return value */
return ret;
}
/******************************************************************************/
/*! \brief SAS General Event Notification Response
*
* This routine handles the response of Inbound IOMB Command with error case
*
* \param agRoot Handles for this instance of SAS/SATA LLL
* \param pIomb Pointer of IOMB Mesage
*
* \return sucess or fail
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiGeneralEventRsp(
agsaRoot_t *agRoot,
agsaGeneralEventRsp_t *pIomb
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
bit32 i;
bit32 status;
bit32 tag;
agsaIORequestDesc_t *pRequest;
agsaDeviceDesc_t *pDevice;
agsaContext_t *agContext = NULL;
agsaGeneralEventRsp_t GenEventData;
agsaHWEventEncrypt_t agEvent;
bit16 OpCode = 0;
smTraceFuncEnter(hpDBG_VERY_LOUD,"3H");
si_memset(&GenEventData,0,sizeof(agsaGeneralEventRsp_t));
OSSA_READ_LE_32(AGROOT, &status, pIomb, OSSA_OFFSET_OF(agsaGeneralEventRsp_t, status));
SA_DBG3(("mpiGeneralEventRsp: %p\n", pIomb));
SA_DBG1(("mpiGeneralEventRsp: OpCode 0x%X status 0x%x\n",pIomb->inbIOMBpayload[0] & OPCODE_BITS, status));
for (i = 0; i < GENERAL_EVENT_PAYLOAD; i++)
{
OSSA_READ_LE_32(AGROOT, &GenEventData.inbIOMBpayload[i], pIomb, OSSA_OFFSET_OF(agsaGeneralEventRsp_t,inbIOMBpayload[i] ));
}
SA_DBG1(("mpiGeneralEventRsp: inbIOMBpayload 0x%08x 0x%08x 0x%08x 0x%08x\n",
GenEventData.inbIOMBpayload[0],GenEventData.inbIOMBpayload[1],
GenEventData.inbIOMBpayload[2],GenEventData.inbIOMBpayload[3] ));
SA_DBG1(("mpiGeneralEventRsp: inbIOMBpayload 0x%08x 0x%08x 0x%08x 0x%08x\n",
GenEventData.inbIOMBpayload[4],GenEventData.inbIOMBpayload[8],
GenEventData.inbIOMBpayload[6],GenEventData.inbIOMBpayload[7] ));
switch (status) /*status */
{
case GEN_EVENT_IOMB_V_BIT_NOT_SET:
SA_DBG1(("mpiGeneralEventRsp: GEN_EVENT_IOMB_V_BIT_NOT_SET\n" ));
break;
case GEN_EVENT_INBOUND_IOMB_OPC_NOT_SUPPORTED:
SA_DBG1(("mpiGeneralEventRsp: GEN_EVENT_INBOUND_IOMB_OPC_NOT_SUPPORTED\n" ));
break;
case GEN_EVENT_IOMB_INVALID_OBID:
SA_DBG1(("mpiGeneralEventRsp: GEN_EVENT_IOMB_INVALID_OBID\n" ));
break;
case GEN_EVENT_DS_IN_NON_OPERATIONAL:
SA_DBG1(("mpiGeneralEventRsp: GEN_EVENT_DS_IN_NON_OPERATIONAL\n" ));
break;
case GEN_EVENT_DS_IN_RECOVERY:
SA_DBG1(("mpiGeneralEventRsp: GEN_EVENT_DS_IN_RECOVERY\n" ));
break;
case GEN_EVENT_DS_INVALID:
SA_DBG1(("mpiGeneralEventRsp: GEN_EVENT_DS_INVALID\n" ));
break;
case GEN_EVENT_IO_XFER_READ_COMPL_ERR:
SA_DBG1(("mpiGeneralEventRsp: GEN_EVENT_IO_XFER_READ_COMPL_ERR 0x%x 0x%x 0x%x\n",
GenEventData.inbIOMBpayload[0],
GenEventData.inbIOMBpayload[1],
GenEventData.inbIOMBpayload[1] ));
ossaGeneralEvent(agRoot, status, agContext, GenEventData.inbIOMBpayload);
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "3H");
return(ret);
default:
SA_DBG1(("mpiGeneralEventRsp: Unknown General Event status!!! 0x%x\n", status));
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "3H");
return AGSA_RC_FAILURE;
}
OpCode = (bit16)(GenEventData.inbIOMBpayload[0] & OPCODE_BITS);
tag = GenEventData.inbIOMBpayload[1];
SA_DBG1(("mpiGeneralEventRsp:OpCode 0x%X [0] 0x%08x\n" ,OpCode,(bit16)(GenEventData.inbIOMBpayload[0] & OPCODE_BITS)));
switch (OpCode) /* OpCode */
{
case OPC_INB_DEV_HANDLE_ACCEPT:
case OPC_INB_ECHO:
case OPC_INB_FW_FLASH_UPDATE:
case OPC_INB_GET_NVMD_DATA:
case OPC_INB_SET_NVMD_DATA:
case OPC_INB_DEREG_DEV_HANDLE:
case OPC_INB_SPC_GET_DEV_INFO:
case OPC_INB_GET_DEV_HANDLE:
case OPC_INB_SPC_REG_DEV:
case OPC_INB_SAS_DIAG_EXECUTE:
case OPC_INB_SAS_DIAG_MODE_START_END:
case OPC_INB_PHYSTART:
case OPC_INB_PHYSTOP:
case OPC_INB_LOCAL_PHY_CONTROL:
case OPC_INB_GPIO:
case OPC_INB_GET_TIME_STAMP:
case OPC_INB_PORT_CONTROL:
case OPC_INB_SET_DEVICE_STATE:
case OPC_INB_GET_DEVICE_STATE:
case OPC_INB_SET_DEV_INFO:
// case OPC_INB_PCIE_DIAG_EXECUTE:
case OPC_INB_SAS_HW_EVENT_ACK:
case OPC_INB_SAS_RE_INITIALIZE:
case OPC_INB_KEK_MANAGEMENT:
case OPC_INB_SET_OPERATOR:
case OPC_INB_GET_OPERATOR:
// case OPC_INB_SGPIO:
#ifdef SPC_ENABLE_PROFILE
case OPC_INB_FW_PROFILE:
#endif
/* Uses the tag table, so we have to free it up */
SA_ASSERT((tag < AGSA_MAX_VALID_PORTS * saRoot->swConfig.maxActiveIOs),
"OPC_OUB_GENERAL_EVENT tag out of range");
SA_ASSERT((saRoot->IOMap[ tag < (AGSA_MAX_VALID_PORTS * saRoot->swConfig.maxActiveIOs) ? tag : 0 ].Tag != MARK_OFF),
"OPC_OUB_GENERAL_EVENT tag not in use 1");
#if defined(SALLSDK_DEBUG)
if (tag > AGSA_MAX_VALID_PORTS * saRoot->swConfig.maxActiveIOs)
{
smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "3H");
return AGSA_RC_FAILURE;
}
#endif /* SALLSDK_DEBUG */
SA_DBG1(("mpiGeneralEventRsp:OpCode found 0x%x htag 0x%x\n",OpCode, tag));
/* get agContext */
agContext = saRoot->IOMap[tag].agContext;
/* get request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
if(pRequest)
{
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_ASSERT((pRequest->valid), "pRequest->valid");
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiGeneralEventRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
}
else
{
SA_DBG1(("mpiGeneralEventRsp:pRequest (%p) NULL\n", pRequest));
ret = AGSA_RC_FAILURE;
}
break;
/* ???? */
case OPC_INB_SATA_HOST_OPSTART:
case OPC_INB_SATA_ABORT:
case OPC_INB_SSPINIIOSTART:
case OPC_INB_SSPINITMSTART:
case OPC_INB_SSPINIEXTIOSTART:
case OPC_INB_SSPTGTIOSTART:
case OPC_INB_SSPTGTRSPSTART:
case OPC_INB_SSP_DIF_ENC_OPSTART:
case OPC_INB_SATA_DIF_ENC_OPSTART:
case OPC_INB_SSP_ABORT:
case OPC_INB_SMP_REQUEST:
case OPC_INB_SMP_ABORT:
{
/* Uses the tag table, so we have to free it up */
SA_DBG1(("mpiGeneralEventRsp:OpCode found 0x%x htag 0x%x\n",OpCode, tag));
tag = GenEventData.inbIOMBpayload[1];
SA_ASSERT((tag < AGSA_MAX_VALID_PORTS * saRoot->swConfig.maxActiveIOs),
"OPC_OUB_GENERAL_EVENT tag out of range");
SA_ASSERT((saRoot->IOMap[ tag < (AGSA_MAX_VALID_PORTS * saRoot->swConfig.maxActiveIOs) ? tag : 0 ].Tag != MARK_OFF),
"OPC_OUB_GENERAL_EVENT tag not in use 2");
#if defined(SALLSDK_DEBUG)
if (tag > AGSA_MAX_VALID_PORTS * saRoot->swConfig.maxActiveIOs)
{
smTraceFuncExit(hpDBG_VERY_LOUD, 'd', "3H");
return AGSA_RC_FAILURE;
}
#endif
/* get request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
if(pRequest)
{
pDevice = pRequest->pDevice;
/* return the request to free pool */
/* get IORequestContext */
agContext = (agsaContext_t *)pRequest->pIORequestContext;
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_ASSERT((pRequest->valid), "pRequest->valid");
pRequest->valid = agFALSE;
saLlistIORemove(&(pDevice->pendingIORequests), &(pRequest->linkNode));
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiGeneralEventRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
break;
}
else
{
SA_DBG1(("mpiGeneralEventRsp:pRequest (%p) NULL\n", pRequest));
ret = AGSA_RC_FAILURE;
}
}
default:
{
SA_DBG1(("mpiGeneralEventRsp:OpCode Not found 0x%x htag 0x%x\n",OpCode, tag));
ret = AGSA_RC_FAILURE;
/* Uses the tag table, so we have to free it up */
tag = GenEventData.inbIOMBpayload[1];
SA_ASSERT((tag < AGSA_MAX_VALID_PORTS * saRoot->swConfig.maxActiveIOs),
"OPC_OUB_GENERAL_EVENT tag out of range");
SA_ASSERT((saRoot->IOMap[ tag < (AGSA_MAX_VALID_PORTS * saRoot->swConfig.maxActiveIOs) ? tag : 0 ].Tag != MARK_OFF),
"OPC_OUB_GENERAL_EVENT tag not in use 3");
#if defined(SALLSDK_DEBUG)
if (tag > AGSA_MAX_VALID_PORTS * saRoot->swConfig.maxActiveIOs)
{
smTraceFuncExit(hpDBG_VERY_LOUD, 'e', "3H");
return AGSA_RC_FAILURE;
}
#endif
/* get agContext */
agContext = saRoot->IOMap[tag].agContext;
/* get request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
if (pRequest == agNULL)
{
smTraceFuncExit(hpDBG_VERY_LOUD, 'f', "3H");
return AGSA_RC_FAILURE;
}
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_ASSERT((pRequest->valid), "pRequest->valid");
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiGeneralEventRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
break;
}
ret = AGSA_RC_FAILURE;
}
switch (OpCode) /* OpCode */
{
case OPC_INB_KEK_MANAGEMENT:
{
bit32 flags = GenEventData.inbIOMBpayload[2];
SA_DBG1(("mpiGeneralEventRsp: OPC_INB_KEK_MANAGEMENT 0x%x htag 0x%x flags 0x%x\n",OpCode, tag, flags));
if (flags & 0xFF00) /* update and store*/
{
agEvent.encryptOperation = OSSA_HW_ENCRYPT_KEK_UPDATE_AND_STORE;
SA_DBG1(("mpiGeneralEventRsp: OSSA_HW_ENCRYPT_KEK_UPDATE_AND_STORE\n"));
}
else /* update */
{
agEvent.encryptOperation = OSSA_HW_ENCRYPT_KEK_UPDATE;
SA_DBG1(("mpiGeneralEventRsp: OSSA_HW_ENCRYPT_KEK_UPDATE\n"));
}
agEvent.status = OSSA_INVALID_ENCRYPTION_SECURITY_MODE;
si_memset(&agEvent, 0, sizeof(agsaHWEventEncrypt_t));
agEvent.status = status;
SA_DBG1(("mpiGeneralEventRsp: ossaHwCB OSSA_HW_EVENT_ENCRYPTION\n" ));
ossaHwCB(agRoot, NULL, OSSA_HW_EVENT_ENCRYPTION, 0, (void*)&agEvent, agContext);
break;
}
case OPC_INB_OPR_MGMT:
si_memset(&agEvent, 0, sizeof(agsaHWEventEncrypt_t));
agEvent.status = status;
agEvent.encryptOperation = OSSA_HW_ENCRYPT_OPERATOR_MANAGEMENT;
SA_DBG1(("mpiGeneralEventRsp: OSSA_HW_ENCRYPT_OPERATOR_MANAGEMENT\n" ));
ossaOperatorManagementCB(agRoot, agContext, status, 0);
break;
case OPC_INB_SET_OPERATOR:
SA_DBG1(("mpiGeneralEventRsp: OSSA_HW_ENCRYPT_SET_OPERATOR\n" ));
ossaSetOperatorCB(agRoot,agContext,0xFF,0xFF );
break;
case OPC_INB_GET_OPERATOR:
SA_DBG1(("mpiGeneralEventRsp: OSSA_HW_ENCRYPT_GET_OPERATOR\n" ));
ossaGetOperatorCB(agRoot,agContext,0xFF,0xFF,0xFF,0xFF,agNULL );
break;
case OPC_INB_ENC_TEST_EXECUTE:
si_memset(&agEvent, 0, sizeof(agsaHWEventEncrypt_t));
agEvent.status = status;
agEvent.encryptOperation = OSSA_HW_ENCRYPT_TEST_EXECUTE;
SA_DBG1(("mpiGeneralEventRsp: OSSA_HW_ENCRYPT_TEST_EXECUTE\n" ));
ossaHwCB(agRoot, NULL, OSSA_HW_EVENT_ENCRYPTION, 0, (void*)&agEvent, agContext);
break;
default:
SA_DBG1(("mpiGeneralEventRsp: MGMNT OpCode Not found 0x%x\n",OpCode ));
ossaGeneralEvent(agRoot, status, agContext, GenEventData.inbIOMBpayload);
break;
}
/* return value */
smTraceFuncExit(hpDBG_VERY_LOUD, 'g', "3H");
return ret;
}
/******************************************************************************/
/*! \brief SPC MPI SSP Request Received Event (target mode)
*
* This function handles the SSP Request Received Event.
*
* \param agRoot Handles for this instance of SAS/SATA LLL
* \param pMsg1 pointer of Message
*
* \return The read value
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiSSPReqReceivedNotify(
agsaRoot_t *agRoot,
agsaSSPReqReceivedNotify_t *pMsg1)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaDeviceDesc_t *pDevice;
bit32 deviceid, iniTagSSPIul, frameTypeHssa, TlrHdsa;
smTraceFuncEnter(hpDBG_VERY_LOUD,"3J");
/* convert endiness if necassary */
OSSA_READ_LE_32(AGROOT, &deviceid, pMsg1, OSSA_OFFSET_OF(agsaSSPReqReceivedNotify_t, deviceId));
OSSA_READ_LE_32(AGROOT, &iniTagSSPIul, pMsg1, OSSA_OFFSET_OF(agsaSSPReqReceivedNotify_t, iniTagSSPIul));
OSSA_READ_LE_32(AGROOT, &frameTypeHssa, pMsg1, OSSA_OFFSET_OF(agsaSSPReqReceivedNotify_t, frameTypeHssa));
OSSA_READ_LE_32(AGROOT, &TlrHdsa, pMsg1, OSSA_OFFSET_OF(agsaSSPReqReceivedNotify_t, TlrHdsa));
/* deviceId -> agDeviceHandle */
pDevice = (agsaDeviceDesc_t *)saRoot->DeviceMap[deviceid & DEVICE_ID_BITS].DeviceHandle;
if (agNULL == pDevice)
{
SA_DBG1(("mpiSSPReqReceivedNotify: warning!!! no deviceHandle is found"));
}
else
{
/* type punning only safe through char *. See gcc -fstrict_aliasing. */
char * safe_type_pun = (char *)&(pMsg1->SSPIu[0]);
if( pDevice->initiatorDevHandle.sdkData != agNULL)
{
ossaSSPReqReceived(agRoot, &(pDevice->initiatorDevHandle),
(agsaFrameHandle_t *)safe_type_pun,
(bit16)((iniTagSSPIul >> SHIFT16) & INITTAG_BITS),
((frameTypeHssa >> SHIFT24) & FRAME_TYPE) |
((TlrHdsa >> SHIFT16) & TLR_BITS),
(iniTagSSPIul & SSPIUL_BITS));
}else if( pDevice->targetDevHandle.sdkData != agNULL)
{
ossaSSPReqReceived(agRoot, &(pDevice->targetDevHandle),
(agsaFrameHandle_t *)safe_type_pun,
(bit16)((iniTagSSPIul >> SHIFT16) & INITTAG_BITS),
((frameTypeHssa >> SHIFT24) & FRAME_TYPE) |
((TlrHdsa >> SHIFT16) & TLR_BITS),
(iniTagSSPIul & SSPIUL_BITS));
}else
{
SA_ASSERT(0, "Device handle sdkData not set");
}
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "3J");
return ret;
}
/******************************************************************************/
/*! \brief SPC MPI Device Handle Arrived Event (target mode)
*
* This function handles the Device Handle Arrived Event.
*
* \param agRoot Handles for this instance of SAS/SATA LLL
* \param pMsg1 pointer of Message
*
* \return The read value
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiDeviceHandleArrived(
agsaRoot_t *agRoot,
agsaDeviceHandleArrivedNotify_t *pMsg1)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaDeviceDesc_t *pDevice;
agsaPort_t *pPort;
agsaSASDeviceInfo_t pDeviceInfo;
agsaPortContext_t *agPortContext;
agsaSASIdentify_t remoteIdentify;
bit32 CTag;
bit32 FwdDeviceId;
bit32 ProtConrPortId;
bit32 portId;
bit32 conRate;
bit8 i, protocol, dTypeSRate;
bit32 HostAssignedId;
if(saRoot == agNULL)
{
SA_ASSERT((saRoot != agNULL), "saRoot");
return AGSA_RC_FAILURE;
}
smTraceFuncEnter(hpDBG_VERY_LOUD,"3L");
/* convert endiness if necassary */
OSSA_READ_LE_32(AGROOT, &CTag, pMsg1, OSSA_OFFSET_OF(agsaDeviceHandleArrivedNotify_t, CTag));
OSSA_READ_LE_32(AGROOT, &FwdDeviceId, pMsg1, OSSA_OFFSET_OF(agsaDeviceHandleArrivedNotify_t, HostAssignedIdFwdDeviceId));
OSSA_READ_LE_32(AGROOT, &ProtConrPortId, pMsg1, OSSA_OFFSET_OF(agsaDeviceHandleArrivedNotify_t, ProtConrPortId));
if(smIS_SPCV(agRoot))
{
portId = ProtConrPortId & PortId_V_MASK;
conRate = (ProtConrPortId & Conrate_V_MASK ) >> Conrate_V_SHIFT;
HostAssignedId = (FwdDeviceId & 0xFFFF0000) >> SHIFT16;
if(HostAssignedId)
{
SA_DBG1(("mpiDeviceHandleArrived: HostAssignedId 0x%X\n",HostAssignedId));
}
}
else
{
portId = ProtConrPortId & PortId_SPC_MASK;
conRate = (ProtConrPortId & Conrate_SPC_MASK ) >> Conrate_SPC_SHIFT;
}
protocol =(bit8)((ProtConrPortId & PROTOCOL_BITS ) >> PROTOCOL_SHIFT);
SA_DBG1(("mpiDeviceHandleArrived: New Port portID %d deviceid 0x%X conRate 0x%X protocol 0x%X\n",portId, FwdDeviceId,conRate,protocol));
/* Port Map */
agPortContext = saRoot->PortMap[portId].PortContext;
if (agNULL == agPortContext)
{
ossaSingleThreadedEnter(agRoot, LL_PORT_LOCK);
/* new port */
/* Acquire port list lock */
/* Allocate a free port */
pPort = (agsaPort_t *) saLlistGetHead(&(saRoot->freePorts));
if (agNULL != pPort)
{
saLlistRemove(&(saRoot->freePorts), &(pPort->linkNode));
/* setup the port data structure */
pPort->portContext.osData = agNULL;
pPort->portContext.sdkData = pPort;
pPort->tobedeleted = agFALSE;
/* Add to valid port list */
saLlistAdd(&(saRoot->validPorts), &(pPort->linkNode));
/* Release port list lock */
ossaSingleThreadedLeave(agRoot, LL_PORT_LOCK);
/* Setup portMap based on portId */
saRoot->PortMap[portId].PortID = portId;
saRoot->PortMap[portId].PortContext = &(pPort->portContext);
saRoot->PortMap[portId].PortStatus &= ~PORT_INVALIDATING;
pPort->portId = portId;
pPort->status &= ~PORT_INVALIDATING;
SA_DBG3(("mpiDeviceHandleArrived: ~PORT_INVALIDATING New Port portID %d PortContext %p\n",saRoot->PortMap[pPort->portId].PortID , &pPort->portContext));
}
else
{
ossaSingleThreadedLeave(agRoot, LL_PORT_LOCK);
SA_DBG2(("mpiDeviceHandleArrived:Port NULL\n"));
/* pPort is agNULL*/
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "3L");
return AGSA_RC_FAILURE;
}
}
else
{
/* exist port */
pPort = (agsaPort_t *) (agPortContext->sdkData);
pPort->status &= ~PORT_INVALIDATING;
pPort->portId =portId;
saRoot->PortMap[pPort->portId].PortStatus &= ~PORT_INVALIDATING;
SA_DBG1(("mpiDeviceHandleArrived: ~PORT_INVALIDATING Old port portID %d PortContext %p\n", portId, &pPort->portContext));
}
/* build Device Information structure */
si_memset(&pDeviceInfo, 0, sizeof(agsaSASDeviceInfo_t));
if (ProtConrPortId & PROTOCOL_BITS)
{
protocol = SA_IDFRM_SSP_BIT; /* SSP */
pDeviceInfo.commonDevInfo.devType_S_Rate = (bit8)(conRate | 0x10);
}
else
{
protocol = SA_IDFRM_SMP_BIT; /* SMP */
pDeviceInfo.commonDevInfo.devType_S_Rate = (bit8)conRate;
}
pDeviceInfo.initiator_ssp_stp_smp = protocol;
pDeviceInfo.numOfPhys = 1;
pDeviceInfo.commonDevInfo.sasAddressHi[0] = pMsg1->sasAddrHi[0];
pDeviceInfo.commonDevInfo.sasAddressHi[1] = pMsg1->sasAddrHi[1];
pDeviceInfo.commonDevInfo.sasAddressHi[2] = pMsg1->sasAddrHi[2];
pDeviceInfo.commonDevInfo.sasAddressHi[3] = pMsg1->sasAddrHi[3];
pDeviceInfo.commonDevInfo.sasAddressLo[0] = pMsg1->sasAddrLow[0];
pDeviceInfo.commonDevInfo.sasAddressLo[1] = pMsg1->sasAddrLow[1];
pDeviceInfo.commonDevInfo.sasAddressLo[2] = pMsg1->sasAddrLow[2];
pDeviceInfo.commonDevInfo.sasAddressLo[3] = pMsg1->sasAddrLow[3];
pDeviceInfo.commonDevInfo.flag = 0;
pDeviceInfo.commonDevInfo.it_NexusTimeout = ITL_TO_DEFAULT;
/* deviceId -> agDeviceHandle */
pDevice = (agsaDeviceDesc_t *)saRoot->DeviceMap[FwdDeviceId & DEVICE_ID_BITS].DeviceHandle;
if (agNULL == pDevice)
{
/* new device */
si_memset(&remoteIdentify, 0, sizeof(agsaSASIdentify_t));
for (i=0;i<4;i++)
{
remoteIdentify.sasAddressHi[i] = pMsg1->sasAddrHi[i];
remoteIdentify.sasAddressLo[i] = pMsg1->sasAddrLow[i];
}
remoteIdentify.deviceType_addressFrameType = (bit8)(pDeviceInfo.commonDevInfo.devType_S_Rate & 0xC0);
dTypeSRate = pDeviceInfo.commonDevInfo.devType_S_Rate;
/* get Device from free Device List */
pDevice = siPortSASDeviceAdd(agRoot, pPort, remoteIdentify, agTRUE, SMP_TO_DEFAULT, ITL_TO_DEFAULT, 0, dTypeSRate, 0);
if (agNULL == pDevice)
{
SA_DBG1(("mpiDeviceHandleArrived: Device Handle is NULL, Out of Resources Error.\n"));
}
else
{
bit32 AccStatus = 0;
bit32 SaveId = FwdDeviceId & 0xFFFF;
/* mapping the device handle and device id */
saRoot->DeviceMap[FwdDeviceId & DEVICE_ID_BITS].DeviceIdFromFW = FwdDeviceId;
saRoot->DeviceMap[FwdDeviceId & DEVICE_ID_BITS].DeviceHandle = (void *)pDevice;
pDevice->DeviceMapIndex = FwdDeviceId;
SA_DBG2(("mpiDeviceHandleArrived: New deviceID 0x%x Device Context %p DeviceTypeSRate 0x%x\n", FwdDeviceId, pDevice, dTypeSRate));
/* Call Back */
AccStatus = ossaDeviceHandleAccept(agRoot, &(pDevice->initiatorDevHandle), &pDeviceInfo, agPortContext,&FwdDeviceId );
HostAssignedId = (FwdDeviceId & 0xFFFF0000) >> SHIFT16;
if(HostAssignedId)
{
if( SaveId == (FwdDeviceId & 0xFFFF) )
{
saRoot->DeviceMap[FwdDeviceId & DEVICE_ID_BITS].DeviceIdFromFW = FwdDeviceId;
pDevice->DeviceMapIndex = FwdDeviceId;
SA_DBG1(("mpiDeviceHandleArrived:FwdDeviceId 0x%x HostAssignedId 0x%x\n",FwdDeviceId,HostAssignedId));
}
else
{
SA_DBG1(("mpiDeviceHandleArrived:Id mangled expect 0x%x Got 0x%x\n",SaveId, (FwdDeviceId & 0xFFFF)));
ret = AGSA_RC_FAILURE;
}
}
/* get AWT flag and ITLN_TMO value */
if(AccStatus == OSSA_RC_ACCEPT )
{
/* build DEVICE_HANDLE_ACCEPT IOMB and send to SPC with action=accept */
mpiDevHandleAcceptCmd(agRoot, agNULL, CTag, FwdDeviceId, 0, pDeviceInfo.commonDevInfo.flag, pDeviceInfo.commonDevInfo.it_NexusTimeout, 0);
}
else
{
mpiDevHandleAcceptCmd(agRoot, agNULL, CTag, FwdDeviceId, 1, pDeviceInfo.commonDevInfo.flag, pDeviceInfo.commonDevInfo.it_NexusTimeout, 0);
}
}
}
SA_DBG1(("mpiDeviceHandleArrived Device 0x%08X flag 0x%08X %s WWID= %02x%02x%02x%02x:%02x%02x%02x%02x, %s\n",
FwdDeviceId,
pDevice->devInfo.sasDeviceInfo.commonDevInfo.flag,
(pDevice->devInfo.sasDeviceInfo.commonDevInfo.devType_S_Rate & 0xF0) == 0x20 ? "SATA DA" :
(pDevice->devInfo.sasDeviceInfo.commonDevInfo.devType_S_Rate & 0xF0) == 0x10 ? "SSP/SMP" :
(pDevice->devInfo.sasDeviceInfo.commonDevInfo.devType_S_Rate & 0xF0) == 0x0 ? " STP " : "Unknown",
pDevice->devInfo.sasDeviceInfo.commonDevInfo.sasAddressHi[3],
pDevice->devInfo.sasDeviceInfo.commonDevInfo.sasAddressHi[2],
pDevice->devInfo.sasDeviceInfo.commonDevInfo.sasAddressHi[1],
pDevice->devInfo.sasDeviceInfo.commonDevInfo.sasAddressHi[0],
pDevice->devInfo.sasDeviceInfo.commonDevInfo.sasAddressLo[3],
pDevice->devInfo.sasDeviceInfo.commonDevInfo.sasAddressLo[2],
pDevice->devInfo.sasDeviceInfo.commonDevInfo.sasAddressLo[1],
pDevice->devInfo.sasDeviceInfo.commonDevInfo.sasAddressLo[0],
(pDevice->devInfo.sasDeviceInfo.commonDevInfo.devType_S_Rate & 0xF) == 8 ? " 1.5G" :
(pDevice->devInfo.sasDeviceInfo.commonDevInfo.devType_S_Rate & 0xF) == 9 ? " 3.0G" :
(pDevice->devInfo.sasDeviceInfo.commonDevInfo.devType_S_Rate & 0xF) == 10 ? " 6.0G" :
(pDevice->devInfo.sasDeviceInfo.commonDevInfo.devType_S_Rate & 0xF) == 11 ? "12.0G" : "????" ));
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "3L");
return ret;
}
/******************************************************************************/
/*! \brief Get Time Stamp Response
*
* This routine handles the response of Get Time Stamp Command
*
* \param agRoot Handles for this instance of SAS/SATA LLL
* \param pIomb Pointer of IOMB Mesage
*
* \return sucess or fail
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiGetTimeStampRsp(
agsaRoot_t *agRoot,
agsaGetTimeStampRsp_t *pIomb
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
agsaContext_t *agContext;
bit32 tag, timeStampLower, timeStampUpper;
smTraceFuncEnter(hpDBG_VERY_LOUD,"3M");
SA_DBG3(("mpiGetTimeStampRsp: HTAG=0x%x\n", pIomb->tag));
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaGetTimeStampRsp_t, tag));
OSSA_READ_LE_32(AGROOT, &timeStampLower, pIomb, OSSA_OFFSET_OF(agsaGetTimeStampRsp_t, timeStampLower));
OSSA_READ_LE_32(AGROOT, &timeStampUpper, pIomb, OSSA_OFFSET_OF(agsaGetTimeStampRsp_t, timeStampUpper));
/* get request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
if (agNULL == pRequest)
{
SA_DBG1(("mpiGetTimeStampRsp: Bad Response IOMB!!! pRequest is NULL.TAG=0x%x\n", tag));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "3M");
return AGSA_RC_FAILURE;
}
agContext = saRoot->IOMap[tag].agContext;
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
SA_ASSERT((pRequest->valid), "pRequest->valid");
SA_DBG3(("mpiGetTimeStampRsp: timeStampLower 0x%x timeStampUpper 0x%x\n", timeStampLower, timeStampUpper));
ossaGetTimeStampCB(agRoot, agContext, timeStampLower, timeStampUpper);
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiGetTimeStampRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
/* return value */
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "3M");
return ret;
}
/******************************************************************************/
/*! \brief SAS HW Event Ack Response
*
* This routine handles the response of SAS HW Event Ack Command
*
* \param agRoot Handles for this instance of SAS/SATA LLL
* \param pIomb Pointer of IOMB Mesage
*
* \return sucess or fail
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiSASHwEventAckRsp(
agsaRoot_t *agRoot,
agsaSASHwEventAckRsp_t *pIomb
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
agsaContext_t *agContext;
agsaPort_t *pPort;
bit32 tag, status;
smTraceFuncEnter(hpDBG_VERY_LOUD,"2N");
SA_DBG2(("mpiSASHwEventAckRsp: Htag=0x%x %p\n", pIomb->tag,pIomb));
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaSASHwEventAckRsp_t, tag));
OSSA_READ_LE_32(AGROOT, &status, pIomb, OSSA_OFFSET_OF(agsaSASHwEventAckRsp_t, status));
/* get request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
if (agNULL == pRequest)
{
SA_DBG1(("mpiSASHwEventAckRsp: Bad Response IOMB!!! pRequest is NULL.TAG=0x%x Status=0x%x\n", tag, status));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2N");
return AGSA_RC_FAILURE;
}
agContext = saRoot->IOMap[tag].agContext;
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
SA_ASSERT((pRequest->valid), "pRequest->valid");
SA_DBG1(("mpiSASHwEventAckRsp: status 0x%x Htag=0x%x HwAckType=0x%x\n",status,pIomb->tag,pRequest->HwAckType ));
ossaHwEventAckCB(agRoot, agContext, status);
pPort = pRequest->pPort;
if (agNULL != pPort)
{
SA_DBG1(("mpiSASHwEventAckRsp: pPort %p tobedeleted %d\n", pPort, pPort->tobedeleted));
if (pPort->status & PORT_INVALIDATING && pPort->tobedeleted )
{
SA_DBG1(("mpiSASHwEventAckRsp: PORT_INVALIDATING portInvalid portID %d pPort %p, nulling out PortContext\n", pPort->portId, pPort));
/* invalid the port */
siPortInvalid(agRoot, pPort);
/* map out the portmap */
saRoot->PortMap[pPort->portId].PortContext = agNULL;
saRoot->PortMap[pPort->portId].PortID = PORT_MARK_OFF;
saRoot->PortMap[pPort->portId].PortStatus |= PORT_INVALIDATING;
}
else
{
SA_DBG1(("mpiSASHwEventAckRsp:pPort->status 0x%x Htag=0x%x %p\n",pPort->status, pIomb->tag,pIomb));
}
}
else
{
SA_DBG1(("mpiSASHwEventAckRsp: pPort is NULL, no portId, HTag=0x%x\n", tag));
}
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiSASHwEventAckRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
/* return value */
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "2N");
return ret;
}
/******************************************************************************/
/*! \brief Port Control Response
*
* This routine handles the response of SAS HW Event Ack Command
*
* \param agRoot Handles for this instance of SAS/SATA LLL
* \param pIomb Pointer of IOMB Mesage
*
* \return sucess or fail
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiPortControlRsp(
agsaRoot_t *agRoot,
agsaPortControlRsp_t *pIomb
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaIORequestDesc_t *pRequest = agNULL;
agsaContext_t *agContext = agNULL;
agsaPortContext_t *agPortContext = agNULL;
bit32 tag;
bit32 port =0;
bit32 operation =0;
bit32 status =0;
bit32 portState =0;
bit32 portOperation =0;
smTraceFuncEnter(hpDBG_VERY_LOUD,"3O");
SA_DBG2(("mpiPortControlRsp: HTag=0x%x\n", pIomb->tag));
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaPortControlRsp_t, tag));
OSSA_READ_LE_32(AGROOT, &operation, pIomb, OSSA_OFFSET_OF(agsaPortControlRsp_t, portOPPortId));
OSSA_READ_LE_32(AGROOT, &status, pIomb, OSSA_OFFSET_OF(agsaPortControlRsp_t, status));
OSSA_READ_LE_32(AGROOT, &portState, pIomb, OSSA_OFFSET_OF(agsaPortControlRsp_t,rsvdPortState ));
/* get request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
if (agNULL == pRequest)
{
SA_DBG1(("mpiPortControlRsp: Bad Response IOMB!!! pRequest is NULL.TAG=0x%x Status=0x%x\n", tag, status));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "3O");
return AGSA_RC_FAILURE;
}
agContext = saRoot->IOMap[tag].agContext;
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
SA_ASSERT((pRequest->valid), "pRequest->valid");
if(!pRequest->valid)
{
SA_DBG1(("mpiPortControlRsp: pRequest->valid %d not set\n", pRequest->valid));
}
SA_DBG2(("mpiPortControlRsp: pRequest->completionCB %p\n", pRequest->completionCB));
port = operation & PORTID_MASK;
if(port < AGSA_MAX_VALID_PORTS )
{
SA_DBG2(("mpiPortControlRsp: PortID 0x%x PortStatus 0x%x PortContext %p\n",
saRoot->PortMap[port].PortID,
saRoot->PortMap[port].PortStatus,
saRoot->PortMap[port].PortContext));
agPortContext = (agsaPortContext_t *)saRoot->PortMap[port].PortContext;
}
SA_DBG2(("mpiPortControlRsp: PortID 0x%x PortStatus 0x%x PortContext %p\n",saRoot->PortMap[operation & PORTID_MASK].PortID,saRoot->PortMap[operation & PORTID_MASK].PortStatus,saRoot->PortMap[operation & PORTID_MASK].PortContext));
agPortContext = (agsaPortContext_t *)saRoot->PortMap[operation & PORTID_MASK].PortContext;
SA_DBG1(("mpiPortControlRsp: agPortContext %p\n",agPortContext ));
SA_DBG2(("mpiPortControlRsp: portID 0x%x status 0x%x\n", (operation & PORTID_MASK), status));
SA_DBG1(("mpiPortControlRsp: portID 0x%x status 0x%x agPortContext %p\n",port, status,agPortContext));
portOperation = (((operation & LOCAL_PHY_OP_BITS) >> SHIFT8) | (portState << SHIFT28) );
SA_DBG1(("mpiPortControlRsp: portState 0x%x operation 0x%x portOperation 0x%x\n",portState, operation,portOperation ));
switch(portOperation)
{
case AGSA_PORT_SET_SMP_PHY_WIDTH:
SA_DBG1(("mpiPortControlRsp: AGSA_PORT_SET_SMP_PHY_WIDTH operation 0x%x\n",operation ));
break;
case AGSA_PORT_SET_PORT_RECOVERY_TIME:
SA_DBG1(("mpiPortControlRsp: AGSA_PORT_SET_PORT_RECOVERY_TIME operation 0x%x\n",operation ));
break;
case AGSA_PORT_IO_ABORT:
SA_DBG1(("mpiPortControlRsp: AGSA_PORT_IO_ABORT operation 0x%x\n",operation ));
break;
case AGSA_PORT_SET_PORT_RESET_TIME:
SA_DBG1(("mpiPortControlRsp: AGSA_PORT_SET_PORT_RESET_TIME operation 0x%x\n",operation ));
break;
case AGSA_PORT_HARD_RESET:
SA_DBG1(("mpiPortControlRsp: AGSA_PORT_HARD_RESET operation 0x%x\n",operation ));
break;
case AGSA_PORT_CLEAN_UP:
SA_DBG1(("mpiPortControlRsp: AGSA_PORT_CLEAN_UP operation 0x%x\n",operation ));
break;
case AGSA_STOP_PORT_RECOVERY_TIMER:
SA_DBG1(("mpiPortControlRsp: AGSA_STOP_PORT_RECOVERY_TIMER operation 0x%x\n",operation ));
break;
default:
{
SA_DBG1(("mpiPortControlRsp: Unknown operation 0x%x\n",operation ));
}
}
ossaPortControlCB(agRoot, agContext, agPortContext, portOperation, status);
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiPortControlRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "3O");
/* return value */
return ret;
}
/******************************************************************************/
/*! \brief SPC MPI SMP ABORT Response
*
* This function handles the SMP Abort Response.
*
* \param agRoot Handles for this instance of SAS/SATA LLL
* \param pIomb pointer of Message
*
* \return The read value
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiSMPAbortRsp(
agsaRoot_t *agRoot,
agsaSMPAbortRsp_t *pIomb
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
agsaDeviceDesc_t *pDevice;
bit32 tag, scp, status;
smTraceFuncEnter(hpDBG_VERY_LOUD,"3P");
SA_DBG3(("mpiSMPAbortRsp: HTag=0x%x Status=0x%x\n", pIomb->tag, pIomb->status));
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaSMPAbortRsp_t, tag));
OSSA_READ_LE_32(AGROOT, &status, pIomb, OSSA_OFFSET_OF(agsaSMPAbortRsp_t, status));
OSSA_READ_LE_32(AGROOT, &scp, pIomb, OSSA_OFFSET_OF(agsaSMPAbortRsp_t, scp));
/* get IORequest from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
if (agNULL == pRequest)
{
SA_DBG1(("mpiSMPAbortRsp: pRequest is NULL, HTag=0x%x Status=0x%x\n", pIomb->tag, pIomb->status));
SA_ASSERT((pRequest), "pRequest");
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "3P");
return AGSA_RC_FAILURE;
}
if ( agTRUE == pRequest->valid )
{
pDevice = pRequest->pDevice;
SA_ASSERT((pRequest->pDevice), "pRequest->pDevice");
SA_DBG3(("mpiSMPAbortRsp: request abort is valid Htag 0x%x\n", tag));
/* remove the SSP_ABORT or SATA_ABORT request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
if( pRequest->completionCB == agNULL )
{
SA_DBG1(("mpiSMPAbortRsp: ************************************************* Valid for Expander only tag 0x%x\n", tag));
ossaSMPAbortCB(agRoot, pRequest->pIORequestContext, scp, status);
}
else
{
(*(ossaGenericAbortCB_t)(pRequest->completionCB))(agRoot, pRequest->pIORequestContext, scp, status);
}
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
/* Delete the request from the pendingIORequests */
saLlistIORemove(&(pDevice->pendingIORequests), &(pRequest->linkNode));
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiSMPAbortRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
}
else
{
ret = AGSA_RC_FAILURE;
SA_DBG1(("mpiSMPAbortRsp: the request is not valid any more. Tag=%x\n", pRequest->HTag));
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "3P");
return ret;
}
/******************************************************************************/
/*! \brief SPC MPI Device Handle Arrived Event (target mode)
*
* This function handles the Device Handle Arrived Event.
*
* \param agRoot Handles for this instance of SAS/SATA LLL
* \param pMsg1 pointer of Message
*
* \return The read value
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiDeviceHandleRemoval(
agsaRoot_t *agRoot,
agsaDeviceHandleRemoval_t *pMsg1)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaDeviceDesc_t *pDevice;
agsaPortContext_t *agPortContext;
bit32 portId;
bit32 deviceid, deviceIdx;
smTraceFuncEnter(hpDBG_VERY_LOUD,"3R");
/* convert endiness if necassary */
OSSA_READ_LE_32(AGROOT, &portId, pMsg1, OSSA_OFFSET_OF(agsaDeviceHandleRemoval_t, portId));
OSSA_READ_LE_32(AGROOT, &deviceid, pMsg1, OSSA_OFFSET_OF(agsaDeviceHandleRemoval_t, deviceId));
SA_DBG3(("mpiDeviceHandleRemoval: portId=0x%x deviceId=0x%x\n", portId, deviceid));
pDevice = saRoot->DeviceMap[deviceid & DEVICE_ID_BITS].DeviceHandle;
SA_DBG2(("mpiDeviceHandleRemoval:PortID 0x%x PortStatus 0x%x PortContext %p\n",
saRoot->PortMap[portId & PORTID_MASK].PortID,
saRoot->PortMap[portId & PORTID_MASK].PortStatus,
saRoot->PortMap[portId & PORTID_MASK].PortContext));
agPortContext = (agsaPortContext_t *)saRoot->PortMap[portId & PORTID_MASK].PortContext;
/* Call Back */
SA_DBG1(("mpiDeviceHandleRemoval: portId=0x%x deviceId=0x%x autoDeregDeviceflag=0x%x\n", portId, deviceid,saRoot->autoDeregDeviceflag[portId & PORTID_MASK]));
if (pDevice->targetDevHandle.sdkData)
{
ossaDeviceHandleRemovedEvent(agRoot, &(pDevice->targetDevHandle), agPortContext);
if (saRoot->autoDeregDeviceflag[portId & PORTID_MASK])
{
/* remove the DeviceMap and MapIndex */
deviceIdx = pDevice->DeviceMapIndex & DEVICE_ID_BITS;
SA_DBG1(("mpiDeviceHandleRemoval: A Freed portId=0x%x deviceId=0x%x\n", portId, deviceid));
OS_ASSERT(deviceIdx < MAX_IO_DEVICE_ENTRIES, "deviceIdx MAX_IO_DEVICE_ENTRIES");
saRoot->DeviceMap[deviceIdx].DeviceIdFromFW = 0;
saRoot->DeviceMap[deviceIdx].DeviceHandle = agNULL;
pDevice->DeviceMapIndex = 0;
/* Reset the device data structure */
pDevice->pPort = agNULL;
pDevice->targetDevHandle.sdkData = agNULL;
pDevice->targetDevHandle.osData = agNULL;
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
saLlistAdd(&(saRoot->freeDevicesList), &(pDevice->linkNode));
SA_DBG1(("mpiDeviceHandleRemoval: portId=0x%x deviceId=0x%x\n", portId, deviceid));
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
}
}
else
{
if (pDevice->initiatorDevHandle.sdkData)
{
ossaDeviceHandleRemovedEvent(agRoot, &(pDevice->initiatorDevHandle), agPortContext);
if (saRoot->autoDeregDeviceflag[portId & PORTID_MASK])
{
/* remove the DeviceMap and MapIndex */
deviceIdx = pDevice->DeviceMapIndex & DEVICE_ID_BITS;
SA_DBG1(("mpiDeviceHandleRemoval: A Freed portId=0x%x deviceId=0x%x\n", portId, deviceid));
OS_ASSERT(deviceIdx < MAX_IO_DEVICE_ENTRIES, "deviceIdx MAX_IO_DEVICE_ENTRIES");
saRoot->DeviceMap[deviceIdx].DeviceIdFromFW = 0;
saRoot->DeviceMap[deviceIdx].DeviceHandle = agNULL;
pDevice->DeviceMapIndex = 0;
/* Reset the device data structure */
pDevice->pPort = agNULL;
pDevice->initiatorDevHandle.sdkData = agNULL;
pDevice->initiatorDevHandle.osData = agNULL;
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
saLlistAdd(&(saRoot->freeDevicesList), &(pDevice->linkNode));
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
}
}
else
{
/* no callback because bad device_id */
SA_DBG1(("mpiDeviceHandleRemoval: Bad Device Handle, deviceId=0x%x\n", deviceid));
}
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "3R");
return ret;
}
/******************************************************************************/
/*! \brief Set Device State Response
*
* This routine handles the response of SET Device State Response
*
* \param agRoot Handles for this instance of SAS/SATA LLL
* \param pIomb Pointer of IOMB Mesage
*
* \return sucess or fail
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiSetDeviceStateRsp(
agsaRoot_t *agRoot,
agsaSetDeviceStateRsp_t *pIomb
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
agsaDevHandle_t *agDevHandle;
agsaDeviceDesc_t *pDevice;
agsaContext_t *agContext;
bit32 tag, status, deviceState, deviceId;
smTraceFuncEnter(hpDBG_VERY_LOUD,"3Q");
SA_DBG1(("mpiSetDeviceStateRsp: HTag=0x%x, deviceId=0x%x\n", pIomb->tag, pIomb->deviceId));
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaSetDeviceStateRsp_t, tag));
OSSA_READ_LE_32(AGROOT, &deviceId, pIomb, OSSA_OFFSET_OF(agsaSetDeviceStateRsp_t, deviceId));
OSSA_READ_LE_32(AGROOT, &status, pIomb, OSSA_OFFSET_OF(agsaSetDeviceStateRsp_t, status));
/* get request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
if (agNULL == pRequest)
{
SA_DBG1(("mpiSetDeviceStateRsp: Bad Response IOMB!!! pRequest is NULL. TAG=0x%x STATUS=0x%x\n", tag, status));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "3Q");
return AGSA_RC_FAILURE;
}
agContext = saRoot->IOMap[tag].agContext;
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
SA_ASSERT((pRequest->valid), "pRequest->valid");
/* status is SUCCESS */
OSSA_READ_LE_32(AGROOT, &deviceState, pIomb, OSSA_OFFSET_OF(agsaSetDeviceStateRsp_t, pds_nds));
/* find device handle from device index */
pDevice = (agsaDeviceDesc_t *)saRoot->DeviceMap[deviceId & DEVICE_ID_BITS].DeviceHandle;
if (agNULL == pDevice)
{
SA_DBG1(("mpiSetDeviceStateRsp: DeviceHandle is NULL!!! deviceId=0x%x TAG=0x%x STATUS=0x%x \n", deviceId, tag, status));
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "3Q");
return AGSA_RC_FAILURE;
}
if (pDevice->targetDevHandle.sdkData)
{
agDevHandle = &(pDevice->targetDevHandle);
}
else
{
agDevHandle = &(pDevice->initiatorDevHandle);
}
if (agDevHandle == agNULL)
{
SA_DBG1(("mpiSetDeviceStateRsp: warning!!! no deviceHandle is found"));
ossaSetDeviceStateCB(agRoot, agContext, agNULL, OSSA_IO_NO_DEVICE, 0, 0);
smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "3Q");
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiSetDeviceStateRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
return AGSA_RC_FAILURE;
}
ossaSetDeviceStateCB(agRoot, agContext, agDevHandle, status, (deviceState & NDS_BITS),
(deviceState & PDS_BITS) >> SHIFT4);
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiSetDeviceStateRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
/* return value */
smTraceFuncExit(hpDBG_VERY_LOUD, 'd', "3Q");
return ret;
}
/******************************************************************************/
/*! \brief Get Device State Response
*
* This routine handles the response of GET Device State Response
*
* \param agRoot Handles for this instance of SAS/SATA LLL
* \param pIomb Pointer of IOMB Mesage
*
* \return sucess or fail
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiGetDeviceStateRsp(
agsaRoot_t *agRoot,
agsaGetDeviceStateRsp_t *pIomb
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
agsaDevHandle_t *agDevHandle;
agsaDeviceDesc_t *pDevice;
agsaContext_t *agContext;
bit32 tag, status, deviceId, deviceState;
smTraceFuncEnter(hpDBG_VERY_LOUD,"3W");
SA_DBG1(("mpiGetDeviceStateRsp: HTag=0x%x, deviceId=0x%x\n", pIomb->tag, pIomb->deviceId));
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaGetDeviceStateRsp_t, tag));
OSSA_READ_LE_32(AGROOT, &deviceId, pIomb, OSSA_OFFSET_OF(agsaGetDeviceStateRsp_t, deviceId));
OSSA_READ_LE_32(AGROOT, &status, pIomb, OSSA_OFFSET_OF(agsaGetDeviceStateRsp_t, status));
/* get request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
if (agNULL == pRequest)
{
SA_DBG1(("mpiGetDeviceStateRsp: Bad Response IOMB!!! pRequest is NULL. TAG=0x%x STATUS=0x%x\n", tag, status));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "3W");
return AGSA_RC_FAILURE;
}
agContext = saRoot->IOMap[tag].agContext;
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
SA_ASSERT((pRequest->valid), "pRequest->valid");
/* status is SUCCESS */
OSSA_READ_LE_32(AGROOT, &deviceState, pIomb, OSSA_OFFSET_OF(agsaGetDeviceStateRsp_t, ds));
/* find device handle from device index */
pDevice = (agsaDeviceDesc_t *)saRoot->DeviceMap[deviceId & DEVICE_ID_BITS].DeviceHandle;
if (pDevice != agNULL)
{
if (pDevice->targetDevHandle.sdkData)
{
agDevHandle = &(pDevice->targetDevHandle);
}
else
{
agDevHandle = &(pDevice->initiatorDevHandle);
}
}
else
{
SA_DBG1(("mpiGetDeviceStateRsp: pDevice is NULL"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "3W");
return AGSA_RC_FAILURE;
}
if (agDevHandle == agNULL)
{
SA_DBG1(("mpiGetDeviceStateRsp: warning!!! no deviceHandle is found"));
ossaGetDeviceStateCB(agRoot, agContext, agNULL, OSSA_IO_NO_DEVICE, 0);
smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "3W");
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiGetDeviceStateRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
return AGSA_RC_FAILURE;
}
ossaGetDeviceStateCB(agRoot, agContext, agDevHandle, status, deviceState);
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiGetDeviceStateRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
/* return value */
smTraceFuncExit(hpDBG_VERY_LOUD, 'd', "3W");
return ret;
}
/******************************************************************************/
/*! \brief SAS ReInitialize Response
*
* This routine handles the response of SAS Reinitialize Response
*
* \param agRoot Handles for this instance of SAS/SATA LLL
* \param pIomb Pointer of IOMB Mesage
*
* \return sucess or fail
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiSasReInitializeRsp(
agsaRoot_t *agRoot,
agsaSasReInitializeRsp_t *pIomb
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
agsaContext_t *agContext;
agsaSASReconfig_t SASReconfig;
bit32 tag, status, setFlags, MaxPorts;
bit32 openRejReCmdData, sataHOLTMO;
smTraceFuncEnter(hpDBG_VERY_LOUD,"3X");
SA_DBG1(("mpiSasReInitializeRsp: HTag=0x%x, status=0x%x\n", pIomb->tag, pIomb->status));
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaSasReInitializeRsp_t, tag));
OSSA_READ_LE_32(AGROOT, &status, pIomb, OSSA_OFFSET_OF(agsaSasReInitializeRsp_t, status));
OSSA_READ_LE_32(AGROOT, &setFlags, pIomb, OSSA_OFFSET_OF(agsaSasReInitializeRsp_t, setFlags));
OSSA_READ_LE_32(AGROOT, &MaxPorts, pIomb, OSSA_OFFSET_OF(agsaSasReInitializeRsp_t, MaxPorts));
OSSA_READ_LE_32(AGROOT, &openRejReCmdData, pIomb, OSSA_OFFSET_OF(agsaSasReInitializeRsp_t, openRejReCmdData));
OSSA_READ_LE_32(AGROOT, &sataHOLTMO, pIomb, OSSA_OFFSET_OF(agsaSasReInitializeRsp_t, sataHOLTMO));
/* get request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
if (agNULL == pRequest)
{
SA_DBG1(("mpiSasReInitializeRsp: Bad Response IOMB!!! pRequest is NULL. TAG=0x%x STATUS=0x%x\n", tag, status));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "3X");
return AGSA_RC_FAILURE;
}
agContext = saRoot->IOMap[tag].agContext;
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
SA_ASSERT((pRequest->valid), "pRequest->valid");
SASReconfig.flags = setFlags;
SASReconfig.maxPorts = (bit8)(MaxPorts & 0xFF);
SASReconfig.openRejectRetriesCmd = (bit16)((openRejReCmdData & 0xFFFF0000) >> SHIFT16);
SASReconfig.openRejectRetriesData = (bit16)(openRejReCmdData & 0x0000FFFF);
SASReconfig.sataHolTmo = (bit16)(sataHOLTMO & 0xFFFF);
ossaReconfigSASParamsCB(agRoot, agContext, status, &SASReconfig);
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiSasReInitializeRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
/* return value */
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "3X");
return ret;
}
/******************************************************************************/
/*! \brief serial GPIO Response
*
* This routine handles the response of serial GPIO Response
*
* \param agRoot Handles for this instance of SAS/SATA LLL
* \param pIomb Pointer of IOMB Mesage
*
* \return sucess or fail
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiSGpioRsp(
agsaRoot_t *agRoot,
agsaSGpioRsp_t *pInIomb
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaIORequestDesc_t *pRequest = NULL;
agsaContext_t *agContext = NULL;
bit32 i, tag, resultFunctionFrameType;
agsaSGpioReqResponse_t SgpioResponse = {0};
smTraceFuncEnter(hpDBG_VERY_LOUD,"3Y");
SA_DBG3(("mpiSGpioRsp: HTAG=0x%x\n", pInIomb->tag));
OSSA_READ_LE_32(AGROOT, &tag, pInIomb, OSSA_OFFSET_OF(agsaSGpioRsp_t, tag));
OSSA_READ_LE_32(AGROOT, &resultFunctionFrameType, pInIomb, OSSA_OFFSET_OF(agsaSGpioRsp_t, resultFunctionFrameType));
SgpioResponse.smpFrameType = resultFunctionFrameType & 0xFF;
SgpioResponse.function = (resultFunctionFrameType & 0xFF00) >> 8;
SgpioResponse.functionResult = (resultFunctionFrameType & 0xFF0000) >> 16;
if (SA_SAS_SMP_READ_GPIO_REGISTER == SgpioResponse.function)
{
for (i = 0; i < OSSA_SGPIO_MAX_READ_DATA_COUNT; i++)
{
OSSA_READ_LE_32(AGROOT, &SgpioResponse.readWriteData[i], pInIomb, OSSA_OFFSET_OF(agsaSGpioRsp_t, readData) + (i * 4));
}
}
/* Get the request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
if (agNULL == pRequest)
{
SA_DBG1(("mpiSGpioRsp: Bad Response IOMB!!! pRequest is NULL.TAG=0x%x STATUS=0x%x\n", tag, SgpioResponse.functionResult));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "3Y");
ret = AGSA_RC_FAILURE;
}
else
{
agContext = saRoot->IOMap[tag].agContext;
ossaSGpioCB(agRoot, agContext, &SgpioResponse);
/* Return the request to free pool */
saReturnRequestToFreePool(agRoot, pRequest);
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "3Y");
}
return ret;
}
/******************************************************************************/
/*! \brief PCIE Diagnostics Response
*
* This routine handles the response of PCIE Diagnostics Response
*
* \param agRoot Handles for this instance of SAS/SATA LLL
* \param pIomb Pointer of IOMB Mesage
*
* \return sucess or fail
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiPCIeDiagExecuteRsp(
agsaRoot_t *agRoot,
void *pInIomb
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = agNULL;
agsaIORequestDesc_t *pRequest;
agsaContext_t *agContext;
bit32 tag, Status, Command;
agsaPCIeDiagResponse_t pciediadrsp;
bit32 *pIomb = (bit32 *)pInIomb;
smTraceFuncEnter(hpDBG_VERY_LOUD,"3Z");
/* sanity check */
SA_ASSERT((agNULL != agRoot), "");
saRoot = (agsaLLRoot_t *) (agRoot->sdkData);
SA_ASSERT((agNULL != saRoot), "");
si_memset(&pciediadrsp, 0, sizeof(agsaPCIeDiagResponse_t));
if(smIS_SPCV(agRoot))
{
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaPCIeDiagExecuteRsp_t,tag));
OSSA_READ_LE_32(AGROOT, &Command, pIomb, OSSA_OFFSET_OF(agsaPCIeDiagExecuteRsp_t,CmdTypeDesc));
OSSA_READ_LE_32(AGROOT, &Status, pIomb, OSSA_OFFSET_OF(agsaPCIeDiagExecuteRsp_t,Status));
OSSA_READ_LE_32(AGROOT, &pciediadrsp.ERR_BLKH, pIomb, OSSA_OFFSET_OF(agsaPCIeDiagExecuteRsp_t,ERR_BLKH ));
OSSA_READ_LE_32(AGROOT, &pciediadrsp.ERR_BLKL, pIomb, OSSA_OFFSET_OF(agsaPCIeDiagExecuteRsp_t,ERR_BLKL ));
OSSA_READ_LE_32(AGROOT, &pciediadrsp.DWord8, pIomb, OSSA_OFFSET_OF(agsaPCIeDiagExecuteRsp_t,DWord8 ));
OSSA_READ_LE_32(AGROOT, &pciediadrsp.DWord9, pIomb, OSSA_OFFSET_OF(agsaPCIeDiagExecuteRsp_t,DWord9 ));
OSSA_READ_LE_32(AGROOT, &pciediadrsp.DWord10, pIomb, OSSA_OFFSET_OF(agsaPCIeDiagExecuteRsp_t,DWord10 ));
OSSA_READ_LE_32(AGROOT, &pciediadrsp.DWord11, pIomb, OSSA_OFFSET_OF(agsaPCIeDiagExecuteRsp_t,DWord11 ));
OSSA_READ_LE_32(AGROOT, &pciediadrsp.DIF_ERR, pIomb, OSSA_OFFSET_OF(agsaPCIeDiagExecuteRsp_t,DIF_ERR ));
SA_DBG3(("mpiPCIeDiagExecuteRsp: HTAG=0x%x\n",tag));
}
else
{
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsa_SPC_PCIeDiagExecuteRsp_t,tag));
OSSA_READ_LE_32(AGROOT, &Command, pIomb, OSSA_OFFSET_OF(agsa_SPC_PCIeDiagExecuteRsp_t,CmdTypeDesc));
OSSA_READ_LE_32(AGROOT, &Status, pIomb, OSSA_OFFSET_OF(agsa_SPC_PCIeDiagExecuteRsp_t,Status));
SA_DBG3(("mpiPCIeDiagExecuteRsp: SPC HTAG=0x%x\n",tag));
}
switch(Status)
{
case OSSA_PCIE_DIAG_SUCCESS:
SA_DBG3(("mpiPCIeDiagExecuteRsp: OSSA_PCIE_DIAG_SUCCESS TAG=0x%x STATUS=0x%x\n", tag, Status));
break;
case OSSA_IO_INVALID_LENGTH:
SA_DBG1(("mpiPCIeDiagExecuteRsp: OSSA_IO_INVALID_LENGTH TAG=0x%x STATUS=0x%x\n", tag, Status));
break;
case OSSA_PCIE_DIAG_INVALID_COMMAND:
SA_DBG1(("mpiPCIeDiagExecuteRsp: OSSA_PCIE_DIAG_INVALID_COMMAND TAG=0x%x STATUS=0x%x\n", tag, Status));
break;
case OSSA_PCIE_DIAG_INTERNAL_FAILURE:
SA_DBG1(("mpiPCIeDiagExecuteRsp: OSSA_PCIE_DIAG_INTERNAL_FAILURE TAG=0x%x STATUS=0x%x\n", tag, Status));
break;
case OSSA_PCIE_DIAG_INVALID_CMD_TYPE:
SA_DBG1(("mpiPCIeDiagExecuteRsp: OSSA_PCIE_DIAG_INVALID_CMD_TYPE TAG=0x%x STATUS=0x%x\n", tag, Status));
break;
case OSSA_PCIE_DIAG_INVALID_CMD_DESC:
SA_DBG1(("mpiPCIeDiagExecuteRsp: OSSA_PCIE_DIAG_INVALID_CMD_DESC TAG=0x%x STATUS=0x%x\n", tag, Status));
break;
case OSSA_PCIE_DIAG_IO_XFR_ERROR_DIF_REFERENCE_TAG_MISMATCH:
SA_DBG1(("mpiPCIeDiagExecuteRsp: OSSA_PCIE_DIAG_IO_XFR_ERROR_DIF_REFERENCE_TAG_MISMATCH TAG=0x%x STATUS=0x%x\n", tag, Status));
break;
case OSSA_PCIE_DIAG_IO_XFR_ERROR_DIF_CRC_MISMATCH:
SA_DBG1(("mpiPCIeDiagExecuteRsp: OSSA_PCIE_DIAG_IO_XFR_ERROR_DIF_CRC_MISMATCH TAG=0x%x STATUS=0x%x\n", tag, Status));
break;
case OSSA_PCIE_DIAG_INVALID_PCIE_ADDR:
SA_DBG1(("mpiPCIeDiagExecuteRsp: OSSA_PCIE_DIAG_INVALID_PCIE_ADDR TAG=0x%x STATUS=0x%x\n", tag, Status));
break;
case OSSA_PCIE_DIAG_INVALID_BLOCK_SIZE:
SA_DBG1(("mpiPCIeDiagExecuteRsp: OSSA_PCIE_DIAG_INVALID_BLOCK_SIZE TAG=0x%x STATUS=0x%x\n", tag, Status));
break;
case OSSA_PCIE_DIAG_LENGTH_NOT_BLOCK_SIZE_ALIGNED:
SA_DBG1(("mpiPCIeDiagExecuteRsp: OSSA_PCIE_DIAG_LENGTH_NOT_BLOCK_SIZE_ALIGNED TAG=0x%x STATUS=0x%x\n", tag, Status));
break;
case OSSA_PCIE_DIAG_IO_XFR_ERROR_DIF_MISMATCH:
SA_DBG1(("mpiPCIeDiagExecuteRsp: OSSA_PCIE_DIAG_IO_XFR_ERROR_DIF_MISMATCH TAG=0x%x STATUS=0x%x\n", tag, Status));
break;
case OSSA_PCIE_DIAG_IO_XFR_ERROR_DIF_APPLICATION_TAG_MISMATCH:
SA_DBG1(("mpiPCIeDiagExecuteRsp: OSSA_PCIE_DIAG_IO_XFR_ERROR_DIF_APPLICATION_TAG_MISMATCH TAG=0x%x STATUS=0x%x\n", tag, Status));
break;
default:
SA_DBG1(("mpiPCIeDiagExecuteRsp: UNKNOWN status TAG=0x%x STATUS=0x%x\n", tag, Status));
break;
}
/* get request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
if (agNULL == pRequest)
{
SA_DBG1(("mpiPCIeDiagExecuteRsp: Bad Response IOMB!!! pRequest is NULL.TAG=0x%x STATUS=0x%x\n", tag, Status));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "3Z");
return AGSA_RC_FAILURE;
}
agContext = saRoot->IOMap[tag].agContext;
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
SA_ASSERT((pRequest->valid), "pRequest->valid");
ossaPCIeDiagExecuteCB(agRoot, agContext, Status, Command,&pciediadrsp);
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiPCIeDiagExecuteRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "3Z");
/* return value */
return ret;
}
/******************************************************************************/
/*! \brief Get DFE Data command Response
*
* This routine handles the response of Get DFE Data command Response
*
* \param agRoot Handles for this instance of SAS/SATA LLL
* \param pIomb Pointer of IOMB Mesage
*
* \return sucess or fail
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiGetDFEDataRsp(
agsaRoot_t *agRoot,
void *pIomb
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = agNULL;
agsaIORequestDesc_t *pRequest;
agsaContext_t *agContext;
bit32 tag = 0, status = 0, In_Ln = 0, MCNT = 0, NBT = 0;
smTraceFuncEnter(hpDBG_VERY_LOUD,"2Y");
/* sanity check */
SA_ASSERT((agNULL != agRoot), "");
saRoot = (agsaLLRoot_t *) (agRoot->sdkData);
SA_ASSERT((agNULL != saRoot), "");
if(smIS_SPCV(agRoot))
{
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaGetDDEFDataRsp_t,tag));
OSSA_READ_LE_32(AGROOT, &status, pIomb, OSSA_OFFSET_OF(agsaGetDDEFDataRsp_t,status));
OSSA_READ_LE_32(AGROOT, &In_Ln, pIomb, OSSA_OFFSET_OF(agsaGetDDEFDataRsp_t,reserved_In_Ln));
OSSA_READ_LE_32(AGROOT, &MCNT, pIomb, OSSA_OFFSET_OF(agsaGetDDEFDataRsp_t,MCNT));
OSSA_READ_LE_32(AGROOT, &NBT, pIomb, OSSA_OFFSET_OF(agsaGetDDEFDataRsp_t,NBT));
}
else
{
/* SPC does not support this command */
}
switch(status)
{
case OSSA_DFE_MPI_IO_SUCCESS:
SA_DBG3(("mpiGetDFEDataRsp: OSSA_DFE_MPI_IO_SUCCESS TAG=0x%x STATUS=0x%x\n", tag, status));
break;
case OSSA_DFE_DATA_OVERFLOW:
SA_DBG1(("mpiGetDFEDataRsp: OSSA_DFE_DATA_OVERFLOW TAG=0x%x STATUS=0x%x\n", tag, status));
break;
case OSSA_DFE_MPI_ERR_RESOURCE_UNAVAILABLE:
SA_DBG1(("mpiGetDFEDataRsp: OSSA_DFE_MPI_ERR_RESOURCE_UNAVAILABLE TAG=0x%x STATUS=0x%x\n", tag, status));
break;
case OSSA_DFE_CHANNEL_DOWN:
SA_DBG1(("mpiGetDFEDataRsp: OSSA_DFE_CHANNEL_DOWN TAG=0x%x STATUS=0x%x\n", tag, status));
break;
case OSSA_DFE_MEASUREMENT_IN_PROGRESS:
SA_DBG1(("mpiGetDFEDataRsp: OSSA_DFE_MEASUREMENT_IN_PROGRESS TAG=0x%x STATUS=0x%x\n", tag, status));
break;
case OSSA_DFE_CHANNEL_INVALID:
SA_DBG1(("mpiGetDFEDataRsp: OSSA_DFE_CHANNEL_INVALID TAG=0x%x STATUS=0x%x\n", tag, status));
break;
case OSSA_DFE_DMA_FAILURE:
SA_DBG1(("mpiGetDFEDataRsp: OSSA_DFE_DMA_FAILURE TAG=0x%x STATUS=0x%x\n", tag, status));
break;
default:
SA_DBG1(("mpiGetDFEDataRsp: UNKNOWN status TAG=0x%x STATUS=0x%x\n", tag, status));
break;
}
/* get request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
if (agNULL == pRequest)
{
SA_DBG1(("mpiGetDFEDataRsp: Bad Response IOMB!!! pRequest is NULL.TAG=0x%x STATUS=0x%x\n", tag, status));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2Y");
return AGSA_RC_FAILURE;
}
agContext = saRoot->IOMap[tag].agContext;
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
SA_ASSERT((pRequest->valid), "pRequest->valid");
ossaGetDFEDataCB(agRoot, agContext, status, NBT);
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiGetDFEDataRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "2Y");
return ret;
}
/******************************************************************************/
/*! \brief SAS Set Controller Config Response
*
* This routine handles the response of Set Controller Config Command
*
* \param agRoot Handles for this instance of SAS/SATA LLL
* \param pIomb Pointer of IOMB Mesage
*
* \return sucess or fail
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiSetControllerConfigRsp(
agsaRoot_t *agRoot,
agsaSetControllerConfigRsp_t *pIomb
)
{
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
agsaHWEventMode_t agMode;
bit32 status, errorQualifierPage, tag;
bit32 errorQualifier;
bit32 pagetype;
smTraceFuncEnter(hpDBG_VERY_LOUD,"3a");
SA_DBG1(("mpiSetControllerConfigRsp: HTag=0x%x\n", pIomb->tag));
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaSetControllerConfigRsp_t, tag));
OSSA_READ_LE_32(AGROOT, &status, pIomb, OSSA_OFFSET_OF(agsaSetControllerConfigRsp_t, status));
OSSA_READ_LE_32(AGROOT, &errorQualifierPage, pIomb, OSSA_OFFSET_OF(agsaSetControllerConfigRsp_t, errorQualifierPage));
/* get request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
if (agNULL == pRequest)
{
SA_DBG1(("mpiSetControllerConfigRsp: Bad Response IOMB!!! pRequest is NULL. TAG=0x%x STATUS=0x%x\n", tag, status));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "3a");
return AGSA_RC_FAILURE;
}
si_memset(&agMode, 0, sizeof(agsaHWEventMode_t));
agMode.modePageOperation = agsaModePageSet;
agMode.status = status;
agMode.context = saRoot->IOMap[tag].agContext;
errorQualifier = (errorQualifierPage & 0xFFFF0000) >> SHIFT16;
pagetype = (errorQualifierPage & 0xFF);
if(status )
{
SA_DBG1(("mpiSetControllerConfigRsp: Error detected tag 0x%x pagetype 0x%x status 0x%x errorQualifier 0x%x\n",
tag, pagetype,status, errorQualifier));
}
else
{
SA_DBG1(("mpiSetControllerConfigRsp: tag 0x%x pagetype 0x%x status 0x%x\n", tag, pagetype,status ));
}
switch( pagetype)
{
case AGSA_ENCRYPTION_DEK_CONFIG_PAGE:
case AGSA_SAS_PROTOCOL_TIMER_CONFIG_PAGE:
case AGSA_INTERRUPT_CONFIGURATION_PAGE:
case AGSA_ENCRYPTION_HMAC_CONFIG_PAGE:
case AGSA_IO_GENERAL_CONFIG_PAGE:
/*case AGSA_ENCRYPTION_CONTROL_PARM_PAGE:*/
/* Report the event before freeing the IOMB */
SA_DBG1(("mpiSetControllerConfigRsp:OSSA_HW_EVENT_MODE\n"));
ossaHwCB(agRoot,agMode.context, OSSA_HW_EVENT_MODE, errorQualifierPage, (void *) &agMode, 0);
break;
case AGSA_ENCRYPTION_GENERAL_CONFIG_PAGE:
SA_DBG1(("mpiSetControllerConfigRsp:warning!!!! GENERAL_CONFIG_PAGE is read only, cannot be set\n"));
break;
/* why we need to read the scrach pad register when handling ENCRYPTION_SECURITY_PARM_PAGE??? */
case AGSA_ENCRYPTION_CONTROL_PARM_PAGE:
{
bit32 ScratchPad1 = 0;
bit32 ScratchPad3 = 0;
agsaEncryptInfo_t encrypt;
agsaEncryptInfo_t *encryptInfo = &encrypt;
SA_DBG1(("mpiSetControllerConfigRsp: AGSA_ENCRYPTION_CONTROL_PARM_PAGE\n" ));
if( pRequest->modePageContext)
{
pRequest->modePageContext = agFALSE;
}
si_memset(&encrypt, 0, sizeof(agsaEncryptInfo_t));
encryptInfo->status = 0;
encryptInfo->encryptionCipherMode = 0;
encryptInfo->encryptionSecurityMode = 0;
ScratchPad1 = ossaHwRegRead(agRoot,V_Scratchpad_1_Register);
ScratchPad3 = ossaHwRegRead(agRoot,V_Scratchpad_3_Register);
if( ScratchPad3 & SCRATCH_PAD3_V_XTS_ENABLED)
{
encryptInfo->encryptionCipherMode = agsaEncryptCipherModeXTS;
}
if( (ScratchPad3 & SCRATCH_PAD3_V_SM_MASK ) == SCRATCH_PAD3_V_SMF_ENABLED )
{
encryptInfo->encryptionSecurityMode = agsaEncryptSMF;
}
if( (ScratchPad3 & SCRATCH_PAD3_V_SM_MASK ) == SCRATCH_PAD3_V_SMA_ENABLED)
{
encryptInfo->encryptionSecurityMode = agsaEncryptSMA;
}
if( (ScratchPad3 & SCRATCH_PAD3_V_SM_MASK ) == SCRATCH_PAD3_V_SMB_ENABLED )
{
encryptInfo->encryptionSecurityMode = agsaEncryptSMB;
}
if((ScratchPad1 & SCRATCH_PAD1_V_RAAE_MASK) == SCRATCH_PAD1_V_RAAE_MASK)
{
if((ScratchPad3 & SCRATCH_PAD3_V_ENC_MASK) == SCRATCH_PAD3_V_ENC_READY ) /* 3 */
{
encryptInfo->status = AGSA_RC_SUCCESS;
}
else if((ScratchPad3 & SCRATCH_PAD3_V_ENC_READY) == SCRATCH_PAD3_V_ENC_DISABLED) /* 0 */
{
encryptInfo->status = 0xFFFF;
encryptInfo->encryptionCipherMode = 0;
encryptInfo->encryptionSecurityMode = 0;
}
else if((ScratchPad3 & SCRATCH_PAD3_V_ENC_MASK ) == SCRATCH_PAD3_V_ENC_DIS_ERR) /* 1 */
{
encryptInfo->status = (ScratchPad3 & SCRATCH_PAD3_V_ERR_CODE ) >> SHIFT16;
}
else if((ScratchPad3 & SCRATCH_PAD3_V_ENC_MASK ) == SCRATCH_PAD3_V_ENC_ENA_ERR) /* 2 */
{
encryptInfo->status = (ScratchPad3 & SCRATCH_PAD3_V_ERR_CODE ) >> SHIFT16;
}
}
else if((ScratchPad1 & SCRATCH_PAD1_V_RAAE_MASK) == SCRATCH_PAD1_V_RAAE_ERR)
{
SA_DBG1(("mpiSetControllerConfigRsp, RAAE not ready SPC AGSA_RC_FAILURE\n"));
encryptInfo->status = 0xFFFF;
encryptInfo->encryptionCipherMode = 0;
encryptInfo->encryptionSecurityMode = 0;
}
else if((ScratchPad1 & SCRATCH_PAD1_V_RAAE_MASK) == 0x0 )
{
SA_DBG2(("mpiSetControllerConfigRsp, RAAE not ready AGSA_RC_BUSY\n"));
}
SA_DBG2(("mpiSetControllerConfigRsp, encryptionCipherMode 0x%x encryptionSecurityMode 0x%x status 0x%x\n",
encryptInfo->encryptionCipherMode,
encryptInfo->encryptionSecurityMode,
encryptInfo->status));
SA_DBG2(("mpiSetControllerConfigRsp, ScratchPad3 0x%x\n",ScratchPad3));
SA_DBG1(("mpiSetControllerConfigRsp:AGSA_ENCRYPTION_CONTROL_PARM_PAGE 0x%X\n", agMode.modePageOperation));
ossaHwCB(agRoot, agNULL, OSSA_HW_EVENT_SECURITY_MODE, errorQualifier, (void *)encryptInfo, agMode.context);
break;
}
default:
SA_DBG1(("mpiSetControllerConfigRsp: Unknown page code 0x%X\n", pagetype));
break;
}
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_ASSERT((pRequest->valid), "pRequest->valid");
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiSetControllerRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "3a");
return AGSA_RC_SUCCESS;
}
/******************************************************************************/
/*! \brief SAS Get Controller Config Response
*
* This routine handles the response of Get Controller Config Command
*
* \param agRoot Handles for this instance of SAS/SATA LLL
* \param pIomb Pointer of IOMB Mesage
*
* \return sucess or fail
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiGetControllerConfigRsp(
agsaRoot_t *agRoot,
agsaGetControllerConfigRsp_t *pIomb
)
{
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
agsaHWEventMode_t agMode;
bit32 status, errorQualifier, tag;
bit32 configPage[12];
smTraceFuncEnter(hpDBG_VERY_LOUD,"3b");
si_memset(&agMode, 0, sizeof(agsaHWEventMode_t));
si_memset(configPage, 0, sizeof(configPage));
SA_DBG2(("mpiGetControllerConfigRsp: HTag=0x%x\n", pIomb->tag));
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaGetControllerConfigRsp_t, tag));
OSSA_READ_LE_32(AGROOT, &status, pIomb, OSSA_OFFSET_OF(agsaGetControllerConfigRsp_t, status));
OSSA_READ_LE_32(AGROOT, &errorQualifier, pIomb, OSSA_OFFSET_OF(agsaGetControllerConfigRsp_t, errorQualifier));
OSSA_READ_LE_32(AGROOT, &configPage[0], pIomb, OSSA_OFFSET_OF(agsaGetControllerConfigRsp_t,configPage[0] ));
OSSA_READ_LE_32(AGROOT, &configPage[1], pIomb, OSSA_OFFSET_OF(agsaGetControllerConfigRsp_t,configPage[1] ));
OSSA_READ_LE_32(AGROOT, &configPage[2], pIomb, OSSA_OFFSET_OF(agsaGetControllerConfigRsp_t,configPage[2] ));
OSSA_READ_LE_32(AGROOT, &configPage[3], pIomb, OSSA_OFFSET_OF(agsaGetControllerConfigRsp_t,configPage[3] ));
OSSA_READ_LE_32(AGROOT, &configPage[4], pIomb, OSSA_OFFSET_OF(agsaGetControllerConfigRsp_t,configPage[4] ));
OSSA_READ_LE_32(AGROOT, &configPage[5], pIomb, OSSA_OFFSET_OF(agsaGetControllerConfigRsp_t,configPage[5] ));
/* get request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
if (agNULL == pRequest)
{
SA_DBG1(("mpiGetControllerConfigRsp: Bad Response IOMB!!! pRequest is NULL. TAG=0x%x STATUS=0x%x\n", tag, status));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "3b");
return AGSA_RC_FAILURE;
}
si_memset(&agMode, 0, sizeof(agsaHWEventMode_t));
agMode.modePageOperation = agsaModePageGet;
agMode.status = status;
SA_DBG1(("mpiGetControllerConfigRsp: page 0x%x status 0x%x errorQualifier 0x%x \n", (pIomb->configPage[0] & 0xFF),status, errorQualifier));
switch (pIomb->configPage[0] & 0xFF)
{
case AGSA_SAS_PROTOCOL_TIMER_CONFIG_PAGE:
agMode.modePageLen = sizeof(agsaSASProtocolTimerConfigurationPage_t);
SA_DBG1(("mpiGetControllerConfigRsp: AGSA_SAS_PROTOCOL_TIMER_CONFIG_PAGE page len 0x%x \n",agMode.modePageLen));
break;
case AGSA_INTERRUPT_CONFIGURATION_PAGE:
agMode.modePageLen = sizeof(agsaInterruptConfigPage_t);
SA_DBG1(("mpiGetControllerConfigRsp: AGSA_INTERRUPT_CONFIGURATION_PAGE page len 0x%x \n",agMode.modePageLen));
break;
case AGSA_IO_GENERAL_CONFIG_PAGE:
agMode.modePageLen = sizeof(agsaIoGeneralPage_t);
SA_DBG1(("mpiGetControllerConfigRsp: AGSA_IO_GENERAL_CONFIG_PAGE page len 0x%x \n",agMode.modePageLen));
break;
case AGSA_ENCRYPTION_GENERAL_CONFIG_PAGE:
agMode.modePageLen = sizeof(agsaEncryptGeneralPage_t);
SA_DBG1(("mpiGetControllerConfigRsp: AGSA_ENCRYPTION_GENERAL_CONFIG_PAGE page len 0x%x \n",agMode.modePageLen));
#ifdef HIALEAH_ENCRYPTION
saRoot->EncGenPage.numberOfKeksPageCode = configPage[0];
saRoot->EncGenPage.KeyCardIdKekIndex = configPage[1];
saRoot->EncGenPage.KeyCardId3_0 = configPage[2];
saRoot->EncGenPage.KeyCardId7_4 = configPage[3];
saRoot->EncGenPage.KeyCardId11_8 = configPage[4];
SA_DBG1(("mpiGetControllerConfigRsp: numberOfKeksPageCode 0x%x\n",saRoot->EncGenPage.numberOfKeksPageCode));
SA_DBG1(("mpiGetControllerConfigRsp: KeyCardIdKekIndex 0x%x\n",saRoot->EncGenPage.KeyCardIdKekIndex));
SA_DBG1(("mpiGetControllerConfigRsp: KeyCardId3_0 0x%x\n",saRoot->EncGenPage.KeyCardId3_0));
SA_DBG1(("mpiGetControllerConfigRsp: KeyCardId7_4 0x%x\n",saRoot->EncGenPage.KeyCardId7_4));
SA_DBG1(("mpiGetControllerConfigRsp: KeyCardId11_8 0x%x\n",saRoot->EncGenPage.KeyCardId11_8));
#endif /* HIALEAH_ENCRYPTION */
break;
case AGSA_ENCRYPTION_DEK_CONFIG_PAGE:
agMode.modePageLen = sizeof(agsaEncryptDekConfigPage_t);
SA_DBG1(("mpiGetControllerConfigRsp: AGSA_ENCRYPTION_DEK_CONFIG_PAGE page len 0x%x \n",agMode.modePageLen));
break;
case AGSA_ENCRYPTION_CONTROL_PARM_PAGE:
agMode.modePageLen = sizeof(agsaEncryptControlParamPage_t);
SA_DBG1(("mpiGetControllerConfigRsp: AGSA_ENCRYPTION_CONTROL_PARM_PAGE page len 0x%x \n",agMode.modePageLen));
break;
case AGSA_ENCRYPTION_HMAC_CONFIG_PAGE:
agMode.modePageLen = sizeof(agsaEncryptHMACConfigPage_t);
SA_DBG1(("mpiGetControllerConfigRsp: AGSA_ENCRYPTION_HMAC_CONFIG_PAGE page len 0x%x \n",agMode.modePageLen));
break;
default:
agMode.modePageLen = 0;
SA_DBG1(("mpiGetControllerConfigRsp: Unknown !!! page len 0x%x \n",agMode.modePageLen));
break;
}
agMode.modePage = (void *) &pIomb->configPage[0];
agMode.context = saRoot->IOMap[tag].agContext;
/* Report the event before freeing the IOMB */
ossaHwCB(agRoot, NULL, OSSA_HW_EVENT_MODE, errorQualifier, (void *) &agMode, 0);
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_ASSERT((pRequest->valid), "pRequest->valid");
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiGetControllerRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "3b");
return AGSA_RC_SUCCESS;
}
/******************************************************************************/
/*! \brief KEK Management Response
*
* This routine handles the response of the KEK management message
*
* \param agRoot Handles for this instance of SAS/SATA LLL
* \param pIomb Pointer of IOMB Mesage
*
* \return sucess or fail
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiKekManagementRsp(
agsaRoot_t *agRoot,
agsaKekManagementRsp_t *pIomb
)
{
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
agsaContext_t *agContext;
agsaHWEventEncrypt_t agEvent;
bit32 status, errorQualifier, tag, flags;
smTraceFuncEnter(hpDBG_VERY_LOUD,"2A");
SA_DBG1(("mpiKekManagementRsp: HTag=0x%x\n", pIomb->tag));
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaKekManagementRsp_t, tag));
OSSA_READ_LE_32(AGROOT, &status, pIomb, OSSA_OFFSET_OF(agsaKekManagementRsp_t, status));
OSSA_READ_LE_32(AGROOT, &flags, pIomb, OSSA_OFFSET_OF(agsaKekManagementRsp_t, flags));
OSSA_READ_LE_32(AGROOT, &errorQualifier, pIomb, OSSA_OFFSET_OF(agsaKekManagementRsp_t, errorQualifier));
SA_DBG1(("mpiKekManagementRsp:status 0x%x flags 0x%x errorQualifier 0x%x\n", status, flags, errorQualifier));
si_memset(&agEvent, 0, sizeof(agsaHWEventEncrypt_t));
if ((flags & 0xFF) == KEK_MGMT_SUBOP_UPDATE)
{
SA_DBG1(("mpiKekManagementRsp:KEK_MGMT_SUBOP_UPDATE 0x%x \n", status));
if (flags & 0xFF00) /* update and store*/
{
agEvent.encryptOperation = OSSA_HW_ENCRYPT_KEK_UPDATE_AND_STORE;
}
else /* update */
{
agEvent.encryptOperation = OSSA_HW_ENCRYPT_KEK_UPDATE;
}
agEvent.status = status;
if (status == OSSA_MPI_ENC_ERR_ILLEGAL_KEK_PARAM)
{
agEvent.eq = errorQualifier;
}
agEvent.info = 0;
/* Store the new KEK index in agEvent.handle */
agEvent.handle = (void *) ((bitptr) (flags >> 24));
/* Store the current KEK index in agEvent.param */
agEvent.param = (void *) ((bitptr) (flags >> 16) & 0xFF);
}
else if ((flags & 0xFF) == KEK_MGMT_SUBOP_INVALIDATE)
{
agEvent.encryptOperation = OSSA_HW_ENCRYPT_KEK_INVALIDTE;
agEvent.status = status;
if (status == OSSA_MPI_ENC_ERR_ILLEGAL_KEK_PARAM)
{
agEvent.eq = errorQualifier;
}
agEvent.info = 0;
/* Store the new KEK index in agEvent.handle */
agEvent.handle = (void *) ((bitptr) (flags >> 24));
/* Store the current KEK index in agEvent.param */
agEvent.param = (void *) ((bitptr) (flags >> 16) & 0xFF);
}
else if ((flags & 0xFF) == KEK_MGMT_SUBOP_KEYCARDINVALIDATE)
{
agEvent.encryptOperation = OSSA_HW_ENCRYPT_KEK_UPDATE_AND_STORE;
agEvent.status = status;
if (status == OSSA_MPI_ENC_ERR_ILLEGAL_KEK_PARAM)
{
agEvent.eq = errorQualifier;
}
agEvent.info = 0;
/* Store the new KEK index in agEvent.handle */
agEvent.handle = (void *) ((bitptr) (flags >> 24));
/* Store the current KEK index in agEvent.param */
agEvent.param = (void *) ((bitptr) (flags >> 16) & 0xFF);
}
else if ((flags & 0xFF) == KEK_MGMT_SUBOP_KEYCARDUPDATE)
{
agEvent.encryptOperation = OSSA_HW_ENCRYPT_KEK_UPDATE;
agEvent.status = status;
if (status == OSSA_MPI_ENC_ERR_ILLEGAL_KEK_PARAM)
{
agEvent.eq = errorQualifier;
}
agEvent.info = 0;
/* Store the new KEK index in agEvent.handle */
agEvent.handle = (void *) ((bitptr) (flags >> 24));
/* Store the current KEK index in agEvent.param */
agEvent.param = (void *) ((bitptr) (flags >> 16) & 0xFF);
}
/* get request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
if (agNULL == pRequest)
{
SA_DBG1(("mpiKekManagementRsp: Bad Response IOMB!!! pRequest is NULL. TAG=0x%x STATUS=0x%x\n", tag, status));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2A");
return AGSA_RC_FAILURE;
}
agContext = saRoot->IOMap[tag].agContext;
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
ossaHwCB(agRoot, NULL, OSSA_HW_EVENT_ENCRYPTION, 0, (void *) &agEvent, agContext);
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_ASSERT((pRequest->valid), "pRequest->valid");
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiKekManagementRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "2A");
return AGSA_RC_SUCCESS;
}
/******************************************************************************/
/*! \brief DEK Management Response
*
* This routine handles the response of the DEK management message
*
* \param agRoot Handles for this instance of SAS/SATA LLL
* \param pIomb Pointer of IOMB Mesage
*
* \return sucess or fail
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiDekManagementRsp(
agsaRoot_t *agRoot,
agsaDekManagementRsp_t *pIomb
)
{
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
agsaContext_t *agContext;
agsaHWEventEncrypt_t agEvent;
bit32 flags, status, errorQualifier, tag, dekIndex;
smTraceFuncEnter(hpDBG_VERY_LOUD,"2B");
SA_DBG1(("mpiDekManagementRsp: HTag=0x%x\n", pIomb->tag));
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaDekManagementRsp_t, tag));
OSSA_READ_LE_32(AGROOT, &status, pIomb, OSSA_OFFSET_OF(agsaDekManagementRsp_t, status));
OSSA_READ_LE_32(AGROOT, &flags, pIomb, OSSA_OFFSET_OF(agsaDekManagementRsp_t, flags));
OSSA_READ_LE_32(AGROOT, &errorQualifier, pIomb, OSSA_OFFSET_OF(agsaDekManagementRsp_t, errorQualifier));
OSSA_READ_LE_32(AGROOT, &dekIndex, pIomb, OSSA_OFFSET_OF(agsaDekManagementRsp_t, dekIndex));
SA_DBG2(("mpiDekManagementRsp:tag =0x%x\n",tag ));
SA_DBG2(("mpiDekManagementRsp:status =0x%x\n", status));
SA_DBG2(("mpiDekManagementRsp:flags =0x%x\n",flags ));
SA_DBG2(("mpiDekManagementRsp:errorQualifier =0x%x\n", errorQualifier));
SA_DBG2(("mpiDekManagementRsp:dekIndex =0x%x\n",dekIndex ));
si_memset(&agEvent, 0, sizeof(agsaHWEventEncrypt_t));
if ((flags & 0xFF) == DEK_MGMT_SUBOP_UPDATE)
{
agEvent.encryptOperation = OSSA_HW_ENCRYPT_DEK_UPDATE;
}
else
{
agEvent.encryptOperation = OSSA_HW_ENCRYPT_DEK_INVALIDTE;
}
agEvent.status = status;
if (status == OSSA_MPI_ENC_ERR_ILLEGAL_DEK_PARAM || OSSA_MPI_ERR_DEK_MANAGEMENT_DEK_UNWRAP_FAIL)
{
agEvent.eq = errorQualifier;
}
/* Store the DEK in agEvent.info */
agEvent.info = (flags >> 8) & 0xF;
/* Store the KEK index in agEvent.handle */
agEvent.handle = (void *) ((bitptr) (flags >> 24));
/* Store the DEK index in agEvent.param */
agEvent.param = (void *) (bitptr) dekIndex;
/* get request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
if (agNULL == pRequest)
{
SA_DBG1(("mpiDekManagementRsp: Bad Response IOMB!!! pRequest is NULL. TAG=0x%x STATUS=0x%x\n", tag, status));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2B");
return AGSA_RC_FAILURE;
}
agContext = saRoot->IOMap[tag].agContext;
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
ossaHwCB(agRoot, NULL, OSSA_HW_EVENT_ENCRYPTION, 0, (void *) &agEvent,agContext );
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_ASSERT((pRequest->valid), "pRequest->valid");
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiDekManagementRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "2B");
return AGSA_RC_SUCCESS;
}
/******************************************************************************/
/*! \brief Operator Management Response
*
* This routine handles the response of the Operator management message
*
* \param agRoot Handles for this instance of SAS/SATA LLL
* \param pIomb Pointer of IOMB Mesage
*
* \return sucess or fail
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiOperatorManagementRsp(
agsaRoot_t *agRoot,
agsaOperatorMangmenRsp_t *pIomb
)
{
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
agsaContext_t *agContext;
agsaHWEventEncrypt_t agEvent;
bit32 OPRIDX_AUTIDX_R_OMO,status, errorQualifier, tag;
smTraceFuncEnter(hpDBG_VERY_LOUD,"36");
SA_DBG1(("mpiOperatorManagementRsp: HTag=0x%x\n", pIomb->tag));
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaOperatorMangmenRsp_t, tag));
OSSA_READ_LE_32(AGROOT, &status, pIomb, OSSA_OFFSET_OF(agsaOperatorMangmenRsp_t, status));
OSSA_READ_LE_32(AGROOT, &OPRIDX_AUTIDX_R_OMO, pIomb, OSSA_OFFSET_OF(agsaOperatorMangmenRsp_t, OPRIDX_AUTIDX_R_OMO));
OSSA_READ_LE_32(AGROOT, &errorQualifier, pIomb, OSSA_OFFSET_OF(agsaOperatorMangmenRsp_t, errorQualifier));
SA_DBG2(("mpiOperatorManagementRsp:tag =0x%x\n",tag ));
SA_DBG2(("mpiOperatorManagementRsp:status =0x%x\n", status));
SA_DBG2(("mpiOperatorManagementRsp:OPRIDX_AUTIDX_R_OMO =0x%x\n",OPRIDX_AUTIDX_R_OMO ));
SA_DBG2(("mpiOperatorManagementRsp:errorQualifier =0x%x\n", errorQualifier));
/* get request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
if (agNULL == pRequest)
{
SA_DBG1(("mpiOperatorManagementRsp: Bad Response IOMB!!! pRequest is NULL. TAG=0x%x STATUS=0x%x\n", tag, status));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "36");
return AGSA_RC_FAILURE;
}
agContext = saRoot->IOMap[tag].agContext;
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
si_memset(&agEvent, 0, sizeof(agsaHWEventEncrypt_t));
agEvent.status = status;
agEvent.info = OPRIDX_AUTIDX_R_OMO;
agEvent.encryptOperation = OSSA_HW_ENCRYPT_OPERATOR_MANAGEMENT;
if (status == OPR_MGMT_MPI_ENC_ERR_OPR_PARAM_ILLEGAL)
{
agEvent.eq = errorQualifier;
}
ossaOperatorManagementCB(agRoot, agContext, status, errorQualifier);
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_ASSERT((pRequest->valid), "pRequest->valid");
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiOperatorManagementRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "36");
return AGSA_RC_SUCCESS;
}
GLOBAL bit32 mpiBistRsp(
agsaRoot_t *agRoot,
agsaEncryptBistRsp_t *pIomb
)
{
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
agsaContext_t *agContext;
agsaHWEventEncrypt_t agEvent;
bit32 status;
bit32 results[11];
bit32 length;
bit32 subop;
bit32 tag;
smTraceFuncEnter(hpDBG_VERY_LOUD,"37");
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaEncryptBistRsp_t, tag));
OSSA_READ_LE_32(AGROOT, &status, pIomb, OSSA_OFFSET_OF(agsaEncryptBistRsp_t, status));
OSSA_READ_LE_32(AGROOT, &subop, pIomb, OSSA_OFFSET_OF(agsaEncryptBistRsp_t, subop));
OSSA_READ_LE_32(AGROOT, &results[0], pIomb, OSSA_OFFSET_OF(agsaEncryptBistRsp_t, testResults[0]));
OSSA_READ_LE_32(AGROOT, &results[1], pIomb, OSSA_OFFSET_OF(agsaEncryptBistRsp_t, testResults[1]));
OSSA_READ_LE_32(AGROOT, &results[2], pIomb, OSSA_OFFSET_OF(agsaEncryptBistRsp_t, testResults[2]));
OSSA_READ_LE_32(AGROOT, &results[3], pIomb, OSSA_OFFSET_OF(agsaEncryptBistRsp_t, testResults[3]));
OSSA_READ_LE_32(AGROOT, &results[4], pIomb, OSSA_OFFSET_OF(agsaEncryptBistRsp_t, testResults[4]));
OSSA_READ_LE_32(AGROOT, &results[5], pIomb, OSSA_OFFSET_OF(agsaEncryptBistRsp_t, testResults[5]));
OSSA_READ_LE_32(AGROOT, &results[6], pIomb, OSSA_OFFSET_OF(agsaEncryptBistRsp_t, testResults[6]));
OSSA_READ_LE_32(AGROOT, &results[7], pIomb, OSSA_OFFSET_OF(agsaEncryptBistRsp_t, testResults[7]));
OSSA_READ_LE_32(AGROOT, &results[8], pIomb, OSSA_OFFSET_OF(agsaEncryptBistRsp_t, testResults[8]));
OSSA_READ_LE_32(AGROOT, &results[9], pIomb, OSSA_OFFSET_OF(agsaEncryptBistRsp_t, testResults[9]));
OSSA_READ_LE_32(AGROOT, &results[10], pIomb, OSSA_OFFSET_OF(agsaEncryptBistRsp_t, testResults[10]));
subop &= 0xFF;
SA_DBG1(("mpiBistRsp: HTag=0x%x subops =0x%x status =0x%x\n",pIomb->tag, subop, status));
switch(subop)
{
case AGSA_BIST_TEST:
length = sizeof(agsaEncryptSelfTestStatusBitMap_t);
break;
case AGSA_SHA_TEST:
length = sizeof(agsaEncryptSHATestResult_t);
break;
case AGSA_HMAC_TEST:
length = sizeof(agsaEncryptHMACTestResult_t);
break;
default:
length = 0;
break;
}
si_memset(&agEvent, 0, sizeof(agsaHWEventEncrypt_t));
agEvent.status = status;
agEvent.encryptOperation = OSSA_HW_ENCRYPT_TEST_EXECUTE;
agEvent.info = length;
agEvent.eq = subop;
agEvent.handle = agNULL;
agEvent.param = &results;
/* get request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
if (agNULL == pRequest)
{
SA_DBG1(("mpiBistRsp: Bad Response IOMB!!! pRequest is NULL. TAG=0x%x STATUS=0x%x\n", tag, status));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "37");
return AGSA_RC_FAILURE;
}
agContext = saRoot->IOMap[tag].agContext;
ossaHwCB(agRoot, NULL, OSSA_HW_EVENT_ENCRYPTION, 0, (void*)&agEvent, agContext);
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_ASSERT((pRequest->valid), "pRequest->valid");
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiBistRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "37");
return AGSA_RC_SUCCESS;
}
/******************************************************************************/
/*! \brief Set Operator Response
*
* This routine handles the response of the Operator management message
*
* \param agRoot Handles for this instance of SAS/SATA LLL
* \param pIomb Pointer of IOMB Mesage
*
* \return sucess or fail
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiSetOperatorRsp(
agsaRoot_t *agRoot,
agsaSetOperatorRsp_t *pIomb
)
{
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaIORequestDesc_t *pRequest = agNULL;
agsaContext_t *agContext = agNULL;
bit32 ERR_QLFR_OPRIDX_PIN_ACS, OPRIDX_PIN_ACS, status, errorQualifier, tag = 0;
smTraceFuncEnter(hpDBG_VERY_LOUD,"38");
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaSetOperatorRsp_t, tag));
OSSA_READ_LE_32(AGROOT, &status, pIomb, OSSA_OFFSET_OF(agsaSetOperatorRsp_t, status));
OSSA_READ_LE_32(AGROOT, &ERR_QLFR_OPRIDX_PIN_ACS, pIomb, OSSA_OFFSET_OF(agsaSetOperatorRsp_t, ERR_QLFR_OPRIDX_PIN_ACS));
errorQualifier = ERR_QLFR_OPRIDX_PIN_ACS >> 16;
OPRIDX_PIN_ACS = ERR_QLFR_OPRIDX_PIN_ACS & 0xFFFF;
SA_DBG1(("mpiSetOperatorRsp: HTag=0x%x ERR_QLFR=0x%x OPRIDX_PIN_ACS=0x%x \n",tag, errorQualifier, OPRIDX_PIN_ACS));
/* get request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
if (agNULL == pRequest)
{
SA_DBG1(("mpiSetOperatorRsp: Bad Response IOMB!!! pRequest is NULL. TAG=0x%x STATUS=0x%x\n", tag, status));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "38");
return AGSA_RC_FAILURE;
}
agContext = saRoot->IOMap[tag].agContext;
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
ossaSetOperatorCB(agRoot,agContext,status,errorQualifier );
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_ASSERT((pRequest->valid), "pRequest->valid");
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiSetOperatorRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "38");
return AGSA_RC_SUCCESS;
}
/******************************************************************************/
/*! \brief Get Operator Response
*
* This routine handles the response of the Operator management message
*
* \param agRoot Handles for this instance of SAS/SATA LLL
* \param pIomb Pointer of IOMB Mesage
*
* \return sucess or fail
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiGetOperatorRsp(
agsaRoot_t *agRoot,
agsaGetOperatorRsp_t *pIomb
)
{
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
agsaContext_t *agContext;
bit32 Num_Option, NumOperators ,status, tag;
bit8 option, Role = 0;
bit32 IDstr[8];
bit8 *tmpIDstr = agNULL;
agsaID_t *IDString = agNULL;
smTraceFuncEnter(hpDBG_VERY_LOUD,"3f");
si_memset(&IDstr, 0, sizeof(IDstr));
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaGetOperatorRsp_t, tag));
OSSA_READ_LE_32(AGROOT, &status, pIomb, OSSA_OFFSET_OF(agsaGetOperatorRsp_t, status));
OSSA_READ_LE_32(AGROOT, &Num_Option, pIomb, OSSA_OFFSET_OF(agsaGetOperatorRsp_t, Num_Option));
OSSA_READ_LE_32(AGROOT, &IDstr[0], pIomb, OSSA_OFFSET_OF(agsaGetOperatorRsp_t, IDString[0]));
OSSA_READ_LE_32(AGROOT, &IDstr[1], pIomb, OSSA_OFFSET_OF(agsaGetOperatorRsp_t, IDString[1]));
OSSA_READ_LE_32(AGROOT, &IDstr[2], pIomb, OSSA_OFFSET_OF(agsaGetOperatorRsp_t, IDString[2]));
OSSA_READ_LE_32(AGROOT, &IDstr[3], pIomb, OSSA_OFFSET_OF(agsaGetOperatorRsp_t, IDString[3]));
OSSA_READ_LE_32(AGROOT, &IDstr[4], pIomb, OSSA_OFFSET_OF(agsaGetOperatorRsp_t, IDString[4]));
OSSA_READ_LE_32(AGROOT, &IDstr[5], pIomb, OSSA_OFFSET_OF(agsaGetOperatorRsp_t, IDString[5]));
OSSA_READ_LE_32(AGROOT, &IDstr[6], pIomb, OSSA_OFFSET_OF(agsaGetOperatorRsp_t, IDString[6]));
OSSA_READ_LE_32(AGROOT, &IDstr[7], pIomb, OSSA_OFFSET_OF(agsaGetOperatorRsp_t, IDString[7]));
SA_DBG1(("mpiGetOperatorRsp:tag=0x%x status=0x%x Num_Option=0x%x IDString_Role=0x%x\n",
tag, status, Num_Option, IDstr[0]));
/* get request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
if (agNULL == pRequest)
{
SA_DBG1(("mpiGetOperatorRsp: Bad Response IOMB!!! pRequest is NULL. TAG=0x%x STATUS=0x%x\n", tag, status));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "3f");
return AGSA_RC_FAILURE;
}
agContext = saRoot->IOMap[tag].agContext;
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
option = Num_Option & 0xFF;
NumOperators = (Num_Option >> SHIFT8) & 0xFF;
/* current operator's Role/ID, valid only if option == 1 */
if ( option == 1)
{
/* extra the role value as parameter */
Role = IDstr[0] & 0xFF;
tmpIDstr = (bit8*)&IDstr[0];
tmpIDstr++; /* skip role byte */
IDString = (agsaID_t *)tmpIDstr;
SA_DBG1(("mpiGetOperatorRsp: OSSA_IO_SUCCESS\n"));
SA_DBG2(("mpiGetOperatorRsp: 0x%02x 0x%02x 0x%02x 0x%02x\n",IDString->ID[0], IDString->ID[1], IDString->ID[2], IDString->ID[3]));
SA_DBG2(("mpiGetOperatorRsp: 0x%02x 0x%02x 0x%02x 0x%02x\n",IDString->ID[4], IDString->ID[5], IDString->ID[6], IDString->ID[7]));
SA_DBG2(("mpiGetOperatorRsp: 0x%02x 0x%02x 0x%02x 0x%02x\n",IDString->ID[8], IDString->ID[9], IDString->ID[10],IDString->ID[11]));
SA_DBG2(("mpiGetOperatorRsp: 0x%02x 0x%02x 0x%02x 0x%02x\n",IDString->ID[12],IDString->ID[13],IDString->ID[14],IDString->ID[15]));
SA_DBG2(("mpiGetOperatorRsp: 0x%02x 0x%02x 0x%02x 0x%02x\n",IDString->ID[16],IDString->ID[17],IDString->ID[18],IDString->ID[19]));
SA_DBG2(("mpiGetOperatorRsp: 0x%02x 0x%02x 0x%02x 0x%02x\n",IDString->ID[20],IDString->ID[21],IDString->ID[22],IDString->ID[23]));
SA_DBG2(("mpiGetOperatorRsp: 0x%02x 0x%02x 0x%02x 0x%02x\n",IDString->ID[24],IDString->ID[25],IDString->ID[26],IDString->ID[27]));
SA_DBG2(("mpiGetOperatorRsp: 0x%02x 0x%02x 0x%02x\n", IDString->ID[28],IDString->ID[29],IDString->ID[30]));
}
SA_DBG1(("mpiGetOperatorRsp:status 0x%x option 0x%x Role 0x%x\n",status,option,Role ));
ossaGetOperatorCB(agRoot,agContext,status,option,NumOperators ,Role,IDString );
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_ASSERT((pRequest->valid), "pRequest->valid");
pRequest->valid = agFALSE;
/* return the request to free pool */
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiGetOperatorRsp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "3f");
return AGSA_RC_SUCCESS;
}
GLOBAL bit32 mpiGetVHistRsp(
agsaRoot_t *agRoot,
agsaGetVHistCapRsp_t *pIomb
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = agNULL;
agsaIORequestDesc_t *pRequest;
agsaContext_t *agContext;
bit32 tag = 0; /* 1 */
bit32 status = 0; /* 2 */
bit32 channel; /* 3 */
bit32 BistLo; /* 4 */
bit32 BistHi; /* 5 */
bit32 BytesXfered = 0; /* 6 */
bit32 PciLo; /* 7 */
bit32 PciHi; /* 8 */
bit32 PciBytecount = 0; /* 9 */
smTraceFuncEnter(hpDBG_VERY_LOUD,"3K");
/* sanity check */
SA_ASSERT((agNULL != agRoot), "");
saRoot = (agsaLLRoot_t *) (agRoot->sdkData);
SA_ASSERT((agNULL != saRoot), "");
if(smIS_SPC12V(agRoot))
{
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaGetVHistCapRsp_t,tag));
OSSA_READ_LE_32(AGROOT, &status, pIomb, OSSA_OFFSET_OF(agsaGetVHistCapRsp_t,status));
OSSA_READ_LE_32(AGROOT, &channel, pIomb, OSSA_OFFSET_OF(agsaGetVHistCapRsp_t,channel));
OSSA_READ_LE_32(AGROOT, &BistLo, pIomb, OSSA_OFFSET_OF(agsaGetVHistCapRsp_t,BistLo));
OSSA_READ_LE_32(AGROOT, &BistHi, pIomb, OSSA_OFFSET_OF(agsaGetVHistCapRsp_t,BistHi));
OSSA_READ_LE_32(AGROOT, &BytesXfered, pIomb, OSSA_OFFSET_OF(agsaGetVHistCapRsp_t,BytesXfered));
OSSA_READ_LE_32(AGROOT, &PciLo, pIomb, OSSA_OFFSET_OF(agsaGetVHistCapRsp_t,PciLo));
OSSA_READ_LE_32(AGROOT, &PciHi, pIomb, OSSA_OFFSET_OF(agsaGetVHistCapRsp_t,PciHi));
OSSA_READ_LE_32(AGROOT, &PciBytecount, pIomb, OSSA_OFFSET_OF(agsaGetVHistCapRsp_t,PciBytecount));
}
else
{
/* SPC does not support this command */
SA_DBG1(("mpiGetVHistRsp: smIS_SPC12V only\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "3K");
return AGSA_RC_FAILURE;
}
SA_DBG3(("mpiGetVHistRsp: HTag=0x%x\n", tag));
/* get request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
if (agNULL == pRequest)
{
SA_DBG1(("mpiGetVHistRsp: Bad Response IOMB!!! pRequest is NULL. TAG=0x%x STATUS=0x%x\n", tag, status));
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "3K");
return AGSA_RC_FAILURE;
}
agContext = saRoot->IOMap[tag].agContext;
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
SA_ASSERT((pRequest->valid), "pRequest->valid");
/* check status success or failure */
if (status)
{
SA_DBG1(("mpiGetVHistRsp: status is FAILED, status = %x\n", status ));
if (pRequest->completionCB == agNULL)
{
ossaVhistCaptureCB(agRoot, agContext, status, BytesXfered);
}
else
{
(*(ossaVhistCaptureCB_t)(pRequest->completionCB))(agRoot, agContext, status, BytesXfered);
}
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "3K");
return AGSA_RC_FAILURE;
}
/* status is SUCCESS */
SA_DBG1(("mpiGetVHistRsp: status is SUCCESS\n" ));
if (pRequest->completionCB == agNULL)
{
ossaVhistCaptureCB(agRoot, agContext, status, BytesXfered);
}
else
{
(*(ossaVhistCaptureCB_t)(pRequest->completionCB))(agRoot, agContext, status, BytesXfered);
}
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
/* return value */
smTraceFuncExit(hpDBG_VERY_LOUD, 'd', "3K");
return ret;
}
/******************************************************************************/
/*! \brief DifEncOffload Response
*
* This routine handles the response of the DifEncOffload Response
*
* \param agRoot Handles for this instance of SAS/SATA LLL
* \param pIomb Pointer of IOMB Mesage
*
* \return sucess or fail
*
*/
/*******************************************************************************/
GLOBAL bit32 mpiDifEncOffloadRsp(
agsaRoot_t *agRoot,
agsaDifEncOffloadRspV_t *pIomb
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
agsaContext_t *agContext;
bit32 tag, status;
agsaOffloadDifDetails_t details;
smTraceFuncEnter(hpDBG_VERY_LOUD,"3F");
OSSA_READ_LE_32(AGROOT, &tag, pIomb, OSSA_OFFSET_OF(agsaDifEncOffloadRspV_t, tag));
OSSA_READ_LE_32(AGROOT, &status, pIomb, OSSA_OFFSET_OF(agsaDifEncOffloadRspV_t, status));
/* get TAG */
SA_DBG3(("mpiDifEncOffloadRsp: HTag=0x%x\n", tag));
/* get request from IOMap */
pRequest = (agsaIORequestDesc_t*)saRoot->IOMap[tag].IORequest;
if (agNULL == pRequest)
{
SA_DBG1(("mpiDifEncOffloadRsp: Bad Response IOMB!!! pRequest is NULL. TAG=0x%x STATUS=0x%x\n", tag, status));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "3F");
return AGSA_RC_FAILURE;
}
agContext = saRoot->IOMap[tag].agContext;
/* remove the request from IOMap */
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
SA_ASSERT((pRequest->valid), "pRequest->valid");
/* check status success or failure */
if (status)
{
SA_DBG1(("mpiDifEncOffloadRsp: status is FAILED, status = %x\n", status ));
if (status == OSSA_IO_XFR_ERROR_DIF_MISMATCH || status == OSSA_IO_XFR_ERROR_DIF_APPLICATION_TAG_MISMATCH ||
status == OSSA_IO_XFR_ERROR_DIF_REFERENCE_TAG_MISMATCH || status == OSSA_IO_XFR_ERROR_DIF_CRC_MISMATCH)
{
si_memset(&details, 0, sizeof(agsaOffloadDifDetails_t));
OSSA_READ_LE_32(AGROOT, &details.ExpectedCRCUDT01, pIomb, OSSA_OFFSET_OF(agsaDifEncOffloadRspV_t, ExpectedCRCUDT01));
OSSA_READ_LE_32(AGROOT, &details.ExpectedUDT2345, pIomb, OSSA_OFFSET_OF(agsaDifEncOffloadRspV_t, ExpectedUDT2345));
OSSA_READ_LE_32(AGROOT, &details.ActualCRCUDT01, pIomb, OSSA_OFFSET_OF(agsaDifEncOffloadRspV_t, ActualCRCUDT01));
OSSA_READ_LE_32(AGROOT, &details.ActualUDT2345, pIomb, OSSA_OFFSET_OF(agsaDifEncOffloadRspV_t, ActualUDT2345));
OSSA_READ_LE_32(AGROOT, &details.DIFErr, pIomb, OSSA_OFFSET_OF(agsaDifEncOffloadRspV_t, DIFErr));
OSSA_READ_LE_32(AGROOT, &details.ErrBoffset, pIomb, OSSA_OFFSET_OF(agsaDifEncOffloadRspV_t, ErrBoffset));
if (pRequest->completionCB == agNULL)
{
ossaDIFEncryptionOffloadStartCB(agRoot, agContext, status, &details);
}
else
{
(*(ossaDIFEncryptionOffloadStartCB_t)(pRequest->completionCB))(agRoot, agContext, status, &details);
}
}
else
{
if (pRequest->completionCB == agNULL)
{
ossaDIFEncryptionOffloadStartCB(agRoot, agContext, status, agNULL);
}
else
{
(*(ossaDIFEncryptionOffloadStartCB_t)(pRequest->completionCB))(agRoot, agContext, status, agNULL);
}
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "3F");
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
return AGSA_RC_FAILURE;
}
/* status is SUCCESS */
SA_DBG1(("mpiDifEncOffloadRsp: status is SUCCESS\n" ));
if (pRequest->completionCB == agNULL)
{
ossaDIFEncryptionOffloadStartCB(agRoot, agContext, status, agNULL);
}
else
{
(*(ossaDIFEncryptionOffloadStartCB_t)(pRequest->completionCB))(agRoot, agContext, status, agNULL);
}
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
/* return the request to free pool */
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
/* return value */
smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "3F");
return ret;
}