#include <sys/cdefs.h>
#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 'H'
#endif
extern bit32 gFPGA_TEST;
extern bit32 gWait_3;
extern bit32 gWait_2;
LOCAL bit32 siGSMDump(
agsaRoot_t *agRoot,
bit32 gsmDumpOffset,
bit32 length,
void *directData);
#ifdef SPC_ENABLE_PROFILE
GLOBAL bit32 saFwProfile(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 queueNum,
agsaFwProfile_t *fwProfileInfo
)
{
bit32 ret = AGSA_RC_SUCCESS, retVal;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *) (agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
mpiICQueue_t *circularQ;
void *pMessage;
agsaFwProfileIOMB_t *pPayload;
bit8 inq, outq;
bit32 i, tcid_processor_cmd = 0;
SA_ASSERT((agNULL != agRoot), "");
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest = (agsaIORequestDesc_t *)saLlistGetHead(&(saRoot->freeIORequests));
if ( agNULL == pRequest )
{
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_DBG1(("saFwProfile, No request from free list\n" ));
return AGSA_RC_BUSY;
}
else
{
inq = (bit8)(queueNum & MPI_IB_NUM_MASK);
outq = (bit8)((queueNum & MPI_OB_NUM_MASK) >> MPI_OB_SHIFT);
SA_ASSERT((AGSA_MAX_INBOUND_Q > inq), "The IBQ Number is out of range.");
saLlistRemove(&(saRoot->freeIORequests), &(pRequest->linkNode));
saRoot->IOMap[pRequest->HTag].Tag = pRequest->HTag;
saRoot->IOMap[pRequest->HTag].IORequest = (void *)pRequest;
saRoot->IOMap[pRequest->HTag].agContext = agContext;
pRequest->valid = agTRUE;
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
#ifdef SA_LL_IBQ_PROTECT
ossaSingleThreadedEnter(agRoot, LL_IOREQ_IBQ0_LOCK + inq);
#endif
circularQ = &saRoot->inboundQueue[inq];
retVal = mpiMsgFreeGet(circularQ, IOMB_SIZE64, &pMessage);
if (AGSA_RC_FAILURE == retVal)
{
#ifdef SA_LL_IBQ_PROTECT
ossaSingleThreadedLeave(agRoot, LL_IOREQ_IBQ0_LOCK + inq);
#endif
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
saRoot->IOMap[pRequest->HTag].Tag = MARK_OFF;
saRoot->IOMap[pRequest->HTag].IORequest = agNULL;
saRoot->IOMap[pRequest->HTag].agContext = agNULL;
pRequest->valid = agFALSE;
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_DBG1(("saFwProfile, error when get free IOMB\n"));
return AGSA_RC_FAILURE;
}
if (AGSA_RC_BUSY == retVal)
{
#ifdef SA_LL_IBQ_PROTECT
ossaSingleThreadedLeave(agRoot, LL_IOREQ_IBQ0_LOCK + inq);
#endif
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
saRoot->IOMap[pRequest->HTag].Tag = MARK_OFF;
saRoot->IOMap[pRequest->HTag].IORequest = agNULL;
saRoot->IOMap[pRequest->HTag].agContext = agNULL;
pRequest->valid = agFALSE;
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_DBG1(("saFwProfile, no more IOMB\n"));
return AGSA_RC_BUSY;
}
pPayload = (agsaFwProfileIOMB_t *)pMessage;
tcid_processor_cmd = (((fwProfileInfo->tcid)<< 16) | ((fwProfileInfo->processor)<< 8) | fwProfileInfo->cmd);
OSSA_WRITE_LE_32(agRoot, pPayload, OSSA_OFFSET_OF(agsaFwProfileIOMB_t, tag), pRequest->HTag);
OSSA_WRITE_LE_32(agRoot, pPayload, OSSA_OFFSET_OF(agsaFwProfileIOMB_t, tcid_processor_cmd), tcid_processor_cmd);
OSSA_WRITE_LE_32(agRoot, pPayload, OSSA_OFFSET_OF(agsaFwProfileIOMB_t, codeStartAdd), fwProfileInfo->codeStartAdd);
OSSA_WRITE_LE_32(agRoot, pPayload, OSSA_OFFSET_OF(agsaFwProfileIOMB_t, codeEndAdd), fwProfileInfo->codeEndAdd);
pPayload->SGLAL = fwProfileInfo->agSgl.sgLower;
pPayload->SGLAH = fwProfileInfo->agSgl.sgUpper;
pPayload->Len = fwProfileInfo->agSgl.len;
pPayload->extReserved = fwProfileInfo->agSgl.extReserved;
for (i = 0; i < FWPROFILE_IOMB_RESERVED_LEN; i ++)
{
pPayload->reserved0[i] = 0;
}
ret = mpiMsgProduce(circularQ, (void *)pMessage, MPI_CATEGORY_SAS_SATA, OPC_INB_FW_PROFILE, outq, (bit8)circularQ->priority);
#ifdef SA_LL_IBQ_PROTECT
ossaSingleThreadedLeave(agRoot, LL_IOREQ_IBQ0_LOCK + inq);
#endif
if (AGSA_RC_FAILURE == ret)
{
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
saRoot->IOMap[pRequest->HTag].Tag = MARK_OFF;
saRoot->IOMap[pRequest->HTag].IORequest = agNULL;
saRoot->IOMap[pRequest->HTag].agContext = agNULL;
pRequest->valid = agFALSE;
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_DBG1(("saFwProfile, error when post FW_PROFILE IOMB\n"));
}
}
return ret;
}
#endif
GLOBAL bit32 saFwFlashUpdate(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 queueNum,
agsaUpdateFwFlash_t *flashUpdateInfo
)
{
bit32 ret = AGSA_RC_SUCCESS, retVal;
agsaLLRoot_t *saRoot;
agsaIORequestDesc_t *pRequest;
mpiICQueue_t *circularQ;
void *pMessage;
agsaFwFlashUpdate_t *pPayload;
bit8 inq, outq;
bit32 i;
SA_ASSERT((agNULL != agRoot), "");
if (agRoot == agNULL)
{
SA_DBG1(("saFwFlashUpdate: agRoot == agNULL\n"));
return AGSA_RC_FAILURE;
}
saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
SA_ASSERT((agNULL != saRoot), "");
if (saRoot == agNULL)
{
SA_DBG1(("saFwFlashUpdate: saRoot == agNULL\n"));
return AGSA_RC_FAILURE;
}
smTraceFuncEnter(hpDBG_VERY_LOUD, "6a");
SA_ASSERT((agNULL != agRoot), "");
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest = (agsaIORequestDesc_t *)saLlistIOGetHead(&(saRoot->freeIORequests));
if ( agNULL == pRequest ) {
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_DBG1(("saFwFlashUpdate, No request from free list\n" ));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "6a");
return AGSA_RC_BUSY;
}
else
{
inq = (bit8)(queueNum & MPI_IB_NUM_MASK);
outq = (bit8)((queueNum & MPI_OB_NUM_MASK) >> MPI_OB_SHIFT);
SA_ASSERT((AGSA_MAX_INBOUND_Q > inq), "The IBQ Number is out of range.");
saLlistIORemove(&(saRoot->freeIORequests), &(pRequest->linkNode));
saRoot->IOMap[pRequest->HTag].Tag = pRequest->HTag;
saRoot->IOMap[pRequest->HTag].IORequest = (void *)pRequest;
saRoot->IOMap[pRequest->HTag].agContext = agContext;
pRequest->valid = agTRUE;
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
#ifdef SA_LL_IBQ_PROTECT
ossaSingleThreadedEnter(agRoot, LL_IOREQ_IBQ0_LOCK + inq);
#endif
circularQ = &saRoot->inboundQueue[inq];
retVal = mpiMsgFreeGet(circularQ, IOMB_SIZE64, &pMessage);
if (AGSA_RC_FAILURE == retVal)
{
#ifdef SA_LL_IBQ_PROTECT
ossaSingleThreadedLeave(agRoot, LL_IOREQ_IBQ0_LOCK + inq);
#endif
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
saRoot->IOMap[pRequest->HTag].Tag = MARK_OFF;
saRoot->IOMap[pRequest->HTag].IORequest = agNULL;
saRoot->IOMap[pRequest->HTag].agContext = agNULL;
pRequest->valid = agFALSE;
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_DBG1(("saFwFlashUpdate, error when get free IOMB\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "6a");
return AGSA_RC_FAILURE;
}
if (AGSA_RC_BUSY == retVal)
{
#ifdef SA_LL_IBQ_PROTECT
ossaSingleThreadedLeave(agRoot, LL_IOREQ_IBQ0_LOCK + inq);
#endif
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
saRoot->IOMap[pRequest->HTag].Tag = MARK_OFF;
saRoot->IOMap[pRequest->HTag].IORequest = agNULL;
saRoot->IOMap[pRequest->HTag].agContext = agNULL;
pRequest->valid = agFALSE;
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_DBG1(("saFwFlashUpdate, no more IOMB\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "6a");
return AGSA_RC_BUSY;
}
pPayload = (agsaFwFlashUpdate_t *)pMessage;
OSSA_WRITE_LE_32( agRoot, pPayload,
OSSA_OFFSET_OF(agsaFwFlashUpdate_t, tag), pRequest->HTag);
OSSA_WRITE_LE_32( agRoot, pPayload,
OSSA_OFFSET_OF(agsaFwFlashUpdate_t, curImageOffset),
flashUpdateInfo->currentImageOffset);
OSSA_WRITE_LE_32( agRoot, pPayload,
OSSA_OFFSET_OF(agsaFwFlashUpdate_t, curImageLen),
flashUpdateInfo->currentImageLen);
OSSA_WRITE_LE_32( agRoot, pPayload,
OSSA_OFFSET_OF(agsaFwFlashUpdate_t, totalImageLen),
flashUpdateInfo->totalImageLen);
pPayload->SGLAL = flashUpdateInfo->agSgl.sgLower;
pPayload->SGLAH = flashUpdateInfo->agSgl.sgUpper;
pPayload->Len = flashUpdateInfo->agSgl.len;
pPayload->extReserved = flashUpdateInfo->agSgl.extReserved;
for (i = 0; i < FWFLASH_IOMB_RESERVED_LEN; i ++) {
pPayload->reserved0[i] = 0;
}
ret = mpiMsgProduce( circularQ, (void *)pMessage, MPI_CATEGORY_SAS_SATA,
OPC_INB_FW_FLASH_UPDATE, outq, (bit8)circularQ->priority);
#ifdef SA_LL_IBQ_PROTECT
ossaSingleThreadedLeave( agRoot, LL_IOREQ_IBQ0_LOCK + inq );
#endif
if (AGSA_RC_FAILURE == ret) {
ossaSingleThreadedEnter( agRoot, LL_IOREQ_LOCKEQ_LOCK );
saRoot->IOMap[pRequest->HTag].Tag = MARK_OFF;
saRoot->IOMap[pRequest->HTag].IORequest = agNULL;
saRoot->IOMap[pRequest->HTag].agContext = agNULL;
pRequest->valid = agFALSE;
saLlistIOAdd( &(saRoot->freeIORequests), &(pRequest->linkNode) );
ossaSingleThreadedLeave( agRoot, LL_IOREQ_LOCKEQ_LOCK );
SA_DBG1( ("saFwFlashUpdate, error when post FW_FLASH_UPDATE IOMB\n") );
}
}
smTraceFuncExit( hpDBG_VERY_LOUD, 'd', "6a" );
return ret;
}
GLOBAL bit32 saFlashExtExecute (
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 queueNum,
agsaFlashExtExecute_t *agFlashExtExe)
{
bit32 ret = AGSA_RC_SUCCESS, retVal;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *) (agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
mpiICQueue_t *circularQ;
void *pMessage;
agsaFwFlashOpExt_t *pPayload;
bit8 inq, outq;
smTraceFuncEnter(hpDBG_VERY_LOUD,"2R");
SA_ASSERT((agNULL != agRoot), "");
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest = (agsaIORequestDesc_t *)saLlistIOGetHead(&(saRoot->freeIORequests));
if ( agNULL == pRequest )
{
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_DBG1(("saFlashExtExecute, No request from free list\n" ));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2R");
return AGSA_RC_BUSY;
}
else
{
inq = (bit8)(queueNum & MPI_IB_NUM_MASK);
outq = (bit8)((queueNum & MPI_OB_NUM_MASK) >> MPI_OB_SHIFT);
SA_ASSERT((AGSA_MAX_INBOUND_Q > inq), "The IBQ Number is out of range.");
saLlistIORemove(&(saRoot->freeIORequests), &(pRequest->linkNode));
saRoot->IOMap[pRequest->HTag].Tag = pRequest->HTag;
saRoot->IOMap[pRequest->HTag].IORequest = (void *)pRequest;
saRoot->IOMap[pRequest->HTag].agContext = agContext;
pRequest->valid = agTRUE;
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
#ifdef SA_LL_IBQ_PROTECT
ossaSingleThreadedEnter(agRoot, LL_IOREQ_IBQ0_LOCK + inq);
#endif
circularQ = &saRoot->inboundQueue[inq];
retVal = mpiMsgFreeGet(circularQ, IOMB_SIZE64, &pMessage);
if (AGSA_RC_FAILURE == retVal)
{
#ifdef SA_LL_IBQ_PROTECT
ossaSingleThreadedLeave(agRoot, LL_IOREQ_IBQ0_LOCK + inq);
#endif
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
saRoot->IOMap[pRequest->HTag].Tag = MARK_OFF;
saRoot->IOMap[pRequest->HTag].IORequest = agNULL;
saRoot->IOMap[pRequest->HTag].agContext = agNULL;
pRequest->valid = agFALSE;
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_DBG1(("saFlashExtExecute, error when get free IOMB\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "2R");
return AGSA_RC_FAILURE;
}
if (AGSA_RC_BUSY == retVal)
{
#ifdef SA_LL_IBQ_PROTECT
ossaSingleThreadedLeave(agRoot, LL_IOREQ_IBQ0_LOCK + inq);
#endif
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
saRoot->IOMap[pRequest->HTag].Tag = MARK_OFF;
saRoot->IOMap[pRequest->HTag].IORequest = agNULL;
saRoot->IOMap[pRequest->HTag].agContext = agNULL;
pRequest->valid = agFALSE;
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_DBG3(("saFlashExtExecute, no more IOMB\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "2R");
return AGSA_RC_BUSY;
}
pPayload = (agsaFwFlashOpExt_t *)pMessage;
si_memset(pPayload, 0, sizeof(agsaFwFlashOpExt_t));
OSSA_WRITE_LE_32(agRoot, pPayload, OSSA_OFFSET_OF(agsaFwFlashOpExt_t, tag), pRequest->HTag);
OSSA_WRITE_LE_32(agRoot, pPayload, OSSA_OFFSET_OF(agsaFwFlashOpExt_t,Command ), agFlashExtExe->command);
OSSA_WRITE_LE_32(agRoot, pPayload, OSSA_OFFSET_OF(agsaFwFlashOpExt_t,PartOffset ), agFlashExtExe->partOffset);
OSSA_WRITE_LE_32(agRoot, pPayload, OSSA_OFFSET_OF(agsaFwFlashOpExt_t,DataLength ), agFlashExtExe->dataLen);
OSSA_WRITE_LE_32(agRoot, pPayload, OSSA_OFFSET_OF(agsaFwFlashOpExt_t,SGLAL ), agFlashExtExe->agSgl->sgLower);
OSSA_WRITE_LE_32(agRoot, pPayload, OSSA_OFFSET_OF(agsaFwFlashOpExt_t,SGLAH ), agFlashExtExe->agSgl->sgUpper);
OSSA_WRITE_LE_32(agRoot, pPayload, OSSA_OFFSET_OF(agsaFwFlashOpExt_t,Len ), agFlashExtExe->agSgl->len);
OSSA_WRITE_LE_32(agRoot, pPayload, OSSA_OFFSET_OF(agsaFwFlashOpExt_t,E_sgl ), agFlashExtExe->agSgl->extReserved);
ret = mpiMsgProduce(circularQ, (void *)pMessage, MPI_CATEGORY_SAS_SATA, OPC_INB_FLASH_OP_EXT, outq, (bit8)circularQ->priority);
#ifdef SA_LL_IBQ_PROTECT
ossaSingleThreadedLeave(agRoot, LL_IOREQ_IBQ0_LOCK + inq);
#endif
if (AGSA_RC_FAILURE == ret)
{
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
saRoot->IOMap[pRequest->HTag].Tag = MARK_OFF;
saRoot->IOMap[pRequest->HTag].IORequest = agNULL;
saRoot->IOMap[pRequest->HTag].agContext = agNULL;
pRequest->valid = agFALSE;
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_DBG1(("saFlashExtExecute, error when post FW_FLASH_UPDATE IOMB\n"));
}
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'd', "2R");
return ret;
}
#ifdef SPC_ENABLE_PROFILE
GLOBAL bit32 mpiFwProfileRsp(
agsaRoot_t *agRoot,
agsaFwProfileRsp_t *payload
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *) (agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
agsaContext_t *agContext;
bit32 status, tag, len;
OSSA_READ_LE_32(AGROOT, &tag, payload, OSSA_OFFSET_OF(agsaFwProfileRsp_t, tag));
OSSA_READ_LE_32(AGROOT, &status, payload, OSSA_OFFSET_OF(agsaFwProfileRsp_t, status));
OSSA_READ_LE_32(AGROOT, &len, payload, OSSA_OFFSET_OF(agsaFwProfileRsp_t, len));
pRequest = saRoot->IOMap[tag].IORequest;
if (agNULL == pRequest)
{
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
SA_DBG1(("mpiFwProfileRsp: the request is NULL. Tag=%x\n", tag));
return AGSA_RC_FAILURE;
}
agContext = saRoot->IOMap[tag].agContext;
saRoot->IOMap[tag].Tag = MARK_OFF;
saRoot->IOMap[tag].IORequest = agNULL;
saRoot->IOMap[tag].agContext = agNULL;
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
if(!pRequest->valid)
{
SA_DBG1(("mpiPortControlRsp: pRequest->valid %d not set\n", pRequest->valid));
}
SA_ASSERT((pRequest->valid), "pRequest->valid");
pRequest->valid = agFALSE;
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
ossaFwProfileCB(agRoot, agContext, status, len);
return ret;
}
#endif
GLOBAL bit32 mpiFwFlashUpdateRsp(
agsaRoot_t *agRoot,
agsaFwFlashUpdateRsp_t *payload
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *) (agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
agsaContext_t *agContext;
bit32 status, tag;
smTraceFuncEnter(hpDBG_VERY_LOUD,"6b");
OSSA_READ_LE_32(AGROOT, &tag, payload, OSSA_OFFSET_OF(agsaFwFlashUpdateRsp_t, tag));
OSSA_READ_LE_32(AGROOT, &status, payload, OSSA_OFFSET_OF(agsaFwFlashUpdateRsp_t, status));
pRequest = saRoot->IOMap[tag].IORequest;
agContext = saRoot->IOMap[tag].agContext;
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;
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiFwFlashUpdateRsp: 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);
if(status > 1)
{
SA_DBG1(("mpiFwFlashUpdateRsp: status = 0x%x\n",status));
}
ossaFwFlashUpdateCB(agRoot, agContext, status);
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "6b");
return ret;
}
GLOBAL bit32 mpiFwExtFlashUpdateRsp(
agsaRoot_t *agRoot,
agsaFwFlashOpExtRsp_t *payload
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *) (agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
agsaContext_t *agContext;
agsaFlashExtResponse_t FlashExtRsp;
bit32 Command,Status, tag;
smTraceFuncEnter(hpDBG_VERY_LOUD,"2T");
OSSA_READ_LE_32(AGROOT, &tag, payload, OSSA_OFFSET_OF(agsaFwFlashOpExtRsp_t, tag));
OSSA_READ_LE_32(AGROOT, &Command, payload, OSSA_OFFSET_OF(agsaFwFlashOpExtRsp_t,Command ));
OSSA_READ_LE_32(AGROOT, &Status, payload, OSSA_OFFSET_OF(agsaFwFlashOpExtRsp_t,Status ));
OSSA_READ_LE_32(AGROOT, &FlashExtRsp.epart_sect_size, payload, OSSA_OFFSET_OF(agsaFwFlashOpExtRsp_t,Epart_Size ));
OSSA_READ_LE_32(AGROOT, &FlashExtRsp.epart_size, payload, OSSA_OFFSET_OF(agsaFwFlashOpExtRsp_t,EpartSectSize ));
pRequest = saRoot->IOMap[tag].IORequest;
agContext = saRoot->IOMap[tag].agContext;
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;
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("mpiFwExtFlashUpdateRsp: 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);
if(Status > 1)
{
SA_DBG1(("mpiFwExtFlashUpdateRsp: status = 0x%x\n",Status));
}
ossaFlashExtExecuteCB(agRoot, agContext, Status,Command,&FlashExtRsp);
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2T");
return ret;
}
GLOBAL bit32 saGetControllerInfo(
agsaRoot_t *agRoot,
agsaControllerInfo_t *controllerInfo
)
{
bit32 ret = AGSA_RC_SUCCESS;
bit32 max_wait_time;
bit32 max_wait_count;
bit32 ContrlCapFlag, MSGUCfgTblBase, CfgTblDWIdx;
bit32 value = 0, value1 = 0;
bit8 pcibar;
if (agNULL != agRoot->sdkData)
{
smTraceFuncEnter(hpDBG_VERY_LOUD,"6e");
}
si_memset(controllerInfo, 0, sizeof(agsaControllerInfo_t));
if(smIS_SPC6V(agRoot))
{
controllerInfo->sdkInterfaceRev = STSDK_LL_INTERFACE_VERSION;
controllerInfo->sdkRevision = STSDK_LL_VERSION;
controllerInfo->hwRevision = (ossaHwRegReadConfig32(agRoot,8) & 0xFF);
}else if(smIS_SPC12V(agRoot))
{
controllerInfo->sdkInterfaceRev = STSDK_LL_12G_INTERFACE_VERSION;
controllerInfo->sdkRevision = STSDK_LL_12G_VERSION;
controllerInfo->hwRevision = (ossaHwRegReadConfig32(agRoot,8) & 0xFF);
} else if(smIS_SPC(agRoot))
{
controllerInfo->hwRevision = SPC_READ_DEV_REV;
controllerInfo->sdkInterfaceRev = MATCHING_SPC_FW_VERSION;
controllerInfo->sdkRevision = STSDK_LL_SPC_VERSION;
}
else
{
controllerInfo->hwRevision = (ossaHwRegReadConfig32(agRoot,8) & 0xFF);
}
SA_DBG1(("saGetControllerInfo: SCRATCH_PAD0 value = 0x%x\n", siHalRegReadExt(agRoot,GEN_MSGU_SCRATCH_PAD_0, MSGU_SCRATCH_PAD_0)));
SA_DBG1(("saGetControllerInfo: SCRATCH_PAD1 value = 0x%x\n", siHalRegReadExt(agRoot,GEN_MSGU_SCRATCH_PAD_1, MSGU_SCRATCH_PAD_1)));
SA_DBG1(("saGetControllerInfo: SCRATCH_PAD2 value = 0x%x\n", siHalRegReadExt(agRoot,GEN_MSGU_SCRATCH_PAD_2, MSGU_SCRATCH_PAD_2)));
SA_DBG1(("saGetControllerInfo: SCRATCH_PAD3 value = 0x%x\n", siHalRegReadExt(agRoot,GEN_MSGU_SCRATCH_PAD_3, MSGU_SCRATCH_PAD_3)));
SA_DBG1(("saGetControllerInfo: SCRATCH_PAD3 value = 0x%x\n", siHalRegReadExt(agRoot,GEN_MSGU_SCRATCH_PAD_3, MSGU_SCRATCH_PAD_3)));
if(siHalRegReadExt(agRoot,GEN_MSGU_SCRATCH_PAD_0, MSGU_SCRATCH_PAD_0) == 0xFFFFFFFF)
{
SA_DBG1(("saGetControllerInfo:AGSA_RC_FAILURE SCRATCH_PAD0 value = 0x%x\n",
siHalRegReadExt(agRoot,GEN_MSGU_SCRATCH_PAD_0, MSGU_SCRATCH_PAD_0) ) );
return AGSA_RC_FAILURE;
}
if(siHalRegReadExt(agRoot,GEN_MSGU_SCRATCH_PAD_0, MSGU_SCRATCH_PAD_0) == 0xFFFFFFFF)
{
SA_DBG1(("saGetControllerInfo:AGSA_RC_FAILURE SCRATCH_PAD0 value = 0x%x\n",
siHalRegReadExt(agRoot,GEN_MSGU_SCRATCH_PAD_0, MSGU_SCRATCH_PAD_0) ) );
return AGSA_RC_FAILURE;
}
if( SCRATCH_PAD1_V_ERROR_STATE(siHalRegReadExt(agRoot,GEN_MSGU_SCRATCH_PAD_1, MSGU_SCRATCH_PAD_1)) )
{
SA_DBG1(("saGetControllerInfo: SCRATCH_PAD1 (0x%x) in error state ila %d raae %d Iop0 %d Iop1 %d\n",
siHalRegReadExt(agRoot,GEN_MSGU_SCRATCH_PAD_1, MSGU_SCRATCH_PAD_1),
( SCRATCH_PAD1_V_ILA_ERROR_STATE(siHalRegReadExt(agRoot,GEN_MSGU_SCRATCH_PAD_1, MSGU_SCRATCH_PAD_1)) ? 1 : 0),
( SCRATCH_PAD1_V_RAAE_ERROR_STATE(siHalRegReadExt(agRoot,GEN_MSGU_SCRATCH_PAD_1,MSGU_SCRATCH_PAD_1)) ? 1 : 0),
( SCRATCH_PAD1_V_IOP0_ERROR_STATE(siHalRegReadExt(agRoot,GEN_MSGU_SCRATCH_PAD_1,MSGU_SCRATCH_PAD_1)) ? 1 : 0),
( SCRATCH_PAD1_V_IOP1_ERROR_STATE(siHalRegReadExt(agRoot,GEN_MSGU_SCRATCH_PAD_1,MSGU_SCRATCH_PAD_1)) ? 1 : 0) ));
}
if(smIS_SPC(agRoot))
{
value = ossaHwRegReadExt(agRoot, PCIBAR3, HDA_RSP_OFFSET1MB+HDA_CMD_CODE_OFFSET) & HDA_STATUS_BITS;
if (value == BOOTTLOADERHDA_IDLE)
{
SA_DBG1(("saGetControllerInfo: HDA mode, value = 0x%x\n", value));
return AGSA_RC_HDA_NO_FW_RUNNING;
}
}
else
{
if(siHalRegReadExt(agRoot,GEN_MSGU_SCRATCH_PAD_1, MSGU_SCRATCH_PAD_1) & SCRATCH_PAD1_V_RESERVED )
{
SA_DBG1(("saGetControllerInfo: Warning SCRATCH_PAD1 reserved bits set value = 0x%x\n", siHalRegReadExt(agRoot,GEN_MSGU_SCRATCH_PAD_1, MSGU_SCRATCH_PAD_1)));
}
if( si_check_V_HDA(agRoot))
{
SA_DBG1(("saGetControllerInfo: HDA mode AGSA_RC_HDA_NO_FW_RUNNING\n" ));
return AGSA_RC_HDA_NO_FW_RUNNING;
}
}
max_wait_time = WAIT_SECONDS(gWait_2);
max_wait_count = MAKE_MODULO(max_wait_time,WAIT_INCREMENT);
if(smIS_SPCV(agRoot))
{
do
{
ossaStallThread(agRoot, WAIT_INCREMENT);
value = siHalRegReadExt(agRoot, GEN_MSGU_SCRATCH_PAD_1, MSGU_SCRATCH_PAD_1);
value1 =siHalRegReadExt(agRoot, GEN_MSGU_SCRATCH_PAD_2, MSGU_SCRATCH_PAD_2);
if(smIS_SPCV(agRoot))
{
if((value & SCRATCH_PAD1_V_RESERVED) )
{
SA_DBG1(("saGetControllerInfo: V reserved SCRATCH_PAD1 value = 0x%x (0x%x)\n", value, SCRATCH_PAD1_V_RESERVED));
ret = AGSA_RC_FW_NOT_IN_READY_STATE;
break;
}
}
if ((max_wait_count -= WAIT_INCREMENT) == 0)
{
SA_DBG1(("saGetControllerInfo: timeout SCRATCH_PAD1_V_READY !! SCRATCH_PAD1/2 value = 0x%x 0x%x\n", value, value1));
break;
}
} while (((value & SCRATCH_PAD1_V_READY) != SCRATCH_PAD1_V_READY) || (value == 0xffffffff));
}
else
{
do
{
ossaStallThread(agRoot, WAIT_INCREMENT);
value = siHalRegReadExt(agRoot, GEN_MSGU_SCRATCH_PAD_1, MSGU_SCRATCH_PAD_1);
if (value & SCRATCH_PAD1_RESERVED)
{
SA_DBG1(("saGetControllerInfo: SCRATCH_PAD1 value = 0x%x\n", value));
ret = AGSA_RC_FW_NOT_IN_READY_STATE;
break;
}
value1 =siHalRegReadExt(agRoot, GEN_MSGU_SCRATCH_PAD_2,MSGU_SCRATCH_PAD_2);
if (value1 & SCRATCH_PAD2_RESERVED)
{
SA_DBG1(("saGetControllerInfo: SCRATCH_PAD2 value = 0x%x\n", value1));
ret = AGSA_RC_FW_NOT_IN_READY_STATE;
break;
}
if ((max_wait_count -= WAIT_INCREMENT) == 0)
{
SA_DBG1(("saGetControllerInfo: Timeout!! SCRATCH_PAD1/2 value = 0x%x 0x%x\n", value, value1));
break;
}
} while (((value & SCRATCH_PAD_STATE_MASK) != SCRATCH_PAD1_RDY) || ((value1 & SCRATCH_PAD_STATE_MASK) != SCRATCH_PAD2_RDY));
}
if (!max_wait_count)
{
SA_DBG1(("saGetControllerInfo: timeout failure\n"));
ret = AGSA_RC_FW_NOT_IN_READY_STATE;
}
if (ret == AGSA_RC_SUCCESS)
{
SA_DBG1(("saGetControllerInfo: FW Ready, SCRATCH_PAD1/2 value = 0x%x 0x%x\n", value, value1));
MSGUCfgTblBase = siHalRegReadExt(agRoot,GEN_MSGU_SCRATCH_PAD_0, MSGU_SCRATCH_PAD_0);
CfgTblDWIdx = MSGUCfgTblBase & SCRATCH_PAD0_OFFSET_MASK;
MSGUCfgTblBase = (MSGUCfgTblBase & SCRATCH_PAD0_BAR_MASK) >> SHIFT26;
pcibar = (bit8)mpiGetPCIBarIndex(agRoot, MSGUCfgTblBase);
controllerInfo->signature = ossaHwRegReadExt(agRoot, pcibar, (bit32)CfgTblDWIdx);
controllerInfo->fwInterfaceRev = ossaHwRegReadExt(agRoot, pcibar, (bit32)CfgTblDWIdx + MAIN_INTERFACE_REVISION);
controllerInfo->fwRevision = ossaHwRegReadExt(agRoot, pcibar, (bit32)CfgTblDWIdx + MAIN_FW_REVISION);
controllerInfo->ilaRevision = ossaHwRegReadExt(agRoot, pcibar, (bit32)CfgTblDWIdx + MAIN_ILAT_ILAV_ILASMRN_ILAMRN_ILAMJN);
controllerInfo->maxPendingIO = ossaHwRegReadExt(agRoot, pcibar, (bit32)CfgTblDWIdx + MAIN_MAX_OUTSTANDING_IO_OFFSET);
controllerInfo->maxDevices = (ossaHwRegReadExt(agRoot, pcibar, (bit32)CfgTblDWIdx + MAIN_MAX_SGL_OFFSET) & MAIN_MAX_DEV_BITS);
controllerInfo->maxDevices = controllerInfo->maxDevices >> SHIFT16;
controllerInfo->maxSgElements = (ossaHwRegReadExt(agRoot, pcibar, (bit32)CfgTblDWIdx + MAIN_MAX_SGL_OFFSET) & MAIN_MAX_SGL_BITS);
if( smIS_SPC(agRoot))
{
SA_DBG2(("saGetControllerInfo: LINK_CTRL 0x%08x Speed 0x%X Lanes 0x%X \n", ossaHwRegReadConfig32(agRoot,128),
((ossaHwRegReadConfig32(agRoot,128) & 0x000F0000) >> 16),
((ossaHwRegReadConfig32(agRoot,128) & 0x0FF00000) >> 20) ));
controllerInfo->PCILinkRate = ((ossaHwRegReadConfig32(agRoot,128) & 0x000F0000) >> 16);
controllerInfo->PCIWidth = ((ossaHwRegReadConfig32(agRoot,128) & 0x0FF00000) >> 20);
}
else
{
SA_DBG2(("saGetControllerInfo: LINK_CTRL 0x%08x Speed 0x%X Lanes 0x%X \n", ossaHwRegReadConfig32(agRoot,208),
((ossaHwRegReadConfig32(agRoot,208) & 0x000F0000) >> 16),
((ossaHwRegReadConfig32(agRoot,208) & 0x0FF00000) >> 20) ));
controllerInfo->PCILinkRate = ((ossaHwRegReadConfig32(agRoot,208) & 0x000F0000) >> 16);
controllerInfo->PCIWidth = ((ossaHwRegReadConfig32(agRoot,208) & 0x0FF00000) >> 20);
}
ContrlCapFlag = ossaHwRegReadExt(agRoot, pcibar, (bit32)CfgTblDWIdx + MAIN_CNTRL_CAP_OFFSET);
controllerInfo->queueSupport = ContrlCapFlag & MAIN_QSUPPORT_BITS;
controllerInfo->phyCount = (bit8)((ContrlCapFlag & MAIN_PHY_COUNT_MASK) >> SHIFT19);
if(smIS_SPCV(agRoot))
{
controllerInfo->controllerSetting = (bit8)((siHalRegReadExt(agRoot,GEN_MSGU_SCRATCH_PAD_1, MSGU_SCRATCH_PAD_1) & SCRATCH_PAD1_V_BOOTSTATE_MASK ) >> SHIFT4);
}
else
{
controllerInfo->controllerSetting = (bit8)(ossaHwRegReadExt(agRoot, pcibar, (bit32)CfgTblDWIdx + MAIN_HDA_FLAGS_OFFSET) & MAIN_HDA_FLAG_BITS);
}
controllerInfo->sasSpecsSupport = (ContrlCapFlag & MAIN_SAS_SUPPORT_BITS) >> SHIFT25;
}
SA_DBG1(("saGetControllerInfo: signature 0x%X\n", controllerInfo->signature));
SA_DBG1(("saGetControllerInfo: fwInterfaceRev 0x%X\n", controllerInfo->fwInterfaceRev));
SA_DBG1(("saGetControllerInfo: hwRevision 0x%X\n", controllerInfo->hwRevision));
SA_DBG1(("saGetControllerInfo: fwRevision 0x%X\n", controllerInfo->fwRevision));
SA_DBG1(("saGetControllerInfo: ilaRevision 0x%X\n", controllerInfo->ilaRevision));
SA_DBG1(("saGetControllerInfo: maxPendingIO 0x%X\n", controllerInfo->maxPendingIO));
SA_DBG1(("saGetControllerInfo: maxDevices 0x%X\n", controllerInfo->maxDevices));
SA_DBG1(("saGetControllerInfo: maxSgElements 0x%X\n", controllerInfo->maxSgElements));
SA_DBG1(("saGetControllerInfo: queueSupport 0x%X\n", controllerInfo->queueSupport));
SA_DBG1(("saGetControllerInfo: phyCount 0x%X\n", controllerInfo->phyCount));
SA_DBG1(("saGetControllerInfo: controllerSetting 0x%X\n", controllerInfo->controllerSetting));
SA_DBG1(("saGetControllerInfo: PCILinkRate 0x%X\n", controllerInfo->PCILinkRate));
SA_DBG1(("saGetControllerInfo: PCIWidth 0x%X\n", controllerInfo->PCIWidth));
SA_DBG1(("saGetControllerInfo: sasSpecsSupport 0x%X\n", controllerInfo->sasSpecsSupport));
SA_DBG1(("saGetControllerInfo: sdkInterfaceRev 0x%X\n", controllerInfo->sdkInterfaceRev));
SA_DBG1(("saGetControllerInfo: sdkRevision 0x%X\n", controllerInfo->sdkRevision));
if (agNULL != agRoot->sdkData)
{
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "6e");
}
return ret;
}
GLOBAL bit32 saGetControllerStatus(
agsaRoot_t *agRoot,
agsaControllerStatus_t *controllerStatus
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *) (agRoot->sdkData);
spc_GSTableDescriptor_t GSTable;
bit32 max_wait_time;
bit32 max_wait_count;
bit32 i, value, value1;
if (agNULL != saRoot)
{
smTraceFuncEnter(hpDBG_VERY_LOUD,"6f");
}
si_memset(controllerStatus, 0, sizeof(agsaControllerStatus_t));
si_memset(&GSTable, 0, sizeof(spc_GSTableDescriptor_t));
if(siHalRegReadExt(agRoot,GEN_MSGU_SCRATCH_PAD_0, MSGU_SCRATCH_PAD_0) == 0xFFFFFFFF)
{
SA_DBG1(("saGetControllerStatus:AGSA_RC_FAILURE SCRATCH_PAD0 value = 0x%x\n", siHalRegReadExt(agRoot,GEN_MSGU_SCRATCH_PAD_0, MSGU_SCRATCH_PAD_0)));
return AGSA_RC_FAILURE;
}
if(siHalRegReadExt(agRoot,GEN_MSGU_SCRATCH_PAD_1, MSGU_SCRATCH_PAD_3) & (OSSA_ENCRYPT_ENGINE_FAILURE_MASK | OSSA_DIF_ENGINE_FAILURE_MASK))
{
SA_DBG1(("saGetControllerStatus: BIST error in SCRATCHPAD 3 0x%x\n", siHalRegReadExt(agRoot,GEN_MSGU_SCRATCH_PAD_3, MSGU_SCRATCH_PAD_3)));
}
if(smIS_SPC(agRoot))
{
controllerStatus->fatalErrorInfo.errorInfo0 = ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_0);
controllerStatus->fatalErrorInfo.errorInfo1 = ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_1);
controllerStatus->fatalErrorInfo.errorInfo2 = ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_2);
controllerStatus->fatalErrorInfo.errorInfo3 = ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_3);
#if defined(SALLSDK_DEBUG)
SA_DBG1(("saGetControllerStatus: SCRATCH_PAD0 value = 0x%x\n", controllerStatus->fatalErrorInfo.errorInfo0));
SA_DBG1(("saGetControllerStatus: SCRATCH_PAD1 value = 0x%x\n", controllerStatus->fatalErrorInfo.errorInfo1));
SA_DBG1(("saGetControllerStatus: SCRATCH_PAD2 value = 0x%x\n", controllerStatus->fatalErrorInfo.errorInfo2));
SA_DBG1(("saGetControllerStatus: SCRATCH_PAD3 value = 0x%x\n", controllerStatus->fatalErrorInfo.errorInfo3));
#endif
value = ossaHwRegReadExt(agRoot, PCIBAR3, HDA_RSP_OFFSET1MB+HDA_CMD_CODE_OFFSET) & HDA_STATUS_BITS;
if (value == BOOTTLOADERHDA_IDLE)
{
SA_DBG1(("saGetControllerStatus: HDA mode, value = 0x%x\n", value));
return AGSA_RC_HDA_NO_FW_RUNNING;
}
value = ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_1);
value1 = ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_2);
if ((SCRATCH_PAD1_ERR == (value & SCRATCH_PAD_STATE_MASK)) || (SCRATCH_PAD2_ERR == (value1 & SCRATCH_PAD_STATE_MASK)))
{
if (agNULL != saRoot)
{
controllerStatus->fatalErrorInfo.regDumpBusBaseNum0 = saRoot->mainConfigTable.regDumpPCIBAR;
controllerStatus->fatalErrorInfo.regDumpOffset0 = saRoot->mainConfigTable.FatalErrorDumpOffset0;
controllerStatus->fatalErrorInfo.regDumpLen0 = saRoot->mainConfigTable.FatalErrorDumpLength0;
controllerStatus->fatalErrorInfo.regDumpBusBaseNum1 = saRoot->mainConfigTable.regDumpPCIBAR;
controllerStatus->fatalErrorInfo.regDumpOffset1 = saRoot->mainConfigTable.FatalErrorDumpOffset1;
controllerStatus->fatalErrorInfo.regDumpLen1 = saRoot->mainConfigTable.FatalErrorDumpLength1;
}
else
{
controllerStatus->fatalErrorInfo.regDumpBusBaseNum0 = 0;
controllerStatus->fatalErrorInfo.regDumpOffset0 = 0;
controllerStatus->fatalErrorInfo.regDumpLen0 = 0;
controllerStatus->fatalErrorInfo.regDumpBusBaseNum1 = 0;
controllerStatus->fatalErrorInfo.regDumpOffset1 = 0;
controllerStatus->fatalErrorInfo.regDumpLen1 = 0;
}
if (agNULL != saRoot)
{
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "6f");
}
return AGSA_RC_FW_NOT_IN_READY_STATE;
}
max_wait_time = WAIT_SECONDS(2);
max_wait_count = MAKE_MODULO(max_wait_time,WAIT_INCREMENT);
do
{
ossaStallThread(agRoot, WAIT_INCREMENT);
value = ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_1);
if (value & SCRATCH_PAD1_RESERVED)
{
SA_DBG1(("saGetControllerStatus: (Reserved bit not 0) SCRATCH_PAD1 value = 0x%x\n", value));
ret = AGSA_RC_FAILURE;
break;
}
value1 = ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_2);
if (value1 & SCRATCH_PAD2_RESERVED)
{
SA_DBG1(("saGetControllerStatus: (Reserved bit not 0) SCRATCH_PAD2 value = 0x%x\n", value1));
ret = AGSA_RC_FAILURE;
break;
}
if ((max_wait_count -=WAIT_INCREMENT) == 0)
{
SA_DBG1(("saGetControllerStatus: Timeout!! SCRATCH_PAD1/2 value = 0x%x 0x%x\n", value, value1));
break;
}
} while (((value & SCRATCH_PAD_STATE_MASK) != SCRATCH_PAD1_RDY) || ((value1 & SCRATCH_PAD_STATE_MASK) != SCRATCH_PAD2_RDY));
if (!max_wait_count)
{
SA_DBG1(("saGetControllerStatus: timeout failure\n"));
ret = AGSA_RC_FAILURE;
}
if (ret == AGSA_RC_SUCCESS)
{
SA_DBG1(("saGetControllerStatus: FW Ready, SCRATCH_PAD1/2 value = 0x%x 0x%x\n", value, value1));
value = ossaHwRegRead(agRoot, MSGU_SCRATCH_PAD_0);
value1 = value & SCRATCH_PAD0_OFFSET_MASK;
value = (value & SCRATCH_PAD0_BAR_MASK) >> SHIFT26;
mpiReadGSTable(agRoot, &GSTable);
controllerStatus->fatalErrorInfo.regDumpBusBaseNum0 = value;
controllerStatus->fatalErrorInfo.regDumpBusBaseNum1 = value;
value = (bit8)mpiGetPCIBarIndex(agRoot, value);
controllerStatus->fatalErrorInfo.regDumpOffset0 = ossaHwRegReadExt(agRoot, value, value1 + MAIN_FATAL_ERROR_RDUMP0_OFFSET);
controllerStatus->fatalErrorInfo.regDumpLen0 = ossaHwRegReadExt(agRoot, value, value1 + MAIN_FATAL_ERROR_RDUMP0_LENGTH);
controllerStatus->fatalErrorInfo.regDumpOffset1 = ossaHwRegReadExt(agRoot, value, value1 + MAIN_FATAL_ERROR_RDUMP1_OFFSET);
controllerStatus->fatalErrorInfo.regDumpLen1 = ossaHwRegReadExt(agRoot, value, value1 + MAIN_FATAL_ERROR_RDUMP1_LENGTH);
SA_DBG2(("saGetControllerStatus: SCRATCH PAD0 0x%x\n", controllerStatus->fatalErrorInfo.errorInfo0));
SA_DBG2(("saGetControllerStatus: SCRATCH PAD1 0x%x\n", controllerStatus->fatalErrorInfo.errorInfo1));
SA_DBG2(("saGetControllerStatus: SCRATCH PAD2 0x%x\n", controllerStatus->fatalErrorInfo.errorInfo2));
SA_DBG2(("saGetControllerStatus: SCRATCH PAD3 0x%x\n", controllerStatus->fatalErrorInfo.errorInfo3));
SA_DBG2(("saGetControllerStatus: RegDumpOffset0 0x%x\n", controllerStatus->fatalErrorInfo.regDumpOffset0));
SA_DBG2(("saGetControllerStatus: RegDumpLen0 0x%x\n", controllerStatus->fatalErrorInfo.regDumpLen0));
SA_DBG2(("saGetControllerStatus: RegDumpOffset1 0x%x\n", controllerStatus->fatalErrorInfo.regDumpOffset1));
SA_DBG2(("saGetControllerStatus: RegDumpLen1 0x%x\n", controllerStatus->fatalErrorInfo.regDumpLen1));
controllerStatus->interfaceState = GSTable.GSTLenMPIS & GST_INF_STATE_BITS;
controllerStatus->iqFreezeState0 = GSTable.IQFreezeState0;
controllerStatus->iqFreezeState1 = GSTable.IQFreezeState1;
for (i = 0; i < 8; i++)
{
controllerStatus->phyStatus[i] = GSTable.PhyState[i];
controllerStatus->recoverableErrorInfo[i] = GSTable.recoverErrInfo[i];
}
controllerStatus->tickCount0 = GSTable.MsguTcnt;
controllerStatus->tickCount1 = GSTable.IopTcnt;
controllerStatus->tickCount2 = GSTable.Iop1Tcnt;
}
}
else
{
SA_DBG1(("saGetControllerStatus: SPCv\n" ));
if(siHalRegReadExt(agRoot,GEN_MSGU_SCRATCH_PAD_1, MSGU_SCRATCH_PAD_1) & SCRATCH_PAD1_V_RESERVED )
{
SA_DBG1(("saGetControllerStatus: Warning SCRATCH_PAD1 reserved bits set value = 0x%x\n", siHalRegReadExt(agRoot,GEN_MSGU_SCRATCH_PAD_1, MSGU_SCRATCH_PAD_1)));
}
if( si_check_V_HDA(agRoot))
{
controllerStatus->fatalErrorInfo.errorInfo0 = ossaHwRegRead(agRoot,V_Scratchpad_0_Register );
controllerStatus->fatalErrorInfo.errorInfo1 = ossaHwRegRead(agRoot,V_Scratchpad_1_Register );
controllerStatus->fatalErrorInfo.errorInfo2 = ossaHwRegRead(agRoot,V_Scratchpad_2_Register );
controllerStatus->fatalErrorInfo.errorInfo3 = ossaHwRegRead(agRoot,V_Scratchpad_3_Register );
SA_DBG1(("saGetControllerStatus: HDA mode, AGSA_RC_HDA_NO_FW_RUNNING errorInfo1 = 0x%x\n",controllerStatus->fatalErrorInfo.errorInfo1 ));
return AGSA_RC_HDA_NO_FW_RUNNING;
}
ret = si_check_V_Ready(agRoot);
if (ret == AGSA_RC_SUCCESS)
{
mpiReadGSTable(agRoot, &GSTable);
controllerStatus->interfaceState = GSTable.GSTLenMPIS & GST_INF_STATE_BITS;
controllerStatus->iqFreezeState0 = GSTable.IQFreezeState0;
controllerStatus->iqFreezeState1 = GSTable.IQFreezeState1;
for (i = 0; i < 8; i++)
{
controllerStatus->phyStatus[i] = GSTable.PhyState[i];
controllerStatus->recoverableErrorInfo[i] = GSTable.recoverErrInfo[i];
}
controllerStatus->tickCount0 = GSTable.MsguTcnt;
controllerStatus->tickCount1 = GSTable.IopTcnt;
controllerStatus->tickCount2 = GSTable.Iop1Tcnt;
controllerStatus->interfaceState = GSTable.GSTLenMPIS & GST_INF_STATE_BITS;
controllerStatus->iqFreezeState0 = GSTable.IQFreezeState0;
controllerStatus->iqFreezeState1 = GSTable.IQFreezeState1;
for (i = 0; i < 8; i++)
{
if( IS_SDKDATA(agRoot))
{
if (agNULL != saRoot)
{
controllerStatus->phyStatus[i] = ((saRoot->phys[i+8].linkstatus << SHIFT8) | saRoot->phys[i].linkstatus);
}
}
else
{
controllerStatus->phyStatus[i] = 0;
}
controllerStatus->recoverableErrorInfo[i] = GSTable.recoverErrInfo[i];
}
controllerStatus->tickCount0 = GSTable.MsguTcnt;
controllerStatus->tickCount1 = GSTable.IopTcnt;
controllerStatus->tickCount2 = GSTable.Iop1Tcnt;
}
SA_DBG1(("saGetControllerStatus: SCRATCH_PAD0 value = 0x%x\n", ossaHwRegRead(agRoot, V_Scratchpad_0_Register)));
SA_DBG1(("saGetControllerStatus: SCRATCH_PAD1 value = 0x%x\n", ossaHwRegRead(agRoot, V_Scratchpad_1_Register)));
SA_DBG1(("saGetControllerStatus: SCRATCH_PAD2 value = 0x%x\n", ossaHwRegRead(agRoot, V_Scratchpad_2_Register)));
SA_DBG1(("saGetControllerStatus: SCRATCH_PAD3 value = 0x%x\n", ossaHwRegRead(agRoot, V_Scratchpad_3_Register)));
controllerStatus->fatalErrorInfo.errorInfo0 = ossaHwRegRead(agRoot,V_Scratchpad_0_Register );
controllerStatus->fatalErrorInfo.errorInfo1 = ossaHwRegRead(agRoot,V_Scratchpad_1_Register );
controllerStatus->fatalErrorInfo.errorInfo2 = ossaHwRegRead(agRoot,V_Scratchpad_2_Register );
controllerStatus->fatalErrorInfo.errorInfo3 = ossaHwRegRead(agRoot,V_Scratchpad_3_Register );
controllerStatus->bootStatus = ( (( controllerStatus->fatalErrorInfo.errorInfo1 >> SHIFT9) & 1 ) |
(( controllerStatus->fatalErrorInfo.errorInfo3 & 0x3) << SHIFT16) |
((( controllerStatus->fatalErrorInfo.errorInfo3 >> SHIFT14) & 0x7) << SHIFT18) |
((( controllerStatus->fatalErrorInfo.errorInfo3 >> SHIFT4 ) & 0x1) << SHIFT23) |
((( controllerStatus->fatalErrorInfo.errorInfo3 >> SHIFT16) & 0xFF) << SHIFT24) );
controllerStatus->bootComponentState[0] = (bit16) (( controllerStatus->fatalErrorInfo.errorInfo1 & 3 ) | 0x8000);
controllerStatus->bootComponentState[1] = (bit16) ((( controllerStatus->fatalErrorInfo.errorInfo1 >> SHIFT10) & 3 ) | 0x8000);
controllerStatus->bootComponentState[2] = (bit16) ((( controllerStatus->fatalErrorInfo.errorInfo1 >> SHIFT12) & 3 ) | 0x8000);
controllerStatus->bootComponentState[3] = (bit16) ((( controllerStatus->fatalErrorInfo.errorInfo1 >> SHIFT4) & 7 ) | 0x8000);
controllerStatus->bootComponentState[4] = (bit16) ((( controllerStatus->fatalErrorInfo.errorInfo1 >> SHIFT2) & 3 ) | 0x8000);
controllerStatus->bootComponentState[5] = 0;
controllerStatus->bootComponentState[6] = 0;
controllerStatus->bootComponentState[7] = 0;
if(controllerStatus->fatalErrorInfo.errorInfo0 == 0xFFFFFFFF)
{
ret = AGSA_RC_FAILURE;
}
}
SA_DBG1(("saGetControllerStatus: fatalErrorInfo.errorInfo0 0x%x\n", controllerStatus->fatalErrorInfo.errorInfo0));
SA_DBG1(("saGetControllerStatus: fatalErrorInfo.errorInfo1 0x%x\n", controllerStatus->fatalErrorInfo.errorInfo1));
SA_DBG1(("saGetControllerStatus: fatalErrorInfo.errorInfo2 0x%x\n", controllerStatus->fatalErrorInfo.errorInfo2));
SA_DBG1(("saGetControllerStatus: fatalErrorInfo.errorInfo3 0x%x\n", controllerStatus->fatalErrorInfo.errorInfo3));
SA_DBG1(("saGetControllerStatus: fatalErrorInfo.regDumpBusBaseNum0 0x%x\n", controllerStatus->fatalErrorInfo.regDumpBusBaseNum0));
SA_DBG1(("saGetControllerStatus: fatalErrorInfo.regDumpOffset0 0x%x\n", controllerStatus->fatalErrorInfo.regDumpOffset0));
SA_DBG1(("saGetControllerStatus: fatalErrorInfo.regDumpLen0 0x%x\n", controllerStatus->fatalErrorInfo.regDumpLen0));
SA_DBG1(("saGetControllerStatus: fatalErrorInfo.regDumpBusBaseNum1 0x%x\n", controllerStatus->fatalErrorInfo.regDumpBusBaseNum1));
SA_DBG1(("saGetControllerStatus: fatalErrorInfo.regDumpOffset1 0x%x\n", controllerStatus->fatalErrorInfo.regDumpOffset1));
SA_DBG1(("saGetControllerStatus: fatalErrorInfo.regDumpLen1 0x%x\n", controllerStatus->fatalErrorInfo.regDumpLen1));
SA_DBG1(("saGetControllerStatus: interfaceState 0x%x\n", controllerStatus->interfaceState));
SA_DBG1(("saGetControllerStatus: iqFreezeState0 0x%x\n", controllerStatus->iqFreezeState0));
SA_DBG1(("saGetControllerStatus: iqFreezeState1 0x%x\n", controllerStatus->iqFreezeState1));
SA_DBG1(("saGetControllerStatus: tickCount0 0x%x\n", controllerStatus->tickCount0));
SA_DBG1(("saGetControllerStatus: tickCount1 0x%x\n", controllerStatus->tickCount1));
SA_DBG1(("saGetControllerStatus: tickCount2 0x%x\n", controllerStatus->tickCount2));
SA_DBG1(("saGetControllerStatus: phyStatus[0] 0x%08x\n", controllerStatus->phyStatus[0]));
SA_DBG1(("saGetControllerStatus: phyStatus[1] 0x%08x\n", controllerStatus->phyStatus[1]));
SA_DBG1(("saGetControllerStatus: phyStatus[2] 0x%08x\n", controllerStatus->phyStatus[2]));
SA_DBG1(("saGetControllerStatus: phyStatus[3] 0x%08x\n", controllerStatus->phyStatus[3]));
SA_DBG1(("saGetControllerStatus: phyStatus[4] 0x%08x\n", controllerStatus->phyStatus[4]));
SA_DBG1(("saGetControllerStatus: phyStatus[5] 0x%08x\n", controllerStatus->phyStatus[5]));
SA_DBG1(("saGetControllerStatus: phyStatus[6] 0x%08x\n", controllerStatus->phyStatus[6]));
SA_DBG1(("saGetControllerStatus: phyStatus[7] 0x%08x\n", controllerStatus->phyStatus[7]));
SA_DBG1(("saGetControllerStatus: recoverableErrorInfo[0] 0x%08x\n", controllerStatus->recoverableErrorInfo[0]));
SA_DBG1(("saGetControllerStatus: recoverableErrorInfo[1] 0x%08x\n", controllerStatus->recoverableErrorInfo[1]));
SA_DBG1(("saGetControllerStatus: recoverableErrorInfo[2] 0x%08x\n", controllerStatus->recoverableErrorInfo[2]));
SA_DBG1(("saGetControllerStatus: recoverableErrorInfo[3] 0x%08x\n", controllerStatus->recoverableErrorInfo[3]));
SA_DBG1(("saGetControllerStatus: recoverableErrorInfo[4] 0x%08x\n", controllerStatus->recoverableErrorInfo[4]));
SA_DBG1(("saGetControllerStatus: recoverableErrorInfo[5] 0x%08x\n", controllerStatus->recoverableErrorInfo[5]));
SA_DBG1(("saGetControllerStatus: recoverableErrorInfo[6] 0x%08x\n", controllerStatus->recoverableErrorInfo[6]));
SA_DBG1(("saGetControllerStatus: recoverableErrorInfo[7] 0x%08x\n", controllerStatus->recoverableErrorInfo[7]));
SA_DBG1(("saGetControllerStatus: bootStatus 0x%08x\n", controllerStatus->bootStatus));
SA_DBG1(("saGetControllerStatus: bootStatus Active FW Image %x\n", (controllerStatus->bootStatus & 1 ) ? 1 : 0 ));
SA_DBG1(("saGetControllerStatus: bootStatus Encryption Cap %x\n", ((controllerStatus->bootStatus & 0x30000 ) >> SHIFT16) ));
SA_DBG1(("saGetControllerStatus: bootStatus Encryption Sec Mode %x\n", ((controllerStatus->bootStatus & 0xC0000 ) >> SHIFT18) ));
SA_DBG1(("saGetControllerStatus: bootStatus Encryption AES XTS %x\n", (controllerStatus->bootStatus & 0x800000 ) ? 1 : 0 ));
SA_DBG1(("saGetControllerStatus: bootStatus Encryption Engine Stat 0x%x\n", ((controllerStatus->bootStatus & 0xFF000000 ) >> SHIFT24) ));
SA_DBG1(("saGetControllerStatus: bootComponentState[0] RAAE_STATE 0x%x\n", controllerStatus->bootComponentState[0]));
SA_DBG1(("saGetControllerStatus: bootComponentState[1] IOP0_STATE 0x%x\n", controllerStatus->bootComponentState[1]));
SA_DBG1(("saGetControllerStatus: bootComponentState[2] IOP1_STATE 0x%x\n", controllerStatus->bootComponentState[2]));
SA_DBG1(("saGetControllerStatus: bootComponentState[3] BOOTLDR_ 0x%x\n", controllerStatus->bootComponentState[3]));
SA_DBG1(("saGetControllerStatus: bootComponentState[4] ILA State 0x%x\n", controllerStatus->bootComponentState[4]));
SA_DBG1(("saGetControllerStatus: bootComponentState[5] 0x%x\n", controllerStatus->bootComponentState[5]));
SA_DBG1(("saGetControllerStatus: bootComponentState[6] 0x%x\n", controllerStatus->bootComponentState[6]));
SA_DBG1(("saGetControllerStatus: bootComponentState[7] 0x%x\n", controllerStatus->bootComponentState[7]));
if (agNULL != saRoot)
{
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "6f");
}
return ret;
}
GLOBAL bit32 saGetControllerEventLogInfo(
agsaRoot_t *agRoot,
agsaControllerEventLog_t *eventLogInfo
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *) (agRoot->sdkData);
smTraceFuncEnter(hpDBG_VERY_LOUD,"6g");
SA_ASSERT((agNULL != agRoot), "");
eventLogInfo->eventLog1 = saRoot->memoryAllocated.agMemory[MPI_MEM_INDEX + MPI_EVENTLOG_INDEX];
eventLogInfo->eventLog1Option = saRoot->mainConfigTable.eventLogOption;
eventLogInfo->eventLog2 = saRoot->memoryAllocated.agMemory[MPI_MEM_INDEX + MPI_IOP_EVENTLOG_INDEX];
eventLogInfo->eventLog2Option = saRoot->mainConfigTable.IOPeventLogOption;
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "6g");
return ret;
}
GLOBAL bit32 saGpioEventSetup(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 queueNum,
agsaGpioEventSetupInfo_t *gpioEventSetupInfo
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *) (agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
agsaGPIOCmd_t payload;
smTraceFuncEnter(hpDBG_VERY_LOUD,"6h");
SA_ASSERT((agNULL != agRoot), "");
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest = (agsaIORequestDesc_t *)saLlistIOGetHead(&(saRoot->freeIORequests));
if ( agNULL == pRequest )
{
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_DBG1(("saGpioEventSetup, No request from free list\n" ));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "6h");
return AGSA_RC_BUSY;
}
else
{
saLlistIORemove(&(saRoot->freeIORequests), &(pRequest->linkNode));
saRoot->IOMap[pRequest->HTag].Tag = pRequest->HTag;
saRoot->IOMap[pRequest->HTag].IORequest = (void *)pRequest;
saRoot->IOMap[pRequest->HTag].agContext = agContext;
pRequest->valid = agTRUE;
si_memset(&payload, 0, sizeof(agsaGPIOCmd_t));
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaGPIOCmd_t, tag), pRequest->HTag);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaGPIOCmd_t, eOBIDGeGsGrGw), GPIO_GE_BIT);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaGPIOCmd_t, GPIEVChange), gpioEventSetupInfo->gpioEventLevel);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaGPIOCmd_t, GPIEVFall), gpioEventSetupInfo->gpioEventFallingEdge);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaGPIOCmd_t, GPIEVRise), gpioEventSetupInfo->gpioEventRisingEdge);
ret = mpiBuildCmd(agRoot, (bit32 *)&payload, MPI_CATEGORY_SAS_SATA, OPC_INB_GPIO, IOMB_SIZE64, queueNum);
if (AGSA_RC_SUCCESS != ret)
{
saRoot->IOMap[pRequest->HTag].Tag = MARK_OFF;
saRoot->IOMap[pRequest->HTag].IORequest = agNULL;
saRoot->IOMap[pRequest->HTag].agContext = agNULL;
pRequest->valid = agFALSE;
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("saGpioEventSetup: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
SA_DBG1(("saGpioEventSetup, sending IOMB failed\n" ));
}
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "6h");
return ret;
}
GLOBAL bit32 saGpioPinSetup(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 queueNum,
agsaGpioPinSetupInfo_t *gpioPinSetupInfo
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *) (agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
agsaGPIOCmd_t payload;
smTraceFuncEnter(hpDBG_VERY_LOUD,"6i");
SA_ASSERT((agNULL != agRoot), "");
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest = (agsaIORequestDesc_t *)saLlistIOGetHead(&(saRoot->freeIORequests));
if ( agNULL == pRequest )
{
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_DBG1(("saGpioPinSetup, No request from free list\n" ));
return AGSA_RC_BUSY;
}
else
{
saLlistIORemove(&(saRoot->freeIORequests), &(pRequest->linkNode));
saRoot->IOMap[pRequest->HTag].Tag = pRequest->HTag;
saRoot->IOMap[pRequest->HTag].IORequest = (void *)pRequest;
saRoot->IOMap[pRequest->HTag].agContext = agContext;
pRequest->valid = agTRUE;
si_memset(&payload, 0, sizeof(agsaGPIOCmd_t));
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaGPIOCmd_t, tag), pRequest->HTag);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaGPIOCmd_t, eOBIDGeGsGrGw), GPIO_GS_BIT);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaGPIOCmd_t, GpioIe), gpioPinSetupInfo->gpioInputEnabled);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaGPIOCmd_t, OT11_0), gpioPinSetupInfo->gpioTypePart1);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaGPIOCmd_t, OT19_12), gpioPinSetupInfo->gpioTypePart2);
ret = mpiBuildCmd(agRoot, (bit32 *)&payload, MPI_CATEGORY_SAS_SATA, OPC_INB_GPIO, IOMB_SIZE64, queueNum);
if (AGSA_RC_SUCCESS != ret)
{
saRoot->IOMap[pRequest->HTag].Tag = MARK_OFF;
saRoot->IOMap[pRequest->HTag].IORequest = agNULL;
saRoot->IOMap[pRequest->HTag].agContext = agNULL;
pRequest->valid = agFALSE;
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("saGpioPinSetup: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
SA_DBG1(("saGpioPinSetup, sending IOMB failed\n" ));
}
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "6i");
return ret;
}
GLOBAL bit32 saGpioRead(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 queueNum
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *) (agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
agsaGPIOCmd_t payload;
smTraceFuncEnter(hpDBG_VERY_LOUD,"6j");
SA_ASSERT((agNULL != agRoot), "");
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest = (agsaIORequestDesc_t *)saLlistIOGetHead(&(saRoot->freeIORequests));
if ( agNULL == pRequest )
{
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_DBG1(("saGpioRead, No request from free list\n" ));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "6j");
return AGSA_RC_BUSY;
}
else
{
saLlistIORemove(&(saRoot->freeIORequests), &(pRequest->linkNode));
saRoot->IOMap[pRequest->HTag].Tag = pRequest->HTag;
saRoot->IOMap[pRequest->HTag].IORequest = (void *)pRequest;
saRoot->IOMap[pRequest->HTag].agContext = agContext;
pRequest->valid = agTRUE;
si_memset(&payload, 0, sizeof(agsaGPIOCmd_t));
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaGPIOCmd_t, tag), pRequest->HTag);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaGPIOCmd_t, eOBIDGeGsGrGw), GPIO_GR_BIT);
ret = mpiBuildCmd(agRoot, (bit32 *)&payload, MPI_CATEGORY_SAS_SATA, OPC_INB_GPIO, IOMB_SIZE64, queueNum);
if (AGSA_RC_SUCCESS != ret)
{
saRoot->IOMap[pRequest->HTag].Tag = MARK_OFF;
saRoot->IOMap[pRequest->HTag].IORequest = agNULL;
saRoot->IOMap[pRequest->HTag].agContext = agNULL;
pRequest->valid = agFALSE;
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("saGpioRead: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
SA_DBG1(("saGpioRead, sending IOMB failed\n" ));
}
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "6j");
return ret;
}
GLOBAL bit32 saGpioWrite(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 queueNum,
bit32 gpioWriteMask,
bit32 gpioWriteValue
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *) (agRoot->sdkData);
agsaIORequestDesc_t *pRequest;
agsaGPIOCmd_t payload;
smTraceFuncEnter(hpDBG_VERY_LOUD,"6k");
SA_ASSERT((agNULL != agRoot), "");
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest = (agsaIORequestDesc_t *)saLlistIOGetHead(&(saRoot->freeIORequests));
if ( agNULL == pRequest )
{
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_DBG1(("saGpioWrite, No request from free list\n" ));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "6k");
return AGSA_RC_BUSY;
}
else
{
saLlistIORemove(&(saRoot->freeIORequests), &(pRequest->linkNode));
saRoot->IOMap[pRequest->HTag].Tag = pRequest->HTag;
saRoot->IOMap[pRequest->HTag].IORequest = (void *)pRequest;
saRoot->IOMap[pRequest->HTag].agContext = agContext;
pRequest->valid = agTRUE;
si_memset(&payload, 0, sizeof(agsaGPIOCmd_t));
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaGPIOCmd_t, tag), pRequest->HTag);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaGPIOCmd_t, eOBIDGeGsGrGw), GPIO_GW_BIT);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaGPIOCmd_t, GpioWrMsk), gpioWriteMask);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaGPIOCmd_t, GpioWrVal), gpioWriteValue);
ret = mpiBuildCmd(agRoot, (bit32 *)&payload, MPI_CATEGORY_SAS_SATA, OPC_INB_GPIO, IOMB_SIZE64, queueNum);
if (AGSA_RC_SUCCESS != ret)
{
saRoot->IOMap[pRequest->HTag].Tag = MARK_OFF;
saRoot->IOMap[pRequest->HTag].IORequest = agNULL;
saRoot->IOMap[pRequest->HTag].agContext = agNULL;
pRequest->valid = agFALSE;
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("saGpioWrite: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
SA_DBG1(("saGpioWrite, sending IOMB failed\n" ));
}
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "6k");
return ret;
}
GLOBAL bit32 saSASDiagExecute(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 queueNum,
agsaSASDiagExecute_t *diag
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = agNULL;
agsaIORequestDesc_t *pRequest = agNULL;
bit32 payload[32];
SA_ASSERT((agNULL != agRoot), "");
saRoot = (agsaLLRoot_t *) (agRoot->sdkData);
SA_ASSERT((agNULL != saRoot), "");
smTraceFuncEnter(hpDBG_VERY_LOUD,"6m");
SA_DBG2(("saSASDiagExecute,command 0x%X\n", diag->command ));
SA_DBG2(("saSASDiagExecute,param0 0x%X\n", diag->param0 ));
SA_DBG2(("saSASDiagExecute,param2 0x%X\n", diag->param2 ));
SA_DBG2(("saSASDiagExecute,param3 0x%X\n", diag->param3 ));
SA_DBG2(("saSASDiagExecute,param4 0x%X\n", diag->param4 ));
SA_DBG2(("saSASDiagExecute,param5 0x%X\n", diag->param5 ));
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest = (agsaIORequestDesc_t *)saLlistIOGetHead(&(saRoot->freeIORequests));
if ( agNULL == pRequest )
{
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_DBG1(("saSASDiagExecute, No request from free list\n" ));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "6m");
return AGSA_RC_BUSY;
}
else
{
saLlistIORemove(&(saRoot->freeIORequests), &(pRequest->linkNode));
saRoot->IOMap[pRequest->HTag].Tag = pRequest->HTag;
saRoot->IOMap[pRequest->HTag].IORequest = (void *)pRequest;
saRoot->IOMap[pRequest->HTag].agContext = agContext;
pRequest->valid = agTRUE;
if(smIS_SPC(agRoot))
{
diag->param5 = 0;
}
si_memset(&payload, 0, sizeof(payload));
if(smIS_SPCV(agRoot))
{
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaSASDiagExecuteCmd_t, tag), pRequest->HTag);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaSASDiagExecuteCmd_t, CmdTypeDescPhyId),diag->command );
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaSASDiagExecuteCmd_t, Pat1Pat2), diag->param0 );
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaSASDiagExecuteCmd_t, Threshold), diag->param1 );
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaSASDiagExecuteCmd_t, CodePatErrMsk), diag->param2 );
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaSASDiagExecuteCmd_t, Pmon), diag->param3 );
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaSASDiagExecuteCmd_t, PERF1CTL), diag->param4 );
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaSASDiagExecuteCmd_t, THRSHLD1), diag->param5 );
ret = mpiBuildCmd(agRoot, (bit32 *)&payload, MPI_CATEGORY_SAS_SATA, OPC_INB_SAS_DIAG_EXECUTE, IOMB_SIZE128, queueNum);
}
else
{
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsa_SPC_SASDiagExecuteCmd_t, tag), pRequest->HTag);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsa_SPC_SASDiagExecuteCmd_t, CmdTypeDescPhyId),diag->command );
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsa_SPC_SASDiagExecuteCmd_t, Pat1Pat2), diag->param0 );
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsa_SPC_SASDiagExecuteCmd_t, Threshold), diag->param1 );
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsa_SPC_SASDiagExecuteCmd_t, CodePatErrMsk), diag->param2 );
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsa_SPC_SASDiagExecuteCmd_t, Pmon), diag->param3 );
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsa_SPC_SASDiagExecuteCmd_t, PERF1CTL), diag->param4 );
ret = mpiBuildCmd(agRoot, (bit32 *)&payload, MPI_CATEGORY_SAS_SATA, OPC_INB_SAS_DIAG_EXECUTE, IOMB_SIZE64, queueNum);
}
if (AGSA_RC_SUCCESS != ret)
{
saRoot->IOMap[pRequest->HTag].Tag = MARK_OFF;
saRoot->IOMap[pRequest->HTag].IORequest = agNULL;
saRoot->IOMap[pRequest->HTag].agContext = agNULL;
pRequest->valid = agFALSE;
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("saSASDiagExecute: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
SA_DBG1(("saSASDiagExecute, sending IOMB failed\n" ));
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "6m");
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
return ret;
}
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "6m");
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
return ret;
}
GLOBAL bit32 saSASDiagStartEnd(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 queueNum,
bit32 phyId,
bit32 operation
)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot;
agsaIORequestDesc_t *pRequest;
agsaSASDiagStartEndCmd_t payload;
SA_ASSERT((agNULL != agRoot), "");
if (agRoot == agNULL)
{
SA_DBG1(("saSASDiagStartEnd: agRoot == agNULL\n"));
return AGSA_RC_FAILURE;
}
saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
SA_ASSERT((agNULL != saRoot), "");
if (saRoot == agNULL)
{
SA_DBG1(("saSASDiagStartEnd: saRoot == agNULL\n"));
return AGSA_RC_FAILURE;
}
smTraceFuncEnter(hpDBG_VERY_LOUD,"6n");
SA_DBG3(("saSASDiagStartEnd, phyId 0x%x operation 0x%x\n",phyId,operation ));
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest = (agsaIORequestDesc_t *)saLlistIOGetHead(&(saRoot->freeIORequests));
if ( agNULL == pRequest )
{
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_DBG1(("saSASDiagStartEnd, No request from free list\n" ));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "6n");
return AGSA_RC_BUSY;
}
else
{
saLlistIORemove(&(saRoot->freeIORequests), &(pRequest->linkNode));
saRoot->IOMap[pRequest->HTag].Tag = pRequest->HTag;
saRoot->IOMap[pRequest->HTag].IORequest = (void *)pRequest;
saRoot->IOMap[pRequest->HTag].agContext = agContext;
pRequest->valid = agTRUE;
si_memset(&payload, 0, sizeof(agsaSASDiagStartEndCmd_t));
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaSASDiagStartEndCmd_t, tag), pRequest->HTag);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaSASDiagStartEndCmd_t, OperationPhyId), ((phyId & SM_PHYID_MASK) | (operation << SHIFT8)));
ret = mpiBuildCmd(agRoot, (bit32 *)&payload, MPI_CATEGORY_SAS_SATA, OPC_INB_SAS_DIAG_MODE_START_END, IOMB_SIZE64, queueNum);
if (AGSA_RC_SUCCESS != ret)
{
saRoot->IOMap[pRequest->HTag].Tag = MARK_OFF;
saRoot->IOMap[pRequest->HTag].IORequest = agNULL;
saRoot->IOMap[pRequest->HTag].agContext = agNULL;
pRequest->valid = agFALSE;
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("saSASDiagStartEnd: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
SA_DBG1(("saSASDiagStartEnd, sending IOMB failed\n" ));
}
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "6n");
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
return ret;
}
GLOBAL bit32 saGetTimeStamp(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 queueNum
)
{
agsaIORequestDesc_t *pRequest;
agsaGetTimeStampCmd_t payload;
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot;
SA_ASSERT((agNULL != agRoot), "");
if (agRoot == agNULL)
{
SA_DBG1(("saGetTimeStamp: agRoot == agNULL\n"));
return AGSA_RC_FAILURE;
}
saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
SA_ASSERT((agNULL != saRoot), "");
if (saRoot == agNULL)
{
SA_DBG1(("saGetTimeStamp: saRoot == agNULL\n"));
return AGSA_RC_FAILURE;
}
smTraceFuncEnter(hpDBG_VERY_LOUD,"6o");
SA_ASSERT((agNULL != agRoot), "");
SA_DBG3(("saGetTimeStamp: agContext %p\n", agContext));
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest = (agsaIORequestDesc_t *)saLlistIOGetHead(&(saRoot->freeIORequests));
if ( agNULL == pRequest )
{
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_DBG1(("saGetTimeStamp, No request from free list\n" ));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "6o");
return AGSA_RC_BUSY;
}
else
{
saLlistIORemove(&(saRoot->freeIORequests), &(pRequest->linkNode));
saRoot->IOMap[pRequest->HTag].Tag = pRequest->HTag;
saRoot->IOMap[pRequest->HTag].IORequest = (void *)pRequest;
saRoot->IOMap[pRequest->HTag].agContext = agContext;
pRequest->valid = agTRUE;
si_memset(&payload, 0, sizeof(agsaGetTimeStampCmd_t));
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaGetTimeStampCmd_t, tag), pRequest->HTag);
ret = mpiBuildCmd(agRoot, (bit32 *)&payload, MPI_CATEGORY_SAS_SATA, OPC_INB_GET_TIME_STAMP, IOMB_SIZE64, queueNum);
if (AGSA_RC_SUCCESS != ret)
{
saRoot->IOMap[pRequest->HTag].Tag = MARK_OFF;
saRoot->IOMap[pRequest->HTag].IORequest = agNULL;
saRoot->IOMap[pRequest->HTag].agContext = agNULL;
pRequest->valid = agFALSE;
if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("saGetTimeStamp: saving pRequest (%p) for later use\n", pRequest));
saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
SA_DBG1(("saGetTimeStamp, sending IOMB failed\n" ));
}
}
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "6o");
return ret;
}
static void saUpdateIOMap(
agsaIOMap_t *pIOMap,
bit32 HTag,
agsaIORequestDesc_t *pRequest,
agsaContext_t *agContext
)
{
pIOMap->Tag = HTag;
pIOMap->IORequest = (void *)pRequest;
pIOMap->agContext = agContext;
}
agsaIORequestDesc_t* saGetRequestFromFreePool(
agsaRoot_t *agRoot,
agsaContext_t *agContext
)
{
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
agsaIORequestDesc_t *pRequest = agNULL;
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest = (agsaIORequestDesc_t *)saLlistIOGetHead(&(saRoot->freeIORequests));
if (pRequest != agNULL)
{
saLlistIORemove(&(saRoot->freeIORequests), &(pRequest->linkNode));
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
saUpdateIOMap(&saRoot->IOMap[pRequest->HTag], pRequest->HTag, pRequest, agContext);
pRequest->valid = agTRUE;
}
else
{
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
}
return pRequest;
}
void saReturnRequestToFreePool(
agsaRoot_t *agRoot,
agsaIORequestDesc_t *pRequest
)
{
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
SA_ASSERT((pRequest->valid), "pRequest->valid");
saUpdateIOMap(&saRoot->IOMap[pRequest->HTag], MARK_OFF, agNULL, agNULL);
pRequest->valid = agFALSE;
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
if (saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
{
SA_DBG1(("saReturnRequestToFreePool: 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);
}
GLOBAL bit32 saSgpio(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 queueNum,
agsaSGpioReqResponse_t *pSGpioReq
)
{
bit32 i;
agsaIORequestDesc_t *pRequest = agNULL;
agsaSGpioCmd_t payload = {0};
bit32 ret = AGSA_RC_BUSY;
smTraceFuncEnter(hpDBG_VERY_LOUD,"6t");
SA_ASSERT((agNULL != agRoot), "");
SA_DBG3(("saSgpio: agContext %p\n", agContext));
pRequest = saGetRequestFromFreePool(agRoot, agContext);
if (agNULL == pRequest)
{
SA_DBG1(("saSgpio, No request from free list\n" ));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "6t");
}
else
{
si_memset(&payload, 0, sizeof(agsaSGpioCmd_t));
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaSGpioCmd_t, tag), pRequest->HTag);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaSGpioCmd_t, regIndexRegTypeFunctionFrameType),
(pSGpioReq->smpFrameType |
((bit32)pSGpioReq->function << 8) |
((bit32)pSGpioReq->registerType << 16) |
((bit32)pSGpioReq->registerIndex << 24)));
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaSGpioCmd_t, regCount), pSGpioReq->registerCount);
if (SA_SAS_SMP_WRITE_GPIO_REGISTER == pSGpioReq->function)
{
for (i = 0; i < pSGpioReq->registerCount; i++)
{
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaSGpioCmd_t, writeData) + (i * 4), pSGpioReq->readWriteData[i]);
}
}
ret = mpiBuildCmd(agRoot, (bit32 *)&payload, MPI_CATEGORY_SAS_SATA, OPC_INB_SGPIO, IOMB_SIZE64, queueNum);
if (AGSA_RC_SUCCESS != ret)
{
saReturnRequestToFreePool(agRoot, pRequest);
SA_DBG1(("saSgpio, sending IOMB failed\n" ));
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "6t");
}
return ret;
}
LOCAL void siSpcGetErrorContent(
agsaRoot_t *agRoot
)
{
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
bit32 value, value1;
value = siHalRegReadExt(agRoot, GEN_MSGU_SCRATCH_PAD_1, MSGU_SCRATCH_PAD_1) & SCRATCH_PAD_STATE_MASK;
value1 = siHalRegReadExt(agRoot, GEN_MSGU_SCRATCH_PAD_2, MSGU_SCRATCH_PAD_2) & SCRATCH_PAD_STATE_MASK;
if ((SCRATCH_PAD1_ERR == value) || (SCRATCH_PAD2_ERR == value1))
{
siGetRegisterDumpGSM(agRoot, (void *)&saRoot->registerDump0[0],
REG_DUMP_NUM0, 0, saRoot->mainConfigTable.FatalErrorDumpLength0);
siGetRegisterDumpGSM(agRoot, (void *)&saRoot->registerDump1[0],
REG_DUMP_NUM1, 0, saRoot->mainConfigTable.FatalErrorDumpLength1);
}
}
LOCAL void siSpcvGetErrorContent(
agsaRoot_t *agRoot
)
{
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
bit32 value;
smTraceFuncEnter(hpDBG_VERY_LOUD,"2d");
value = siHalRegReadExt(agRoot, GEN_MSGU_SCRATCH_PAD_1, MSGU_SCRATCH_PAD_1);
if(((value & SPCV_RAAE_STATE_MASK) == SPCV_ERROR_VALUE) ||
((value & SPCV_IOP0_STATE_MASK) == SPCV_ERROR_VALUE) ||
((value & SPCV_IOP1_STATE_MASK) == SPCV_ERROR_VALUE)
)
{
siGetRegisterDumpGSM(agRoot, (void *)&saRoot->registerDump0[0],
REG_DUMP_NUM0, 0, saRoot->mainConfigTable.FatalErrorDumpLength0);
siGetRegisterDumpGSM(agRoot, (void *)&saRoot->registerDump1[0],
REG_DUMP_NUM1, 0, saRoot->mainConfigTable.FatalErrorDumpLength1);
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2d");
}
#define LEFT_BYTE_FAIL(x, v) \
do {if( (x) < (v) ) return AGSA_RC_FAILURE; } while(0);
LOCAL bit32 siDumpInboundQueue(
void * buffer,
bit32 length,
mpiICQueue_t *q
)
{
bit8 * _buf = buffer;
si_memcpy( _buf, (bit8*)(q->memoryRegion.virtPtr) + length, 128*256);
return AGSA_RC_SUCCESS;
}
LOCAL bit32 siDumpOutboundQueue(
void * buffer,
bit32 length,
mpiOCQueue_t *q)
{
bit8 * _buf = buffer;
si_memcpy( _buf, (bit8*)(q->memoryRegion.virtPtr) + length, 128*256);
return AGSA_RC_SUCCESS;
}
LOCAL bit32 siWaitForNonFatalTransfer( agsaRoot_t *agRoot,bit32 pcibar)
{
bit32 status = AGSA_RC_SUCCESS;
bit32 ready;
bit32 max_wait_time;
bit32 max_wait_count;
smTraceFuncEnter(hpDBG_VERY_LOUD,"2c");
SA_DBG4(("siWaitForNonFatalTransfer:0 IBDBS 0x%x\n",ossaHwRegReadExt(agRoot,0 ,V_Inbound_Doorbell_Set_Register ) ));
ossaHwRegWriteExt(agRoot, 0,V_Inbound_Doorbell_Set_Register, SPCV_MSGU_CFG_TABLE_TRANSFER_DEBUG_INFO );
SA_DBG4(("siWaitForNonFatalTransfer:1 IBDBS 0x%x\n",ossaHwRegReadExt(agRoot,0 ,V_Inbound_Doorbell_Set_Register ) ));
max_wait_time = (2000 * 1000);
max_wait_count = MAKE_MODULO(max_wait_time,WAIT_INCREMENT) - WAIT_INCREMENT;
do
{
ossaStallThread(agRoot, WAIT_INCREMENT);
ready = ossaHwRegReadExt(agRoot,0 ,V_Inbound_Doorbell_Set_Register );
} while ( (ready & SPCV_MSGU_CFG_TABLE_TRANSFER_DEBUG_INFO) && (max_wait_count -= WAIT_INCREMENT));
if(max_wait_count == 0)
{
SA_DBG1(("siWaitForNonFatalTransfer:Timeout IBDBS 0x%x\n",ossaHwRegReadExt(agRoot,0 ,V_Inbound_Doorbell_Set_Register ) ));
status = AGSA_RC_FAILURE;
}
SA_DBG4(("siWaitForNonFatalTransfer:3 IBDBS 0x%x\n",ossaHwRegReadExt(agRoot,0 ,V_Inbound_Doorbell_Set_Register ) ));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2c");
return(status);
}
LOCAL bit32 siWaitForFatalTransfer( agsaRoot_t *agRoot,bit32 pcibar)
{
bit32 status = AGSA_RC_SUCCESS;
bit32 ready;
bit32 ErrorTableOffset;
bit32 max_wait_time;
bit32 max_wait_count;
smTraceFuncEnter(hpDBG_VERY_LOUD,"2o");
ErrorTableOffset = siGetTableOffset( agRoot, MAIN_MERRDCTO_MERRDCES );
SA_DBG4(("siWaitForFatalTransfer: MPI_FATAL_EDUMP_TABLE_STATUS Offset 0x%x 0x%x\n",ErrorTableOffset+MPI_FATAL_EDUMP_TABLE_STATUS, ossaHwRegReadExt(agRoot,pcibar ,ErrorTableOffset+MPI_FATAL_EDUMP_TABLE_STATUS )));
SA_DBG4(("siWaitForFatalTransfer: MPI_FATAL_EDUMP_TABLE_ACCUM_LEN Offset 0x%x 0x%x\n",ErrorTableOffset+MPI_FATAL_EDUMP_TABLE_ACCUM_LEN, ossaHwRegReadExt(agRoot,pcibar ,ErrorTableOffset+ MPI_FATAL_EDUMP_TABLE_ACCUM_LEN)));
ossaHwRegWriteExt(agRoot,pcibar ,ErrorTableOffset+MPI_FATAL_EDUMP_TABLE_HANDSHAKE, MPI_FATAL_EDUMP_HANDSHAKE_RDY );
SA_DBG4(("siWaitForFatalTransfer:1 MPI_FATAL_EDUMP_TABLE_HANDSHAKE 0x%x\n",ossaHwRegReadExt(agRoot,pcibar ,ErrorTableOffset+MPI_FATAL_EDUMP_TABLE_HANDSHAKE ) ));
max_wait_time = (2000 * 1000);
max_wait_count = MAKE_MODULO(max_wait_time,WAIT_INCREMENT) - WAIT_INCREMENT;
do
{
ossaStallThread(agRoot, WAIT_INCREMENT);
ready = ossaHwRegReadExt(agRoot,0 ,ErrorTableOffset+MPI_FATAL_EDUMP_TABLE_HANDSHAKE );
} while (ready && (max_wait_count -= WAIT_INCREMENT));
if(max_wait_count == 0)
{
SA_DBG1(("siWaitForFatalTransfer : 1 Timeout\n"));
status = AGSA_RC_FAILURE;
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2o");
return(status);
}
LOCAL bit32 siFatalErrorBuffer(
agsaRoot_t *agRoot,
agsaForensicData_t *forensicData
)
{
bit32 status = AGSA_RC_FAILURE;
bit32 pcibar;
bit32 ErrorTableOffset;
bit32 Accum_len = 0;
agsaLLRoot_t *saRoot;
SA_ASSERT( (agNULL != agRoot), "");
saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
SA_ASSERT( (agNULL != saRoot), "saRoot");
if(agNULL == saRoot )
{
SA_DBG1(("siFatalErrorBuffer: agNULL saRoot\n"));
return(status);
}
if(saRoot->ResetFailed )
{
SA_DBG1(("siFatalErrorBuffer: saRoot->ResetFailed\n"));
return(status);
}
smTraceFuncEnter(hpDBG_VERY_LOUD,"2a");
SA_DBG2(("siFatalErrorBuffer:In %p Offset 0x%08x Len 0x%08x Totel len 0x%x\n",
forensicData->BufferType.dataBuf.directData,
forensicData->BufferType.dataBuf.directOffset,
forensicData->BufferType.dataBuf.directLen,
forensicData->BufferType.dataBuf.readLen ));
pcibar = siGetPciBar(agRoot);
ErrorTableOffset = siGetTableOffset( agRoot, MAIN_MERRDCTO_MERRDCES );
SA_DBG3(("siFatalErrorBuffer: MPI_FATAL_EDUMP_TABLE_STATUS 0x%x LEN 0x%x\n",
ossaHwRegReadExt(agRoot,pcibar ,ErrorTableOffset+MPI_FATAL_EDUMP_TABLE_STATUS),
ossaHwRegReadExt(agRoot,pcibar ,ErrorTableOffset+ MPI_FATAL_EDUMP_TABLE_ACCUM_LEN) ));
if(forensicData->BufferType.dataBuf.directOffset == 0)
{
ossaHwRegWriteExt(agRoot, pcibar,V_MEMBASE_II_ShiftRegister, saRoot->FatalForensicShiftOffset);
saRoot->ForensicLastOffset =0;
saRoot->FatalForensicStep = 0;
saRoot->FatalBarLoc = 0;
saRoot->FatalForensicShiftOffset = 0;
SA_DBG1(("siFatalErrorBuffer: directOffset zero SCRATCH_PAD1 0x%x\n", siHalRegReadExt(agRoot,GEN_MSGU_SCRATCH_PAD_1, MSGU_SCRATCH_PAD_1) ));
}
Accum_len = ossaHwRegReadExt(agRoot,pcibar ,ErrorTableOffset+ MPI_FATAL_EDUMP_TABLE_ACCUM_LEN);
SA_DBG2(("siFatalErrorBuffer: Accum_len 0x%x\n", Accum_len));
if(Accum_len == 0xFFFFFFFF)
{
SA_DBG1(("siFatalErrorBuffer: Possible PCI issue 0x%x not expected\n", Accum_len));
return(status);
}
if( Accum_len == 0 || Accum_len >=0x100000 )
{
SA_DBG1(("siFatalErrorBuffer: Accum_len == saRoot->FatalCurrentLength 0x%x\n", Accum_len));
return(IOCTL_ERROR_NO_FATAL_ERROR);
}
if(saRoot->FatalForensicStep == 0)
{
moreData:
if(forensicData->BufferType.dataBuf.directData)
{
siPciCpyMem(agRoot,saRoot->FatalBarLoc ,forensicData->BufferType.dataBuf.directData,forensicData->BufferType.dataBuf.directLen ,1 );
}
saRoot->FatalBarLoc += forensicData->BufferType.dataBuf.directLen;
forensicData->BufferType.dataBuf.directOffset += forensicData->BufferType.dataBuf.directLen;
saRoot->ForensicLastOffset += forensicData->BufferType.dataBuf.directLen;
forensicData->BufferType.dataBuf.readLen = forensicData->BufferType.dataBuf.directLen;
if(saRoot->ForensicLastOffset >= Accum_len)
{
SA_DBG1(("siFatalErrorBuffer: Accum_len reached 0x%x directOffset 0x%x\n",Accum_len,forensicData->BufferType.dataBuf.directOffset ));
saRoot->FatalBarLoc = 0;
saRoot->FatalForensicStep = 1;
saRoot->FatalForensicShiftOffset = 0;
status = AGSA_RC_COMPLETE;
return status;
}
if(saRoot->FatalBarLoc < (64*1024))
{
SA_DBG2(("siFatalErrorBuffer: In same 64k FatalBarLoc 0x%x\n",saRoot->FatalBarLoc ));
status = AGSA_RC_SUCCESS;
return status;
}
saRoot->FatalForensicShiftOffset+= 0x100;
ossaHwRegWriteExt(agRoot, pcibar,V_MEMBASE_II_ShiftRegister, saRoot->FatalForensicShiftOffset);
saRoot->FatalBarLoc = 0;
SA_DBG1(("siFatalErrorBuffer: Get next bar data 0x%x\n",saRoot->FatalForensicShiftOffset));
status = AGSA_RC_SUCCESS;
SA_DBG1(("siFatalErrorBuffer:Offset 0x%x BarLoc 0x%x\n",saRoot->FatalForensicShiftOffset,saRoot->FatalBarLoc ));
SA_DBG1(("siFatalErrorBuffer: step 0 status %d %p Offset 0x%x Len 0x%x total_len 0x%x\n",
status,
forensicData->BufferType.dataBuf.directData,
forensicData->BufferType.dataBuf.directOffset,
forensicData->BufferType.dataBuf.directLen,
forensicData->BufferType.dataBuf.readLen ));
return(status);
}
if(saRoot->FatalForensicStep == 1)
{
SA_DBG1(("siFatalErrorBuffer: FatalForensicStep 1 Accum_len 0x%X MPI_FATAL_EDUMP_TABLE_ACCUM_LEN 0x%x\n",
Accum_len,
ossaHwRegReadExt(agRoot,pcibar ,ErrorTableOffset+ MPI_FATAL_EDUMP_TABLE_ACCUM_LEN)));
saRoot->FatalForensicShiftOffset = 0;
ossaHwRegWriteExt(agRoot, pcibar,V_MEMBASE_II_ShiftRegister ,saRoot->FatalForensicShiftOffset);
SA_DBG1(("siFatalErrorBuffer: FatalForensicStep 1\n" ));
siWaitForFatalTransfer( agRoot,pcibar);
saRoot->FatalForensicStep = 0;
if( ossaHwRegReadExt(agRoot,pcibar ,ErrorTableOffset+ MPI_FATAL_EDUMP_TABLE_STATUS) != MPI_FATAL_EDUMP_TABLE_STAT_NF_SUCCESS_DONE )
{
SA_DBG3(("siFatalErrorBuffer:Step 3\n" ));
SA_DBG3(("siFatalErrorBuffer:Step 3 MPI_FATAL_EDUMP_TABLE_STATUS 0x%x\n", ossaHwRegReadExt(agRoot,pcibar ,ErrorTableOffset+ MPI_FATAL_EDUMP_TABLE_STATUS )));
ossaHwRegWriteExt(agRoot,pcibar ,ErrorTableOffset+MPI_FATAL_EDUMP_TABLE_STATUS, 0 );
goto moreData;
}
else
{
SA_DBG3(("siFatalErrorBuffer:Step 4\n" ));
SA_DBG1(("siFatalErrorBuffer: Done Read 0x%x accum 0x%x\n",
forensicData->BufferType.dataBuf.directOffset,
ossaHwRegReadExt(agRoot,pcibar ,ErrorTableOffset+ MPI_FATAL_EDUMP_TABLE_ACCUM_LEN)));
#if defined(SALLSDK_DEBUG)
SA_DBG1(("siFatalErrorBuffer: SCRATCH_PAD1_V_ERROR_STATE 0x%x\n",SCRATCH_PAD1_V_ERROR_STATE( siHalRegReadExt(agRoot,GEN_MSGU_SCRATCH_PAD_1, MSGU_SCRATCH_PAD_1) )));
SA_DBG1(("siFatalErrorBuffer: SCRATCH_PAD0 value = 0x%x\n", siHalRegReadExt(agRoot,GEN_MSGU_SCRATCH_PAD_0, MSGU_SCRATCH_PAD_0)));
SA_DBG1(("siFatalErrorBuffer: SCRATCH_PAD1 value = 0x%x\n", siHalRegReadExt(agRoot,GEN_MSGU_SCRATCH_PAD_1, MSGU_SCRATCH_PAD_1)));
SA_DBG1(("siFatalErrorBuffer: SCRATCH_PAD2 value = 0x%x\n", siHalRegReadExt(agRoot,GEN_MSGU_SCRATCH_PAD_2, MSGU_SCRATCH_PAD_2)));
SA_DBG1(("siFatalErrorBuffer: SCRATCH_PAD3 value = 0x%x\n", siHalRegReadExt(agRoot,GEN_MSGU_SCRATCH_PAD_3, MSGU_SCRATCH_PAD_3)));
#endif
forensicData->BufferType.dataBuf.readLen = 0xFFFFFFFF;
status = AGSA_RC_SUCCESS;
}
}
SA_DBG3(("siFatalErrorBuffer:status 0x%x %p directOffset 0x%x directLen 0x%x readLen 0x%x\n",
status,
forensicData->BufferType.dataBuf.directData,
forensicData->BufferType.dataBuf.directOffset,
forensicData->BufferType.dataBuf.directLen,
forensicData->BufferType.dataBuf.readLen ));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2a");
return(status);
}
LOCAL bit32 siNonFatalErrorBuffer(
agsaRoot_t *agRoot,
agsaForensicData_t *forensicData
)
{
bit32 status = AGSA_RC_FAILURE;
bit32 pcibar;
bit32 ErrorTableOffset;
bit32 ready;
bit32 biggest;
bit32 max_wait_time;
bit32 max_wait_count;
agsaLLRoot_t *saRoot;
SA_ASSERT( (agNULL != agRoot), "agRoot");
saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
SA_ASSERT( (agNULL != saRoot), "saRoot");
if(agNULL == saRoot )
{
SA_DBG1(("siNonFatalErrorBuffer: agNULL saRoot\n"));
return(status);
}
smTraceFuncEnter(hpDBG_VERY_LOUD,"2b");
pcibar = siGetPciBar(agRoot);
ErrorTableOffset = siGetTableOffset( agRoot, MAIN_MERRDCTO_MERRDCES );
SA_DBG4(("siNonFatalErrorBuffer: ErrorTableOffset 0x%x\n",ErrorTableOffset ));
SA_DBG4(("siNonFatalErrorBuffer: MPI_FATAL_EDUMP_TABLE_STATUS Offset 0x%x 0x%x\n",
ErrorTableOffset + MPI_FATAL_EDUMP_TABLE_STATUS,
ossaHwRegReadExt(agRoot,pcibar,ErrorTableOffset + MPI_FATAL_EDUMP_TABLE_STATUS)));
SA_DBG4(("siNonFatalErrorBuffer: MPI_FATAL_EDUMP_TABLE_ACCUM_LEN Offset 0x%x 0x%x\n",
ErrorTableOffset + MPI_FATAL_EDUMP_TABLE_ACCUM_LEN,
ossaHwRegReadExt(agRoot,pcibar,ErrorTableOffset + MPI_FATAL_EDUMP_TABLE_ACCUM_LEN)));
biggest = saRoot->memoryAllocated.agMemory[HDA_DMA_BUFFER].totalLength;
if(biggest >= forensicData->BufferType.dataBuf.directLen )
{
biggest = forensicData->BufferType.dataBuf.directLen;
}
else
{
SA_DBG1(("siNonFatalErrorBuffer: directLen larger than DMA Buffer 0x%x < 0x%x\n",
biggest, forensicData->BufferType.dataBuf.directLen));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2b");
return(AGSA_RC_FAILURE);
}
if(saRoot->memoryAllocated.agMemory[HDA_DMA_BUFFER].virtPtr)
{
si_memset(saRoot->memoryAllocated.agMemory[HDA_DMA_BUFFER].virtPtr, 0, biggest);
}
else
{
SA_DBG1(("siNonFatalErrorBuffer: Error\n" ));
return(AGSA_RC_FAILURE);
}
if(forensicData->BufferType.dataBuf.directOffset)
{
ossaHwRegWriteExt(agRoot, pcibar, ErrorTableOffset + MPI_FATAL_EDUMP_TABLE_STATUS, 0);
goto skip_setup;
}
SA_DBG1(("siNonFatalErrorBuffer: %p Offset 0x%x Len 0x%x total_len 0x%x\n",
forensicData->BufferType.dataBuf.directData,
forensicData->BufferType.dataBuf.directOffset,
forensicData->BufferType.dataBuf.directLen,
forensicData->BufferType.dataBuf.readLen ));
SA_DBG1(("siNonFatalErrorBuffer: directOffset zero setup\n" ));
SA_DBG1(("siNonFatalErrorBuffer: MPI_FATAL_EDUMP_TABLE_STATUS 0x%x LEN 0x%x\n",
ossaHwRegReadExt(agRoot,pcibar ,ErrorTableOffset+MPI_FATAL_EDUMP_TABLE_STATUS),
ossaHwRegReadExt(agRoot,pcibar ,ErrorTableOffset+ MPI_FATAL_EDUMP_TABLE_ACCUM_LEN) ));
SA_DBG1(("siNonFatalErrorBuffer: Clear V_Scratchpad_Rsvd_0_Register 0x%x\n",
ossaHwRegReadExt(agRoot, 0,V_Scratchpad_Rsvd_0_Register) ));
ossaHwRegWriteExt(agRoot, 0,V_Scratchpad_Rsvd_0_Register ,0);
saRoot->ForensicLastOffset = 0;
ossaHwRegWriteExt(agRoot, pcibar, ErrorTableOffset + MPI_FATAL_EDUMP_TABLE_LO_OFFSET, saRoot->memoryAllocated.agMemory[HDA_DMA_BUFFER].phyAddrLower);
ossaHwRegWriteExt(agRoot, pcibar, ErrorTableOffset + MPI_FATAL_EDUMP_TABLE_HI_OFFSET, saRoot->memoryAllocated.agMemory[HDA_DMA_BUFFER].phyAddrUpper);
ossaHwRegWriteExt(agRoot, pcibar, ErrorTableOffset + MPI_FATAL_EDUMP_TABLE_LENGTH, biggest);
ossaHwRegWriteExt(agRoot, pcibar, ErrorTableOffset + MPI_FATAL_EDUMP_TABLE_STATUS, 0);
ossaHwRegWriteExt(agRoot, pcibar, ErrorTableOffset + MPI_FATAL_EDUMP_TABLE_ACCUM_LEN, 0);
SA_DBG4(("siNonFatalErrorBuffer: MPI_FATAL_EDUMP_TABLE_STATUS Offset 0x%x 0x%x\n",
ErrorTableOffset + MPI_FATAL_EDUMP_TABLE_STATUS,
ossaHwRegReadExt(agRoot,pcibar,ErrorTableOffset + MPI_FATAL_EDUMP_TABLE_STATUS )));
SA_DBG4(("siNonFatalErrorBuffer: MPI_FATAL_EDUMP_TABLE_ACCUM_LEN Offset 0x%x 0x%x\n",
ErrorTableOffset + MPI_FATAL_EDUMP_TABLE_ACCUM_LEN,
ossaHwRegReadExt(agRoot, pcibar, ErrorTableOffset + MPI_FATAL_EDUMP_TABLE_ACCUM_LEN)));
if( 0 != ossaHwRegReadExt(agRoot, pcibar, ErrorTableOffset + MPI_FATAL_EDUMP_TABLE_ACCUM_LEN))
{
SA_DBG1(("siNonFatalErrorBuffer: MPI_FATAL_EDUMP_TABLE_ACCUM_LEN 0x%x 0x%x\n",
forensicData->BufferType.dataBuf.directOffset,
ossaHwRegReadExt(agRoot, pcibar, ErrorTableOffset + MPI_FATAL_EDUMP_TABLE_ACCUM_LEN)));
}
skip_setup:
if( saRoot->ForensicLastOffset == 0xFFFFFFFF)
{
forensicData->BufferType.dataBuf.readLen = 0xFFFFFFFF;
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "2b");
return(AGSA_RC_SUCCESS);
}
siWaitForNonFatalTransfer(agRoot,pcibar);
SA_DBG3(("siNonFatalErrorBuffer: MPI_FATAL_EDUMP_TABLE_STATUS 0x%x LEN 0x%x\n",
ossaHwRegReadExt(agRoot,pcibar ,ErrorTableOffset+MPI_FATAL_EDUMP_TABLE_STATUS),
ossaHwRegReadExt(agRoot,pcibar ,ErrorTableOffset+ MPI_FATAL_EDUMP_TABLE_ACCUM_LEN) ));
max_wait_time = (2000 * 1000);
max_wait_count = MAKE_MODULO(max_wait_time,WAIT_INCREMENT) - WAIT_INCREMENT;
ready = ossaHwRegReadExt(agRoot,pcibar,ErrorTableOffset + MPI_FATAL_EDUMP_TABLE_STATUS );
do
{
ossaStallThread(agRoot, WAIT_INCREMENT);
ready = ossaHwRegReadExt(agRoot,pcibar ,ErrorTableOffset + MPI_FATAL_EDUMP_TABLE_STATUS );
forensicData->BufferType.dataBuf.directOffset = ossaHwRegReadExt(agRoot,pcibar,ErrorTableOffset + MPI_FATAL_EDUMP_TABLE_ACCUM_LEN);
if( ready == MPI_FATAL_EDUMP_TABLE_STAT_NF_SUCCESS_MORE_DATA )
{
SA_DBG2(("siNonFatalErrorBuffer: More data available MPI_FATAL_EDUMP_TABLE_ACCUM_LEN 0x%x\n", ossaHwRegReadExt(agRoot,pcibar,ErrorTableOffset+ MPI_FATAL_EDUMP_TABLE_ACCUM_LEN) ));
break;
}
} while ( ready != MPI_FATAL_EDUMP_TABLE_STAT_NF_SUCCESS_DONE && (max_wait_count -= WAIT_INCREMENT));
if(max_wait_count == 0 || ready == MPI_FATAL_EDUMP_TABLE_STAT_DMA_FAILED)
{
status = AGSA_RC_FAILURE;
SA_DBG1(("siNonFatalErrorBuffer: timeout waiting ready\n"));
}
else
{
forensicData->BufferType.dataBuf.readLen = forensicData->BufferType.dataBuf.directOffset - saRoot->ForensicLastOffset;
if( ready == MPI_FATAL_EDUMP_TABLE_STAT_NF_SUCCESS_DONE && forensicData->BufferType.dataBuf.readLen == 0)
{
SA_DBG1(("siNonFatalErrorBuffer:ready 0x%x readLen 0x%x\n",ready ,forensicData->BufferType.dataBuf.readLen));
saRoot->ForensicLastOffset = 0xFFFFFFFF;
}
else
{
saRoot->ForensicLastOffset = forensicData->BufferType.dataBuf.directOffset;
}
if(forensicData->BufferType.dataBuf.directData )
{
si_memcpy(forensicData->BufferType.dataBuf.directData, saRoot->memoryAllocated.agMemory[HDA_DMA_BUFFER].virtPtr,biggest);
}
status = AGSA_RC_SUCCESS;
}
SA_DBG3(("siNonFatalErrorBuffer: %p directOffset 0x%x directLen 0x%x readLen 0x%x\n",
forensicData->BufferType.dataBuf.directData,
forensicData->BufferType.dataBuf.directOffset,
forensicData->BufferType.dataBuf.directLen,
forensicData->BufferType.dataBuf.readLen ));
smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "2b");
return(status);
}
LOCAL bit32 siGetForensicData(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
agsaForensicData_t *forensicData
)
{
bit32 status = AGSA_RC_FAILURE;
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
smTraceFuncEnter(hpDBG_VERY_LOUD,"2Z");
if(forensicData->DataType == TYPE_GSM_SPACE)
{
#define _1M 0x100000
if( forensicData->BufferType.gsmBuf.directLen >= _1M )
{
return AGSA_RC_FAILURE;
}
if(forensicData->BufferType.dataBuf.readLen)
{
SA_DBG1(("siGetForensicData: Incorrect readLen 0x%08X\n", forensicData->BufferType.dataBuf.readLen));
forensicData->BufferType.dataBuf.readLen = forensicData->BufferType.dataBuf.directLen;
}
if( forensicData->BufferType.dataBuf.directOffset >= ONE_MEGABYTE )
{
SA_DBG1(("siGSMDump: total length > ONE_MEGABYTE 0x%x\n",forensicData->BufferType.dataBuf.directOffset));
forensicData->BufferType.dataBuf.readLen = 0xFFFFFFFF;
return(AGSA_RC_SUCCESS);
}
if(smIS_SPC(agRoot))
{
if( forensicData->BufferType.dataBuf.directLen >= SIXTYFOURKBYTE )
{
SA_DBG1(("siGetForensicData directLen too large !\n"));
return AGSA_RC_FAILURE;
}
SA_DBG1(("siGetForensicData: TYPE_GSM_SPACE directLen 0x%X directOffset 0x%08X %p\n",
forensicData->BufferType.dataBuf.directLen,
forensicData->BufferType.dataBuf.directOffset,
forensicData->BufferType.dataBuf.directData ));
if (AGSA_RC_FAILURE == siBar4Shift(agRoot, BAR_SHIFT_GSM_OFFSET + forensicData->BufferType.dataBuf.directOffset))
{
SA_DBG1(("siGSMDump:Shift Bar4 to 0x%x failed\n", 0x0));
return AGSA_RC_FAILURE;
}
forensicData->BufferType.gsmBuf.directOffset = 0;
}
status = siGSMDump( agRoot,
forensicData->BufferType.gsmBuf.directOffset,
forensicData->BufferType.gsmBuf.directLen,
forensicData->BufferType.gsmBuf.directData );
if(status == AGSA_RC_SUCCESS)
{
forensicData->BufferType.dataBuf.readLen = forensicData->BufferType.dataBuf.directLen;
}
if( forensicData->BufferType.dataBuf.directOffset == 0 )
{
SA_DBG1(("siGetForensicData: TYPE_GSM_SPACE readLen 0x%08X\n", forensicData->BufferType.dataBuf.readLen));
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "2Z");
return status;
}
else if(forensicData->DataType == TYPE_INBOUND_QUEUE )
{
mpiICQueue_t *circularQ = NULL;
SA_DBG2(("siGetForensicData: TYPE_INBOUND \n"));
if(forensicData->BufferType.queueBuf.queueIndex >=AGSA_MAX_INBOUND_Q )
{
smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "2Z");
return AGSA_RC_FAILURE;
}
circularQ = &saRoot->inboundQueue[forensicData->BufferType.queueBuf.queueIndex];
status = siDumpInboundQueue( forensicData->BufferType.queueBuf.directData,
forensicData->BufferType.queueBuf.directLen,
circularQ );
smTraceFuncExit(hpDBG_VERY_LOUD, 'e', "2Z");
return status;
}
else if(forensicData->DataType == TYPE_OUTBOUND_QUEUE )
{
mpiOCQueue_t *circularQ = NULL;
SA_DBG2(("siGetForensicData: TYPE_OUTBOUND\n"));
if(forensicData->BufferType.queueBuf.queueIndex >= AGSA_MAX_OUTBOUND_Q )
{
smTraceFuncExit(hpDBG_VERY_LOUD, 'd', "2Z");
return AGSA_RC_FAILURE;
}
circularQ = &saRoot->outboundQueue[forensicData->BufferType.queueBuf.queueIndex];
status = siDumpOutboundQueue(forensicData->BufferType.queueBuf.directData,
forensicData->BufferType.queueBuf.directLen,
circularQ );
smTraceFuncExit(hpDBG_VERY_LOUD, 'e', "2Z");
return status;
}
else if(forensicData->DataType == TYPE_NON_FATAL )
{
SA_DBG2(("siGetForensicData:TYPE_NON_FATAL \n"));
status = siNonFatalErrorBuffer(agRoot,forensicData);
smTraceFuncExit(hpDBG_VERY_LOUD, 'f', "2Z");
return status;
}
else if(forensicData->DataType == TYPE_FATAL )
{
SA_DBG2(("siGetForensicData:TYPE_NON_FATAL \n"));
status = siFatalErrorBuffer(agRoot,forensicData );
smTraceFuncExit(hpDBG_VERY_LOUD, 'g', "2Z");
return status;
}
else
{
SA_DBG1(("siGetForensicData receive error parameter!\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'h', "2Z");
return AGSA_RC_FAILURE;
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'i', "2Z");
return status;
}
bit32 saGetForensicData(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
agsaForensicData_t *forensicData
)
{
bit32 status;
status = siGetForensicData(agRoot, agContext, forensicData);
ossaGetForensicDataCB(agRoot, agContext, status, forensicData);
return status;
}
bit32 saGetIOErrorStats(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 flag
)
{
agsaLLRoot_t *saRoot = (agsaLLRoot_t*)agRoot->sdkData;
bit32 status = AGSA_RC_SUCCESS;
ossaGetIOErrorStatsCB(agRoot, agContext, status, &saRoot->IoErrorCount);
if (flag)
{
si_memset(&saRoot->IoErrorCount, 0, sizeof(agsaIOErrorEventStats_t));
}
return status;
}
bit32 saGetIOEventStats(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 flag
)
{
agsaLLRoot_t *saRoot = (agsaLLRoot_t*)agRoot->sdkData;
bit32 status = AGSA_RC_SUCCESS;
ossaGetIOEventStatsCB(agRoot, agContext, status, &saRoot->IoEventCount);
if (flag)
{
si_memset(&saRoot->IoEventCount, 0, sizeof(agsaIOErrorEventStats_t));
}
return status;
}
bit32 saGetRegisterDump(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 queueNum,
agsaRegDumpInfo_t *regDumpInfo
)
{
agsaLLRoot_t *saRoot = agNULL;
bit32 ret = AGSA_RC_SUCCESS;
smTraceFuncEnter(hpDBG_VERY_LOUD,"6p");
SA_ASSERT((agNULL != agRoot), "");
saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
SA_ASSERT((agNULL != saRoot), "");
SA_ASSERT((agNULL != regDumpInfo), "");
SA_DBG3(("saGetRegisterDump: agContext %p\n", agContext));
if (regDumpInfo->regDumpSrc > 3)
{
SA_DBG1(("saGetRegisterDump, regDumpSrc %d or regDumpNum %d invalid\n",
regDumpInfo->regDumpNum, regDumpInfo->regDumpNum));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "6p");
ossaGetRegisterDumpCB(agRoot, agContext, OSSA_FAILURE);
return AGSA_RC_FAILURE;
}
switch(regDumpInfo->regDumpSrc)
{
case REG_DUMP_NONFLASH:
if (regDumpInfo->regDumpNum == GET_IOST_RB_INFO)
{
regDumpInfo->regDumpOffset = regDumpInfo->regDumpOffset + 0;
ret = siGSMDump(agRoot, regDumpInfo->regDumpOffset, regDumpInfo->directLen, regDumpInfo->directData);
ossaGetRegisterDumpCB(agRoot, agContext, ret);
return ret;
}
if (regDumpInfo->regDumpNum == GET_GSM_SM_INFO)
{
bit32 offset;
if(smIS_SPC(agRoot))
{
offset = regDumpInfo->regDumpOffset + SPC_GSM_SM_OFFSET;
}else if(smIS_SPCV(agRoot))
{
offset = regDumpInfo->regDumpOffset + SPCV_GSM_SM_OFFSET;
} else
{
SA_DBG1(("saGetRegisterDump: the device type is not support\n"));
return AGSA_RC_FAILURE;
}
ret = siGSMDump(agRoot, offset, regDumpInfo->directLen, regDumpInfo->directData);
ossaGetRegisterDumpCB(agRoot, agContext, ret);
return ret;
}
if(smIS_SPC(agRoot)) {
siSpcGetErrorContent(agRoot);
}
else if(smIS_SPCV(agRoot)) {
siSpcvGetErrorContent(agRoot);
}
if (regDumpInfo->directLen > REGISTER_DUMP_BUFF_SIZE)
{
SA_DBG1(("saGetRegisterDump, Request too many bytes %d\n",
regDumpInfo->directLen));
regDumpInfo->directLen = REGISTER_DUMP_BUFF_SIZE;
}
if (regDumpInfo->regDumpNum == 0)
{
si_memcpy(regDumpInfo->directData, (bit8 *)&saRoot->registerDump0[0] +
regDumpInfo->regDumpOffset, regDumpInfo->directLen);
}
else if( regDumpInfo->regDumpNum == 1)
{
si_memcpy(regDumpInfo->directData, (bit8 *)&saRoot->registerDump1[0] +
regDumpInfo->regDumpOffset, regDumpInfo->directLen);
} else {
SA_DBG1(("saGetRegisterDump, the regDumpNum value is wrong %x\n",
regDumpInfo->regDumpNum));
}
ossaGetRegisterDumpCB(agRoot, agContext, OSSA_SUCCESS);
break;
case REG_DUMP_FLASH:
ret = mpiNVMReadRegDumpCmd(agRoot, agContext, queueNum,
regDumpInfo->regDumpNum,
regDumpInfo->regDumpOffset,
regDumpInfo->indirectAddrUpper32,
regDumpInfo->indirectAddrLower32,
regDumpInfo->indirectLen);
break;
default:
break;
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "6p");
return ret;
}
bit32 siGetRegisterDumpGSM(
agsaRoot_t *agRoot,
void *destinationAddress,
bit32 regDumpNum,
bit32 regDumpOffset,
bit32 len
)
{
agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
bit32 ret = AGSA_RC_SUCCESS;
bit32 rDumpOffset, rDumpLen;
bit8 *dst;
smTraceFuncEnter(hpDBG_VERY_LOUD,"2V");
SA_ASSERT((agNULL != agRoot), "");
dst = (bit8 *)destinationAddress;
if (regDumpNum > 1)
{
SA_DBG1(("siGetRegisterDump, regDumpNum %d is invalid\n", regDumpNum));
return AGSA_RC_FAILURE;
}
if (!regDumpNum)
{
rDumpOffset = saRoot->mainConfigTable.FatalErrorDumpOffset0;
rDumpLen = saRoot->mainConfigTable.FatalErrorDumpLength0;
}
else
{
rDumpOffset = saRoot->mainConfigTable.FatalErrorDumpOffset1;
rDumpLen = saRoot->mainConfigTable.FatalErrorDumpLength1;
}
if (len > rDumpLen)
{
SA_DBG1(("siGetRegisterDump, Request too many bytes %d, rDumpLen %d\n", len, rDumpLen));
len = rDumpLen;
}
if (regDumpOffset >= len)
{
SA_DBG1(("siGetRegisterDump, Offset is not within the area %d, regDumpOffset%d\n", rDumpLen, regDumpOffset));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2V");
return AGSA_RC_FAILURE;
}
if ((len % 4) > 0)
{
len = (len/4 + 1) * 4;
}
ret = siGSMDump(agRoot, rDumpOffset, len, dst);
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "2V");
return ret;
}
bit32 saGetNVMDCommand(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 queueNum,
agsaNVMDData_t *NVMDInfo
)
{
bit32 ret = AGSA_RC_SUCCESS;
SA_ASSERT((agNULL != agRoot), "");
ret = mpiGetNVMDCmd(agRoot, agContext, NVMDInfo, queueNum);
return ret;
}
bit32 saSetNVMDCommand(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 queueNum,
agsaNVMDData_t *NVMDInfo
)
{
bit32 ret = AGSA_RC_SUCCESS;
SA_ASSERT((agNULL != agRoot), "");
ret = mpiSetNVMDCmd(agRoot, agContext, NVMDInfo, queueNum);
return ret;
}
GLOBAL bit32 saSendSMPIoctl(
agsaRoot_t *agRoot,
agsaDevHandle_t *agDevHandle,
bit32 queueNum,
agsaSMPFrame_t *pSMPFrame,
ossaSMPCompletedCB_t agCB
)
{
bit32 ret = AGSA_RC_SUCCESS;
bit32 retVal;
bit8 inq, outq;
agsaIORequestDesc_t *pRequest;
void *pMessage;
bit8 *payload_ptr;
agsaDeviceDesc_t *pDevice;
bit8 using_reserved = agFALSE;
agsaPort_t *pPort;
mpiICQueue_t *circularQ;
agsaLLRoot_t *saRoot = agNULL;
saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
SA_ASSERT((agNULL != saRoot), "");
SA_ASSERT((agNULL != agRoot), "");
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest = (agsaIORequestDesc_t *)saLlistIOGetHead(&(saRoot->freeIORequests));
if ( agNULL == pRequest )
{
pRequest = (agsaIORequestDesc_t *)saLlistIOGetHead(&(saRoot->freeReservedRequests));
if(agNULL != pRequest)
{
using_reserved = agTRUE;
SA_DBG1(("saSMPStart, using saRoot->freeReservedRequests\n"));
}
else
{
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_DBG1(("saSMPStart, No request from free list Not using saRoot->freeReservedRequests\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "9a");
return AGSA_RC_BUSY;
}
}
inq = (bit8)(queueNum & MPI_IB_NUM_MASK);
outq = (bit8)((queueNum & MPI_OB_NUM_MASK) >> MPI_OB_SHIFT);
SA_ASSERT((agNULL != agDevHandle), "");
if (agNULL == agDevHandle->sdkData)
{
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_DBG1(("saSMPStart, Device has been removed. agDevHandle=%p\n", agDevHandle));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "9a");
return AGSA_RC_FAILURE;
}
pDevice = (agsaDeviceDesc_t *) (agDevHandle->sdkData);
pPort = pDevice->pPort;
if( using_reserved )
{
saLlistIORemove(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
}
else
{
saLlistIORemove(&(saRoot->freeIORequests), &(pRequest->linkNode));
}
saLlistIOAdd(&(pDevice->pendingIORequests), &(pRequest->linkNode));
SA_ASSERT((!pRequest->valid), "The pRequest is in use");
pRequest->valid = agTRUE;
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->pIORequestContext = (agsaIORequest_t *)pRequest;
pRequest->pDevice = pDevice;
pRequest->pPort = pPort;
pRequest->startTick = saRoot->timeTick;
pRequest->completionCB = (ossaSSPCompletedCB_t)agCB;
pRequest->requestType = AGSA_SMP_IOCTL_REQUEST;
saRoot->IOMap[pRequest->HTag].Tag = pRequest->HTag;
saRoot->IOMap[pRequest->HTag].IORequest = (void *)pRequest;
#ifdef SA_LL_IBQ_PROTECT
ossaSingleThreadedEnter(agRoot, LL_IOREQ_IBQ0_LOCK + inq);
#endif
circularQ = &saRoot->inboundQueue[inq];
retVal = mpiMsgFreeGet(circularQ, IOMB_SIZE64, &pMessage);
if (AGSA_RC_FAILURE == retVal)
{
#ifdef SA_LL_IBQ_PROTECT
ossaSingleThreadedLeave(agRoot, LL_IOREQ_IBQ0_LOCK + inq);
#endif
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
saLlistIORemove(&(pDevice->pendingIORequests), &(pRequest->linkNode));
pRequest->valid = agFALSE;
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_DBG1(("saSMPStart, error when get free IOMB\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "9a");
return AGSA_RC_FAILURE;
}
if (AGSA_RC_BUSY == retVal)
{
#ifdef SA_LL_IBQ_PROTECT
ossaSingleThreadedLeave(agRoot, LL_IOREQ_IBQ0_LOCK + inq);
#endif
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
saLlistIORemove(&(pDevice->pendingIORequests), &(pRequest->linkNode));
pRequest->valid = agFALSE;
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_DBG1(("saSMPStart, no more IOMB\n"));
smTraceFuncExit(hpDBG_VERY_LOUD, 'd', "9a");
return AGSA_RC_BUSY;
}
#ifdef SA_LL_IBQ_PROTECT
ossaSingleThreadedLeave(agRoot, LL_IOREQ_IBQ0_LOCK + inq);
#endif
if(smIS_SPC(agRoot))
{
agsaSMPCmd_t payload;
bit32 IR_IP_OV_res_phyId_DPdLen_res = 0;
si_memset(&payload, 0, sizeof(agsaSMPCmd_V_t));
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaSMPCmd_t, tag), pRequest->HTag);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaSMPCmd_t, deviceId), pDevice->DeviceMapIndex);
if (smpFrameFlagIndirectResponse & pSMPFrame->flag && smpFrameFlagIndirectPayload & pSMPFrame->flag)
{
SA_DBG2(("saSMPStart:V Indirect payload and indirect response\n"));
pRequest->IRmode = INDIRECT_MODE;
IR_IP_OV_res_phyId_DPdLen_res = 3;
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaSMPCmd_t, SMPCmd[4]), (pSMPFrame->outFrameAddrLower32));
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaSMPCmd_t, SMPCmd[5]), (pSMPFrame->outFrameAddrUpper32));
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaSMPCmd_t, SMPCmd[6]), (pSMPFrame->outFrameLen));
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaSMPCmd_t, SMPCmd[8]), (pSMPFrame->inFrameAddrLower32));
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaSMPCmd_t, SMPCmd[9]), (pSMPFrame->inFrameAddrUpper32));
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaSMPCmd_t, SMPCmd[10]), (pSMPFrame->inFrameLen));
}
IR_IP_OV_res_phyId_DPdLen_res |= (pSMPFrame->flag & 3);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaSMPCmd_t, IR_IP_OV_res_phyId_DPdLen_res), IR_IP_OV_res_phyId_DPdLen_res);
payload_ptr = (bit8 *)&payload;
#ifdef SA_LL_IBQ_PROTECT
ossaSingleThreadedEnter(agRoot, LL_IOREQ_IBQ0_LOCK + inq);
#endif
ret = mpiSMPCmd(agRoot, pMessage, OPC_INB_SMP_REQUEST, (agsaSMPCmd_t *)payload_ptr, inq, outq);
#ifdef SA_LL_IBQ_PROTECT
ossaSingleThreadedLeave(agRoot, LL_IOREQ_IBQ0_LOCK + inq);
#endif
}
else
{
agsaSMPCmd_V_t vpayload;
bit32 IR_IP_OV_res_phyId_DPdLen_res = 0;
si_memset(&vpayload, 0, sizeof(agsaSMPCmd_V_t));
OSSA_WRITE_LE_32(agRoot, &vpayload, OSSA_OFFSET_OF(agsaSMPCmd_V_t, tag), pRequest->HTag);
OSSA_WRITE_LE_32(agRoot, &vpayload, OSSA_OFFSET_OF(agsaSMPCmd_V_t, deviceId), pDevice->DeviceMapIndex);
OSSA_WRITE_LE_32(agRoot, &vpayload, OSSA_OFFSET_OF(agsaSMPCmd_V_t,SMPHDR ), *((bit32*)pSMPFrame->outFrameBuf+0) );
if (smpFrameFlagIndirectResponse & pSMPFrame->flag && smpFrameFlagIndirectPayload & pSMPFrame->flag)
{
SA_DBG2(("saSMPStart:V Indirect payload and indirect response\n"));
pRequest->IRmode = INDIRECT_MODE;
IR_IP_OV_res_phyId_DPdLen_res = 3;
OSSA_WRITE_LE_32(agRoot, &vpayload, OSSA_OFFSET_OF(agsaSMPCmd_V_t,IndirL_SMPRF15_12 ), (pSMPFrame->outFrameAddrLower32));
OSSA_WRITE_LE_32(agRoot, &vpayload, OSSA_OFFSET_OF(agsaSMPCmd_V_t,IndirH_or_SMPRF19_16 ), (pSMPFrame->outFrameAddrUpper32));
OSSA_WRITE_LE_32(agRoot, &vpayload, OSSA_OFFSET_OF(agsaSMPCmd_V_t,IndirLen_or_SMPRF23_20 ), (pSMPFrame->outFrameLen));
OSSA_WRITE_LE_32(agRoot, &vpayload, OSSA_OFFSET_OF(agsaSMPCmd_V_t,ISRAL_or_SMPRF31_28), (pSMPFrame->inFrameAddrLower32));
OSSA_WRITE_LE_32(agRoot, &vpayload, OSSA_OFFSET_OF(agsaSMPCmd_V_t,ISRAH_or_SMPRF35_32), (pSMPFrame->inFrameAddrUpper32));
OSSA_WRITE_LE_32(agRoot, &vpayload, OSSA_OFFSET_OF(agsaSMPCmd_V_t,ISRL_or_SMPRF39_36), (pSMPFrame->inFrameLen));
}
else if (smpFrameFlagIndirectResponse & pSMPFrame->flag )
{
SA_DBG2(("saSMPStart:V Direct payload and indirect response\n"));
IR_IP_OV_res_phyId_DPdLen_res = (pSMPFrame->outFrameLen << SHIFT16) | pSMPFrame->flag;
OSSA_WRITE_LE_32(agRoot, &vpayload, OSSA_OFFSET_OF(agsaSMPCmd_V_t, IR_IP_OV_res_phyId_DPdLen_res), IR_IP_OV_res_phyId_DPdLen_res);
OSSA_WRITE_LE_32(agRoot, &vpayload, OSSA_OFFSET_OF(agsaSMPCmd_V_t, ISRAL_or_SMPRF31_28 ), (pSMPFrame->inFrameAddrLower32));
OSSA_WRITE_LE_32(agRoot, &vpayload, OSSA_OFFSET_OF(agsaSMPCmd_V_t, ISRAH_or_SMPRF35_32 ), (pSMPFrame->inFrameAddrUpper32));
OSSA_WRITE_LE_32(agRoot, &vpayload, OSSA_OFFSET_OF(agsaSMPCmd_V_t, ISRL_or_SMPRF39_36 ), (pSMPFrame->inFrameLen));
}
IR_IP_OV_res_phyId_DPdLen_res |= (pSMPFrame->flag & 3);
OSSA_WRITE_LE_32(agRoot, &vpayload, OSSA_OFFSET_OF(agsaSMPCmd_V_t, IR_IP_OV_res_phyId_DPdLen_res), IR_IP_OV_res_phyId_DPdLen_res);
#ifdef SA_LL_IBQ_PROTECT
ossaSingleThreadedEnter(agRoot, LL_IOREQ_IBQ0_LOCK + inq);
#endif
payload_ptr = (bit8 *)&vpayload;
ret = mpiSMPCmd(agRoot, pMessage, OPC_INB_SMP_REQUEST, (agsaSMPCmd_t *)payload_ptr, inq, outq);
#ifdef SA_LL_IBQ_PROTECT
ossaSingleThreadedLeave(agRoot, LL_IOREQ_IBQ0_LOCK + inq);
#endif
}
return ret;
}
bit32 saReconfigSASParams(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 queueNum ,
agsaSASReconfig_t *agSASConfig
)
{
bit32 ret = AGSA_RC_SUCCESS;
SA_ASSERT((agNULL != agRoot), "");
if(smIS_SPCV(agRoot))
{
SA_DBG1(("saReconfigSASParams: AGSA_RC_FAILURE for SPCv\n" ));
return(AGSA_RC_FAILURE);
}
ret = mpiSasReinitializeCmd(agRoot, agContext, agSASConfig, queueNum);
return ret;
}
bit32 siGSMDump(
agsaRoot_t *agRoot,
bit32 gsmDumpOffset,
bit32 length,
void *directData)
{
bit8 *dst;
bit32 value, rem, offset = 0;
bit32 i, workOffset, dwLength;
bit32 bar = 0;
SA_DBG1(("siGSMDump: gsmDumpOffset 0x%x length 0x%x\n", gsmDumpOffset, length));
if (length > (64 * 1024))
{
SA_DBG1(("siGSMDump: Max length is greater than 64K bytes 0x%x\n", length));
return AGSA_RC_FAILURE;
}
if (gsmDumpOffset & 3)
{
SA_DBG1(("siGSMDump: Not allow NON_DW Boundary 0x%x\n", gsmDumpOffset));
return AGSA_RC_FAILURE;
}
if ((gsmDumpOffset + length) > ONE_MEGABYTE)
{
SA_DBG1(("siGSMDump: Out of GSM end address boundary 0x%x\n", (gsmDumpOffset+length)));
return AGSA_RC_FAILURE;
}
if( smIS_SPCV(agRoot))
{
bar = PCIBAR1;
}
else if( smIS_SPC(agRoot))
{
bar = PCIBAR2;
}
else
{
SA_DBG1(("siGSMDump: device type is not supported"));
return AGSA_RC_FAILURE;
}
workOffset = gsmDumpOffset & 0xFFFF0000;
offset = gsmDumpOffset & 0x0000FFFF;
gsmDumpOffset = workOffset;
dst = (bit8 *)directData;
rem = length & 3;
dwLength = length >> 2;
for (i =0; i < dwLength; i++)
{
if((workOffset + offset) > length )
{
break;
}
value = ossaHwRegReadExt(agRoot, bar, (workOffset + offset) & 0x0000FFFF);
si_memcpy(dst, &value, 4);
dst += 4;
offset += 4;
}
if (rem != 0)
{
value = ossaHwRegReadExt(agRoot, bar, (workOffset + offset) & 0x0000FFFF);
if(dst)
{
si_memcpy(dst, &value, rem);
}
}
if (AGSA_RC_FAILURE == siBar4Shift(agRoot, 0x0))
{
SA_DBG1(("siGSMDump:Shift Bar4 to 0x%x failed\n", 0x0));
return AGSA_RC_FAILURE;
}
return AGSA_RC_SUCCESS;
}
bit32 saPCIeDiagExecute(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 queueNum,
agsaPCIeDiagExecute_t *diag)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = agNULL;
agsaIORequestDesc_t *pRequest;
bit32 payload[32];
smTraceFuncEnter(hpDBG_VERY_LOUD,"6r");
SA_ASSERT((agNULL != agRoot), "");
saRoot = (agsaLLRoot_t *) (agRoot->sdkData);
SA_ASSERT((agNULL != saRoot), "");
SA_ASSERT((agNULL != diag), "");
if(diag->len == 0)
{
SA_DBG1(("saPCIeDiagExecute, diag->len Zero\n"));
}
SA_DBG1(("saPCIeDiagExecute, diag->command 0x%X\n", diag->command ));
SA_DBG1(("saPCIeDiagExecute, diag->flags 0x%X\n",diag->flags ));
SA_DBG1(("saPCIeDiagExecute, diag->initialIOSeed 0x%X\n", diag->initialIOSeed));
SA_DBG1(("saPCIeDiagExecute, diag->reserved 0x%X\n",diag->reserved ));
SA_DBG1(("saPCIeDiagExecute, diag->rdAddrLower 0x%X\n", diag->rdAddrLower));
SA_DBG1(("saPCIeDiagExecute, diag->rdAddrUpper 0x%X\n", diag->rdAddrUpper ));
SA_DBG1(("saPCIeDiagExecute, diag->wrAddrLower 0x%X\n", diag->wrAddrLower));
SA_DBG1(("saPCIeDiagExecute, diag->wrAddrUpper 0x%X\n",diag->wrAddrUpper ));
SA_DBG1(("saPCIeDiagExecute, diag->len 0x%X\n",diag->len ));
SA_DBG1(("saPCIeDiagExecute, diag->pattern 0x%X\n",diag->pattern ));
SA_DBG1(("saPCIeDiagExecute, %02X %02X %02X %02X %02X %02X\n",
diag->udtArray[0],
diag->udtArray[1],
diag->udtArray[2],
diag->udtArray[3],
diag->udtArray[4],
diag->udtArray[5] ));
SA_DBG1(("saPCIeDiagExecute, %02X %02X %02X %02X %02X %02X\n",
diag->udrtArray[0],
diag->udrtArray[1],
diag->udrtArray[2],
diag->udrtArray[3],
diag->udrtArray[4],
diag->udrtArray[5]));
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest = (agsaIORequestDesc_t *)saLlistIOGetHead(&(saRoot->freeIORequests));
if ( agNULL == pRequest )
{
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_DBG1(("saPCIeDiagExecute, No request from free list\n" ));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "6r");
return AGSA_RC_BUSY;
}
saLlistIORemove(&(saRoot->freeIORequests), &(pRequest->linkNode));
saRoot->IOMap[pRequest->HTag].Tag = pRequest->HTag;
saRoot->IOMap[pRequest->HTag].IORequest = (void *)pRequest;
saRoot->IOMap[pRequest->HTag].agContext = agContext;
pRequest->valid = agTRUE;
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
si_memset(&payload, 0, sizeof(payload));
if(smIS_SPCV(agRoot))
{
bit32 UDTR1_UDT0 ,UDT5_UDT2,UDTR5_UDTR2;
UDTR5_UDTR2 = (( diag->udrtArray[5] << SHIFT24) | (diag->udrtArray[4] << SHIFT16) | (diag->udrtArray[3] << SHIFT8) | diag->udrtArray[2]);
UDT5_UDT2 = (( diag->udtArray[5] << SHIFT24) | (diag->udtArray[4] << SHIFT16) | (diag->udtArray[3] << SHIFT8) | diag->udtArray[2]);
UDTR1_UDT0 = (( diag->udrtArray[1] << SHIFT24) | (diag->udrtArray[0] << SHIFT16) | (diag->udtArray[1] << SHIFT8) | diag->udtArray[0]);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaPCIeDiagExecuteCmd_t, tag) , pRequest->HTag);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaPCIeDiagExecuteCmd_t, CmdTypeDesc), diag->command );
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaPCIeDiagExecuteCmd_t, UUM_EDA) , diag->flags);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaPCIeDiagExecuteCmd_t, UDTR1_UDT0) , UDTR1_UDT0);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaPCIeDiagExecuteCmd_t, UDT5_UDT2) , UDT5_UDT2);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaPCIeDiagExecuteCmd_t, UDTR5_UDTR2), UDTR5_UDTR2);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaPCIeDiagExecuteCmd_t, Res_IOS) , diag->initialIOSeed);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaPCIeDiagExecuteCmd_t, rdAddrLower), diag->rdAddrLower);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaPCIeDiagExecuteCmd_t, rdAddrUpper), diag->rdAddrUpper);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaPCIeDiagExecuteCmd_t, wrAddrLower), diag->wrAddrLower);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaPCIeDiagExecuteCmd_t, wrAddrUpper), diag->wrAddrUpper);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaPCIeDiagExecuteCmd_t, len), diag->len);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaPCIeDiagExecuteCmd_t, pattern), diag->pattern);
ret = mpiBuildCmd(agRoot, (bit32 *)&payload, MPI_CATEGORY_SAS_SATA, OPC_INB_PCIE_DIAG_EXECUTE, IOMB_SIZE128, queueNum);
}
else
{
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsa_SPC_PCIDiagExecuteCmd_t, tag), pRequest->HTag);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsa_SPC_PCIDiagExecuteCmd_t, CmdTypeDesc), diag->command );
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsa_SPC_PCIDiagExecuteCmd_t, rdAddrLower), diag->rdAddrLower);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsa_SPC_PCIDiagExecuteCmd_t, rdAddrUpper), diag->rdAddrUpper);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsa_SPC_PCIDiagExecuteCmd_t, wrAddrLower), diag->wrAddrLower);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsa_SPC_PCIDiagExecuteCmd_t, wrAddrUpper), diag->wrAddrUpper);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsa_SPC_PCIDiagExecuteCmd_t, len), diag->len);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsa_SPC_PCIDiagExecuteCmd_t, pattern), diag->pattern);
ret = mpiBuildCmd(agRoot, (bit32 *)&payload, MPI_CATEGORY_SAS_SATA, OPC_INB_PCIE_DIAG_EXECUTE, IOMB_SIZE64, queueNum);
}
if (AGSA_RC_SUCCESS != ret)
{
saRoot->IOMap[pRequest->HTag].Tag = MARK_OFF;
saRoot->IOMap[pRequest->HTag].IORequest = agNULL;
saRoot->IOMap[pRequest->HTag].agContext = agNULL;
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_DBG1(("saPCIeDiagExecute, sending IOMB failed\n" ));
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "6r");
return ret;
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "6r");
return ret;
}
bit32 saGetDFEData(
agsaRoot_t *agRoot,
agsaContext_t *agContext,
bit32 queueNum,
bit32 interface,
bit32 laneNumber,
bit32 interations,
agsaSgl_t *agSgl)
{
bit32 ret = AGSA_RC_SUCCESS;
agsaLLRoot_t *saRoot = agNULL;
agsaIORequestDesc_t *pRequest = agNULL;
bit32 payload[32];
bit32 reserved_In_Ln;
smTraceFuncEnter(hpDBG_VERY_LOUD,"2X");
SA_ASSERT((agNULL != agRoot), "");
saRoot = (agsaLLRoot_t *) (agRoot->sdkData);
SA_ASSERT((agNULL != saRoot), "");
SA_ASSERT((agNULL != agSgl), "");
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest = (agsaIORequestDesc_t *)saLlistIOGetHead(&(saRoot->freeIORequests));
if ( agNULL == pRequest )
{
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_DBG1(("saGetDFEData, No request from free list\n" ));
smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2X");
return AGSA_RC_BUSY;
}
saLlistIORemove(&(saRoot->freeIORequests), &(pRequest->linkNode));
saRoot->IOMap[pRequest->HTag].Tag = pRequest->HTag;
saRoot->IOMap[pRequest->HTag].IORequest = (void *)pRequest;
saRoot->IOMap[pRequest->HTag].agContext = agContext;
pRequest->valid = agTRUE;
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
si_memset(&payload, 0, sizeof(payload));
if(smIS_SPCV(agRoot))
{
reserved_In_Ln = ((interface & 0x1) << SHIFT7) | (laneNumber & 0x7F);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaGetDDEFDataCmd_t, tag) , pRequest->HTag);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaGetDDEFDataCmd_t, reserved_In_Ln) , reserved_In_Ln);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaGetDDEFDataCmd_t, MCNT) , interations);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaGetDDEFDataCmd_t, Buf_AddrL) , agSgl->sgLower);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaGetDDEFDataCmd_t, Buf_AddrH) , agSgl->sgUpper);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaGetDDEFDataCmd_t, Buf_Len) , agSgl->len);
OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaGetDDEFDataCmd_t, E_reserved) , agSgl->extReserved);
ret = mpiBuildCmd(agRoot, (bit32 *)&payload, MPI_CATEGORY_SAS_SATA, OPC_INB_GET_DFE_DATA, IOMB_SIZE128, queueNum);
}
else
{
ret = AGSA_RC_FAILURE;
}
if (AGSA_RC_SUCCESS != ret)
{
saRoot->IOMap[pRequest->HTag].Tag = MARK_OFF;
saRoot->IOMap[pRequest->HTag].IORequest = agNULL;
saRoot->IOMap[pRequest->HTag].agContext = agNULL;
ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
pRequest->valid = agFALSE;
saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
SA_DBG1(("saPCIeDiagExecute, sending IOMB failed\n" ));
smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "2X");
return ret;
}
smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "2X");
return ret;
}
