void SYSTEM_DEBUG_CLASS::addChipToAttnList(
TARGETING::TargetHandle_t i_chipTgt,
ATTENTION_VALUE_TYPE i_attnType )
{
AttnData l_attnData( i_chipTgt, i_attnType );
g_AttnDataList.insert( std::lower_bound( g_AttnDataList.begin(),
g_AttnDataList.end(), l_attnData ), l_attnData );
}
void SYSTEM_DEBUG_CLASS::initAttnPendingtatus( )
{
for( AttnList::iterator i = g_AttnDataList.begin();
i != g_AttnDataList.end(); ++i )
{
(*i).isAnalysisNotDone = true;
}
}
bool SYSTEM_DEBUG_CLASS::IsAttentionActive( TARGETING::TargetHandle_t i_pChipHandle ) const
{
bool rc = false;
for(AttnList::const_iterator i = g_AttnDataList.begin(); i != g_AttnDataList.end(); ++i)
{
if((*i).targetHndl == i_pChipHandle)
{
rc = true;
break;
}
}
return rc;
}
void SYSTEM_DEBUG_CLASS::SetAttentionType(TARGETING::TargetHandle_t i_pTargetHandle,
ATTENTION_VALUE_TYPE i_eAttnType)
{
if(i_eAttnType > INVALID_ATTENTION_TYPE)
{
if( !isActiveAttentionPending( i_pTargetHandle, i_eAttnType ) )
{
AttnData attnData( i_pTargetHandle, i_eAttnType );
g_AttnDataList.insert( std::lower_bound( g_AttnDataList.begin(),
g_AttnDataList.end(),
attnData ), attnData );
}
}
}
bool findTarget( TARGETING::TargetHandle_t i_chipTgt,
AttnList::iterator & it )
{
bool matchFound = false;
it = std::lower_bound( g_AttnDataList.begin(), g_AttnDataList.end(),
i_chipTgt );
if( it != g_AttnDataList.end() && i_chipTgt == (*it).targetHndl )
{
matchFound = true;
}
return matchFound;
}
uint8_t SYSTEM_DEBUG_CLASS::GetAttentionType(TARGETING::TargetHandle_t i_pChipHandle) const
{
uint8_t type = INVALID_ATTENTION_TYPE;
for(AttnList::const_iterator i = g_AttnDataList.begin(); i != g_AttnDataList.end(); ++i)
{
if((*i).targetHndl == i_pChipHandle)
{
type = (uint8_t) (*i).attnType;
break;
}
}
return (uint8_t) type;
}
TargetHandle_t SYSTEM_DEBUG_CLASS::getTargetWithAttn
( TYPE i_tgtType, ATTENTION_VALUE_TYPE i_attnType) const
{
TargetHandle_t o_tgt = NULL;
for(AttnList::const_iterator i = g_AttnDataList.begin();
i != g_AttnDataList.end(); ++i)
{
if(( getTargetType( (*i).targetHndl ) == i_tgtType)
&& ( (*i).attnType == i_attnType ) )
{
o_tgt = (*i).targetHndl;
break;
}
}
return o_tgt;
}
void SYSTEM_DEBUG_CLASS::CalloutThoseAtAttention(STEP_CODE_DATA_STRUCT & serviceData) const
{
ServiceDataCollector * sdc = serviceData.service_data;
CaptureData & capture = sdc->GetCaptureData();
for(AttnList::const_iterator i = g_AttnDataList.begin(); i != g_AttnDataList.end(); ++i)
{
sdc->SetCallout((*i).targetHndl);
AttnData ad(*i);
BitString cbs(sizeof(AttnData)*8,(CPU_WORD *)&ad);
capture.Add(PlatServices::getSystemTarget(),0,cbs);
}
sdc->SetCallout(NextLevelSupport_ENUM);
}
bool findAttention( TARGETING::TargetHandle_t i_chipTgt,
ATTENTION_VALUE_TYPE i_eAttnType,
AttnList::iterator & it )
{
bool matchFound = false;
AttnData l_attnData( i_chipTgt, i_eAttnType );
it = std::lower_bound( g_AttnDataList.begin(),
g_AttnDataList.end(),
l_attnData );
if( it != g_AttnDataList.end() && *it == l_attnData )
{
matchFound = true;
}
return matchFound;
}
errlHndl_t MemInjectSink::putAttentions(
const AttnList & i_list)
{
errlHndl_t err = 0;
AttnList::const_iterator it = i_list.begin();
while(it != i_list.end())
{
err = putAttention(*it);
if(err)
{
break;
}
++it;
}
return err;
}
uint32_t SYSTEM_DEBUG_CLASS::Reinitialize(const AttnList & i_attnList)
{
using PluginDef::bindParm;
uint32_t l_rc = 0;
do
{
if ( i_attnList.empty() )
{
PRDF_ERR( "SYSTEM_DEBUG_CLASS::Reinitialize() input AttnList is "
"empty" );
/*@
* @errortype
* @subsys EPUB_FIRMWARE_SP
* @reasoncode PRDF_CODE_FAIL
* @moduleid PRDF_SDBUG_INIT
* @userdata1 0
* @userdata2 0
* @userdata3 0
* @userdata4 0
* @devdesc input AttnList is empty.
* @custDesc Chip diagnosis did not find any chip with an
* attention.
* @procedure EPUB_PRC_SP_CODE
*/
PRDF_CREATE_ERRL( g_prd_errlHndl,
ERRL_SEV_UNRECOVERABLE, // error on diagnostic
ERRL_ETYPE_NOT_APPLICABLE,
SRCI_MACH_CHECK,
SRCI_NO_ATTR,
PRDF_SDBUG_INIT, // module id
FSP_DEFAULT_REFCODE,
PRDF_CODE_FAIL, // Reason code
0, // user data word 1
0, // user data word 2
0, // user data word 3
0 ); // user data word 4
PRDF_ADD_PROCEDURE_CALLOUT( g_prd_errlHndl, SRCI_PRIORITY_MED,
EPUB_PRC_SP_CODE );
l_rc = PRD_ATTN_DATA_ACCESS_FAILED;
break;
}
Clear();
for( AttnList::const_iterator i = i_attnList.begin();
i != i_attnList.end(); ++i )
{
addChipToAttnList( (*i).targetHndl,(*i).attnType );
// There can be a case where chip has both recoverable and Check
// Stop. In that case chip shall report only Check Stop. In such a
// case, we analyse the recoverable first and see if we can blame
// check stop on recoverable. To ease its handling, let us add a
// chip reporting recoverable attention to attention list.
if( ((*i).attnType == CHECK_STOP ) || ((*i).attnType == UNIT_CS ) )
{
bool l_recovFound = false;
ExtensibleChip * l_chip =
( ExtensibleChip *) systemPtr->GetChip( (*i).targetHndl );
ExtensibleChipFunction * ef
= l_chip->getExtensibleFunction("CheckForRecovered");
(*ef)( l_chip, bindParm<bool &>( l_recovFound ) );
if ( l_recovFound )
{
addChipToAttnList( (*i).targetHndl,RECOVERABLE );
}
}
}
g_init_done = true;
} while(0);
return l_rc;
}