// Notify HTMGT that an OCC has failed and needs to be reset
void processOccReset(TARGETING::Target * i_proc)
{
TMGT_INF(">>processOccReset(0x%p)", i_proc);
errlHndl_t errl = NULL;
TARGETING::Target * failedOccTarget = NULL;
TARGETING::Target* sys = NULL;
TARGETING::targetService().getTopLevelTarget(sys);
uint8_t safeMode = 0;
// If the system is in safemode then ignore request to reset OCCs
if(sys &&
sys->tryGetAttr<TARGETING::ATTR_HTMGT_SAFEMODE>(safeMode) &&
safeMode)
{
return;
}
// Get functional OCC (one per proc)
TARGETING::TargetHandleList pOccs;
getChildChiplets(pOccs, i_proc, TARGETING::TYPE_OCC);
if (pOccs.size() > 0)
{
failedOccTarget = pOccs[0];
}
if(NULL != failedOccTarget)
{
uint32_t huid = failedOccTarget->getAttr<TARGETING::ATTR_HUID>();
TMGT_INF("processOccReset(HUID=0x%08X) called", huid);
}
else
{
uint32_t huid = i_proc->getAttr<TARGETING::ATTR_HUID>();
TMGT_INF("processOccReset: Invalid OCC target (proc huid=0x08X)"
"resetting OCCs anyway",
huid);
/*@
* @errortype
* @reasoncode HTMGT_RC_INVALID_PARAMETER
* @moduleid HTMGT_MOD_PROCESS_OCC_RESET
* @userdata1[0:7] Processor HUID
* @devdesc No OCC target found for proc Target,
*/
bldErrLog(errl,
HTMGT_MOD_PROCESS_OCC_RESET,
HTMGT_RC_INVALID_PARAMETER,
huid, 0, 0, 1,
ERRORLOG::ERRL_SEV_INFORMATIONAL);
// Add HB firmware callout
errl->addProcedureCallout(HWAS::EPUB_PRC_HB_CODE,
HWAS::SRCI_PRIORITY_MED);
ERRORLOG::errlCommit(errl, HTMGT_COMP_ID); // sets errl to NULL
}
errl = OccManager::resetOccs(failedOccTarget);
if(errl)
{
ERRORLOG::errlCommit(errl, HTMGT_COMP_ID); // sets errl to NULL
}
TMGT_INF("<<processOccReset()");
} // end processOccReset()
void TargetServiceImpl::getMcsList(
TargetHandle_t i_proc,
TargetHandleList & o_list)
{
getChildChiplets(o_list, i_proc, TYPE_MCS);
}
// Notify HTMGT that an OCC has an error to report
void processOccError(TARGETING::Target * i_procTarget)
{
TMGT_INF(">>processOccError(0x%p)", i_procTarget);
TARGETING::Target* sys = NULL;
TARGETING::targetService().getTopLevelTarget(sys);
uint8_t safeMode = 0;
// If the system is in safemode then can't talk to OCCs -
// ignore call to processOccError
if(sys &&
sys->tryGetAttr<TARGETING::ATTR_HTMGT_SAFEMODE>(safeMode) &&
safeMode)
{
return;
}
bool polledOneOcc = false;
errlHndl_t err = OccManager::buildOccs();
if (NULL == err)
{
if (i_procTarget != NULL)
{
const uint32_t l_huid =
i_procTarget->getAttr<TARGETING::ATTR_HUID>();
TMGT_INF("processOccError(HUID=0x%08X) called", l_huid);
TARGETING::TargetHandleList pOccs;
getChildChiplets(pOccs, i_procTarget, TARGETING::TYPE_OCC);
if (pOccs.size() > 0)
{
// Poll specified OCC flushing any errors
errlHndl_t err = OccManager::sendOccPoll(true, pOccs[0]);
if (err)
{
ERRORLOG::errlCommit(err, HTMGT_COMP_ID);
}
polledOneOcc = true;
}
}
if ((OccManager::getNumOccs() > 1) || (false == polledOneOcc))
{
// Send POLL command to all OCCs to flush any other errors
errlHndl_t err = OccManager::sendOccPoll(true);
if (err)
{
ERRORLOG::errlCommit(err, HTMGT_COMP_ID);
}
}
if (OccManager::occNeedsReset())
{
TMGT_ERR("processOccError(): OCCs need to be reset");
// Don't pass failed target as OCC should have already
// been marked as failed during the poll.
errlHndl_t err = OccManager::resetOccs(NULL);
if(err)
{
ERRORLOG::errlCommit(err, HTMGT_COMP_ID);
}
}
}
else
{
// OCC build failed...
TMGT_ERR("processOccError() called, but unable to find OCCs");
ERRORLOG::errlCommit(err, HTMGT_COMP_ID);
}
TMGT_INF("<<processOccError()");
} // end processOccError()
/**
* @brief Stops OCCs on all Processors in the node
*/
errlHndl_t stopAllOCCs()
{
TRACFCOMP( g_fapiTd,ENTER_MRK"stopAllOCCs" );
errlHndl_t l_errl = NULL;
bool winkle_loaded = false;
do {
#ifndef __HOSTBOOT_RUNTIME
//OCC requires the build_winkle_images library
if ( !VFS::module_is_loaded( "libbuild_winkle_images.so" ) )
{
l_errl = VFS::module_load( "libbuild_winkle_images.so" );
if ( l_errl )
{
// load module returned with errl set
TRACFCOMP( g_fapiTd,ERR_MRK"loadnStartAllOccs: Could not load build_winkle module" );
// break from do loop if error occured
break;
}
winkle_loaded = true;
}
#endif
TargetHandleList procChips;
getAllChips(procChips, TYPE_PROC, true);
if(procChips.size() == 0)
{
TRACFCOMP( g_fapiTd,INFO_MRK"loadnStartAllOccs: No processors found" );
//We'll never get this far in the IPL without any processors,
// so just exit.
break;
}
TRACFCOMP( g_fapiTd,
INFO_MRK"loadnStartAllOccs: %d procs found",
procChips.size());
//The OCC Procedures require processors within a DCM be
//setup together. If DCM installed is set, we work under
//the assumption that each nodeID is a DCM. So sort the
//list by NodeID then call OCC Procedures on NodeID pairs.
std::sort(procChips.begin(),
procChips.end(),
orderByNodeAndPosition);
//The OCC master for the node must be reset last. For all
//OP systems there is only a single OCC that can be the
//master so it is safe to look at the MASTER_CAPABLE flag.
Target* masterProc0 = NULL;
Target* masterProc1 = NULL;
TargetHandleList::iterator itr1 = procChips.begin();
if(0 == (*itr1)->getAttr<ATTR_PROC_DCM_INSTALLED>())
{
TRACUCOMP( g_fapiTd,
INFO_MRK"stopAllOCCs: non-dcm path entered");
for (TargetHandleList::iterator itr = procChips.begin();
itr != procChips.end();
++itr)
{
TargetHandleList pOccs;
getChildChiplets(pOccs, *itr, TYPE_OCC);
if (pOccs.size() > 0)
{
if( pOccs[0]->getAttr<ATTR_OCC_MASTER_CAPABLE>() )
{
masterProc0 = *itr;
continue;
}
}
l_errl = HBOCC::stopOCC( *itr, NULL );
if (l_errl)
{
TRACFCOMP( g_fapiImpTd, ERR_MRK"stopAllOCCs: stop failed");
errlCommit (l_errl, HWPF_COMP_ID);
// just commit and try the next chip
}
}
if (l_errl)
{
break;
}
}
else
{
TRACFCOMP( g_fapiTd,
INFO_MRK"stopAllOCCs: Following DCM Path");
for (TargetHandleList::iterator itr = procChips.begin();
itr != procChips.end();
++itr)
{
Target* targ0 = *itr;
Target* targ1 = NULL;
TRACFCOMP( g_fapiImpTd, INFO_MRK"stopAllOCCs: Cur target nodeID=%d",
targ0->getAttr<ATTR_FABRIC_NODE_ID>());
//if the next target in the list is in the same node
// they are on the same DCM, so bump itr forward
// and update targ0 pointer
if((itr+1) != procChips.end())
{
TRACFCOMP( g_fapiImpTd, INFO_MRK"stopAllOCCs: n+1 target nodeID=%d", ((*(itr+1))->getAttr<ATTR_FABRIC_NODE_ID>()));
if((targ0->getAttr<ATTR_FABRIC_NODE_ID>()) ==
((*(itr+1))->getAttr<ATTR_FABRIC_NODE_ID>()))
{
//need to flip the numbers because we were reversed
targ1 = targ0;
itr++;
targ0 = *itr;
}
}
TargetHandleList pOccs;
getChildChiplets(pOccs, targ0, TYPE_OCC);
if (pOccs.size() > 0)
{
if( pOccs[0]->getAttr<ATTR_OCC_MASTER_CAPABLE>() )
{
masterProc0 = targ0;
masterProc1 = targ1;
continue;
}
}
l_errl = HBOCC::stopOCC( targ0, targ1 );
if (l_errl)
{
TRACFCOMP( g_fapiImpTd, ERR_MRK"stopAllOCCs: stop failed");
errlCommit (l_errl, HWPF_COMP_ID);
// just commit and try the next module
}
}
if (l_errl)
{
break;
}
}
//now do the master OCC
if( masterProc0 )
{
l_errl = HBOCC::stopOCC( masterProc0, masterProc1 );
if (l_errl)
{
TRACFCOMP( g_fapiImpTd, ERR_MRK"stopAllOCCs: stop failed on master");
break;
}
}
} while(0);
//make sure we always unload the module if we loaded it
if (winkle_loaded)
{
#ifndef __HOSTBOOT_RUNTIME
errlHndl_t l_tmpErrl =
VFS::module_unload( "libbuild_winkle_images.so" );
if ( l_tmpErrl )
{
TRACFCOMP( g_fapiTd,ERR_MRK"stopAllOCCs: Error unloading build_winkle module" );
if(l_errl)
{
errlCommit( l_tmpErrl, HWPF_COMP_ID );
}
else
{
l_errl = l_tmpErrl;
}
}
#endif
}
TRACFCOMP( g_fapiTd,EXIT_MRK"stopAllOCCs" );
return l_errl;
}
