//******************************************************************************
// fapiPutScom function
//******************************************************************************
fapi::ReturnCode fapiPutScom(const fapi::Target& i_target,
const uint64_t i_address,
ecmdDataBufferBase & i_data)
{
fapi::ReturnCode l_rc;
bool l_traceit = platIsScanTraceEnabled();
// call the platform implementation
l_rc = platPutScom( i_target, i_address, i_data );
if (l_rc)
{
FAPI_ERR("fapiPutScom failed - Target %s, Addr %.16llX",
i_target.toEcmdString(), i_address);
}
if( l_traceit )
{
FAPI_SCAN( "TRACE : PUTSCOM : %s : %.16llX %.16llX",
i_target.toEcmdString(),
i_address,
i_data.getDoubleWord( 0 ) );
}
return l_rc;
}
fapi::ReturnCode _fapiPutSpyImage(const fapi::Target& i_target,
const spyId_t i_spyId,
const ecmdDataBufferBase & i_data,
ecmdDataBufferBase & io_imageData)
{
fapi::ReturnCode l_rc;
bool l_traceit = platIsScanTraceEnabled();
// call the platform implementation
l_rc = platPutSpyImage( i_target, i_spyId, i_data, io_imageData );
if (l_rc)
{
FAPI_ERR("fapiPutSpyImage failed - Target %s, SpyId 0x%.16llX",
i_target.toEcmdString(), i_spyId);
}
if( l_traceit )
{
FAPI_SCAN( "TRACE : PUTSPYIMG : %s : %.16llX %.16llX",
i_target.toEcmdString(),
i_spyId,
i_data.getDoubleWord(0));
}
return l_rc;
}
fapi::ReturnCode _fapiGetSpyImage(const fapi::Target& i_target,
const char * const i_spyId,
ecmdDataBufferBase & o_data,
const ecmdDataBufferBase & i_imageData)
{
fapi::ReturnCode l_rc;
bool l_traceit = platIsScanTraceEnabled();
// call the platform implementation
l_rc = platGetSpyImage( i_target, i_spyId, o_data, i_imageData );
if (l_rc)
{
FAPI_ERR("fapiGetSpyImage failed - Target %s, SpyId %s",
i_target.toEcmdString(), i_spyId);
}
if( l_traceit )
{
FAPI_SCAN( "TRACE : GETSPYIMAGE : %s : %s %.16llX",
i_target.toEcmdString(),
i_spyId,
o_data.getDoubleWord(0));
}
return l_rc;
}
fapi::ReturnCode fapiGetRing(const fapi::Target& i_target,
const scanRingId_t i_address,
ecmdDataBufferBase & o_data,
const uint32_t i_ringMode)
{
fapi::ReturnCode l_rc;
bool l_traceit = platIsScanTraceEnabled();
// call the platform implementation
l_rc = platGetRing( i_target, i_address, o_data, i_ringMode );
if (l_rc)
{
FAPI_ERR("fapiGetRing failed - Target %s, Addr 0x%.16llX",
i_target.toEcmdString(), i_address);
}
if( l_traceit )
{
FAPI_SCAN( "TRACE : GETRING : %s : %.16llX %.16llX",
i_target.toEcmdString(),
i_address,
o_data.getDoubleWord( 0 ) );
}
return l_rc;
}
//******************************************************************************
// fapiPutCfamRegister function
//******************************************************************************
fapi::ReturnCode fapiPutCfamRegister(const fapi::Target& i_target,
const uint32_t i_address,
ecmdDataBufferBase & i_data)
{
fapi::ReturnCode l_rc;
bool l_traceit = platIsScanTraceEnabled();
// call the platform implementation
l_rc = platPutCfamRegister( i_target, i_address, i_data );
if (l_rc)
{
FAPI_ERR("platPutCfamRegister failed - Target %s, Addr %.8X",
i_target.toEcmdString(), i_address);
}
if( l_traceit )
{
FAPI_SCAN( "TRACE : PUTCFAMREG : %s : %.8X %.8X",
i_target.toEcmdString(),
i_address,
i_data.getWord(0) );
}
return l_rc;
}
/// @brief passing a 'Put Ring from Image' message to SBE with RingId_t
ReturnCode platPutRing(const Target<TARGET_TYPE_ALL>& i_target,
const RingId_t i_ringID,
const RingMode i_ringMode = RING_MODE_HEADER_CHECK)
{
FAPI_DBG("Entering: platPutRing() with RingId_t");
ReturnCode l_rc = FAPI2_RC_SUCCESS;
errlHndl_t l_err = NULL;
// Note: Trace is placed here in plat code because PPE doesn't support
// trace in common fapi2_hw_access.H
bool l_traceit = platIsScanTraceEnabled();
//convert const RingId_t to RingId_t
RingId_t l_ringID = reinterpret_cast<RingId_t>(i_ringID);
// Extract the component pointer
TARGETING::Target* l_target =
reinterpret_cast<TARGETING::Target*>(i_target.get());
// Grab the name of the target
TARGETING::ATTR_FAPI_NAME_type l_targName = {0};
fapi2::toString(i_target, l_targName, sizeof(l_targName));
uint64_t l_flag = platGetDDScanMode(i_ringMode);
size_t l_size = (size_t) 0;
FAPI_DBG("platPutRing l_target : %.16llX i_targetType %.16llX",
l_target,
l_target->getAttr<TARGETING::ATTR_TYPE>());
FAPI_DBG("platPutRing l_RingID :"
" %.16llX i_ringMode %.16llX l_flag %.16llX",
static_cast<uint64_t>(l_ringID), i_ringMode, l_flag );
l_err = deviceWrite(l_target,
nullptr,
l_size,
DEVICE_SCAN_SBE_ADDRESS(l_ringID,i_ringMode,l_flag));
if(l_err)
{
FAPI_ERR("platPutRing: deviceWrite returns error!");
// Add the error log pointer as data to the ReturnCode
l_rc.setPlatDataPtr(reinterpret_cast<void *> (l_err));
}
if (l_traceit)
{
FAPI_SCAN("TRACE : PUTRING w RingId_t : %s : %.16llX",
l_targName,
static_cast<uint64_t>(l_ringID));
}
FAPI_DBG(EXIT_MRK "platPutRing() with RingId_t");
return l_rc;
}
// This will be used in future Cumulus code
/// @brief Platform-level implementation called by putRing()
inline ReturnCode platPutRing(const Target<TARGET_TYPE_ALL>& i_target,
const scanRingId_t i_address,
variable_buffer& i_data,
const RingMode i_ringMode)
{
FAPI_DBG(ENTER_MRK "platPutRing");
ReturnCode l_rc;
errlHndl_t l_err = NULL;
// Note: Trace is placed here in plat code because PPE doesn't support
// trace in common fapi2_hw_access.H
bool l_traceit = platIsScanTraceEnabled();
// Extract the component pointer
TARGETING::Target* l_target =
reinterpret_cast<TARGETING::Target*>(i_target.get());
// Grab the name of the target
TARGETING::ATTR_FAPI_NAME_type l_targName = {0};
fapi2::toString(i_target, l_targName, sizeof(l_targName));
// Output buffer must be set to ring's len by user
uint64_t l_ringLen = i_data.getBitLength();
uint64_t l_flag = platGetDDScanMode(i_ringMode);
size_t l_size = i_data.getLength<uint8_t>();
l_err = deviceWrite(l_target,
i_data.pointer(),
l_size,
DEVICE_SCAN_ADDRESS(i_address, l_ringLen, l_flag));
if (l_err)
{
FAPI_ERR("platPutRing: deviceRead returns error!");
FAPI_ERR("fapiPutRing failed - Target %s, Addr %.16llX",
l_targName, i_address);
// Add the error log pointer as data to the ReturnCode
l_rc.setPlatDataPtr(reinterpret_cast<void *> (l_err));
}
if (l_traceit)
{
uint64_t l_data = i_data.get<uint64_t>();
FAPI_SCAN("TRACE : PUTRING : %s : %.16llX %.16llX",
l_targName,
i_address,
l_data);
}
FAPI_DBG(EXIT_MRK "platPutRing");
return l_rc;
}
fapi::ReturnCode fapiModifyRing(const fapi::Target& i_target,
const scanRingId_t i_address,
ecmdDataBufferBase & i_data,
const fapi::ChipOpModifyMode i_modifyMode,
const uint32_t i_ringMode)
{
fapi::ReturnCode l_rc;
bool l_traceit = platIsScanTraceEnabled();
// call the platform implementation
l_rc = platModifyRing( i_target, i_address, i_data, i_modifyMode, i_ringMode );
if (l_rc)
{
FAPI_ERR("platModifyRing failed - Target %s, Addr 0x%.16llX,"
"ModifyMode 0x%.8X", i_target.toEcmdString(),
i_address, i_modifyMode);
}
if( l_traceit )
{
// get string representation of the modify mode
const char * l_pMode = NULL;
if (i_modifyMode == fapi::CHIP_OP_MODIFY_MODE_OR)
{
l_pMode = "OR";
}
else if (i_modifyMode == fapi::CHIP_OP_MODIFY_MODE_AND)
{
l_pMode = "AND";
}
else if (i_modifyMode == fapi::CHIP_OP_MODIFY_MODE_XOR)
{
l_pMode = "XOR";
}
else
{
l_pMode = "?";
}
FAPI_SCAN( "TRACE : MODRING : %s : %.16llX %.16llX %s",
i_target.toEcmdString(),
i_address,
i_data.getDoubleWord(0),
l_pMode);
}
return l_rc;
}
/// @brief Platform-level implementation called by modifyRing()
ReturnCode platModifyRing(const Target<TARGET_TYPE_ALL>& i_target,
const scanRingId_t i_address,
const variable_buffer& i_data,
const ChipOpModifyMode i_modifyMode,
const RingMode i_ringMode)
{
FAPI_DBG(ENTER_MRK "platModifyRing");
// TODO RTC:152489 - story to finish this modifyRing
FAPI_ERR("platModifyRing: not supported yet");
assert(0,"platModifyRing not supported yet.");
ReturnCode l_rc;
errlHndl_t l_err = NULL;
variable_buffer l_current_data(i_data);
// Note: Trace is placed here in plat code because PPE doesn't support
// trace in common fapi2_hw_access.H
bool l_traceit = platIsScanTraceEnabled();
// Grab the name of the target
TARGETING::ATTR_FAPI_NAME_type l_targName = {0};
fapi2::toString(i_target, l_targName, sizeof(l_targName));
do
{
// Extract the component pointer
TARGETING::Target* l_target =
reinterpret_cast<TARGETING::Target*>(i_target.get());
// --------------------
// Read current value
// --------------------
uint64_t l_ringLen = l_current_data.getBitLength();
uint64_t l_flag = platGetDDScanMode(i_ringMode);
size_t l_size = l_current_data.getLength<uint8_t>();
l_err = deviceRead(l_target,
l_current_data.pointer(),
l_size,
DEVICE_SCAN_ADDRESS(i_address, l_ringLen, l_flag));
if (l_err)
{
FAPI_ERR("platModifyRing: deviceRead returns error!");
FAPI_ERR("platModifyRing failed - Target %s, Addr %.16llX",
l_targName, i_address);
// Add the error log pointer as data to the ReturnCode
l_rc.setPlatDataPtr(reinterpret_cast<void *> (l_err));
// break out if read fails
break;
}
// ----------------------
// Applying modification
// ----------------------
/* TODO-RTC:151261 - re-enable when variable_buffer operations supported
if (fapi2::CHIP_OP_MODIFY_MODE_OR == i_modifyMode)
{
l_current_data |= i_data;
}
else if (fapi2::CHIP_OP_MODIFY_MODE_AND == i_modifyMode)
{
l_current_data &= i_data;
}
else
{
l_current_data ^= i_data;
} */
// -------------------------
// Write back updated data
// -------------------------
l_err = deviceWrite(l_target,
l_current_data.pointer(),
l_size,
DEVICE_SCAN_ADDRESS(i_address, l_ringLen, l_flag));
if (l_err)
{
FAPI_ERR("platModifyRing: deviceWrite returns error!");
FAPI_ERR("platModifyRing failed - Target %s, Addr %.16llX",
l_targName, i_address);
// Add the error log pointer as data to the ReturnCode
l_rc.setPlatDataPtr(reinterpret_cast<void *> (l_err));
break;
}
} while (0);
if (l_traceit)
{
uint64_t l_data = l_current_data.get<uint64_t>();
FAPI_SCAN("TRACE : MODIFYRING : %s : %.16llX %.16llX",
l_targName,
i_address,
l_data);
}
FAPI_DBG(EXIT_MRK "platModifyRing");
return l_rc;
}
/// @brief Platform-level implementation called by getScom()
ReturnCode platGetScom(const Target<TARGET_TYPE_ALL>& i_target,
const uint64_t i_address,
buffer<uint64_t>& o_data)
{
ReturnCode l_rc;
errlHndl_t l_err = NULL;
FAPI_DBG(ENTER_MRK "platGetScom");
// Note: Trace is placed here in plat code because PPE doesn't support
// trace in common fapi2_hw_access.H
bool l_traceit = platIsScanTraceEnabled();
// Extract the component pointer
TARGETING::Target* l_target =
reinterpret_cast<TARGETING::Target*>(i_target.get());
// Grab the name of the target
TARGETING::ATTR_FAPI_NAME_type l_targName = {0};
fapi2::toString(i_target, l_targName, sizeof(l_targName));
// Perform SCOM read
size_t l_size = sizeof(uint64_t);
l_err = deviceRead(l_target,
&o_data(),
l_size,
DEVICE_SCOM_ADDRESS(i_address, opMode));
//If an error occured durring the device read and a pib_err_mask is set,
// then we will check if the err matches the mask, if it does we
// ignore the error
if(l_err && (pib_err_mask != 0x00))
{
checkPibMask(l_err);
}
if (l_err)
{
if(opMode & fapi2::IGNORE_HW_ERROR)
{
delete l_err;
l_err = nullptr;
}
else
{
FAPI_ERR("platGetScom: deviceRead returns error!");
FAPI_ERR("fapiGetScom failed - Target %s, Addr %.16llX",
l_targName, i_address);
l_rc.setPlatDataPtr(reinterpret_cast<void *> (l_err));
}
}
if (l_traceit)
{
uint64_t l_data = (uint64_t)o_data;
FAPI_SCAN("TRACE : GETSCOM : %s : %.16llX %.16llX",
l_targName,
i_address,
l_data);
}
FAPI_DBG(EXIT_MRK "platGetScom");
return l_rc;
}
/// @brief Platform-level implementation of modifyCfamRegister()
ReturnCode platModifyCfamRegister(const Target<TARGET_TYPE_ALL>& i_target,
const uint32_t i_address,
const buffer<uint32_t> i_data,
const ChipOpModifyMode i_modifyMode)
{
FAPI_DBG(ENTER_MRK "platModifyCfamRegister");
ReturnCode l_rc;
errlHndl_t l_err = NULL;
bool l_traceit = platIsScanTraceEnabled();
const char* l_modeString = platModeString(i_modifyMode);
// Grab the name of the target
TARGETING::ATTR_FAPI_NAME_type l_targName = {0};
fapi2::toString(i_target, l_targName, sizeof(l_targName));
do
{
// Can't access cfam engine on master processor
l_err = verifyCfamAccessTarget(i_target,i_address);
if (l_err)
{
FAPI_ERR("platModifyCfamRegister: verifyCfamAccessTarget returns error!");
l_rc.setPlatDataPtr(reinterpret_cast<void *> (l_err));
break;
}
// Extract the component pointer
TARGETING::Target* l_target =
reinterpret_cast<TARGETING::Target*>(i_target.get());
// Get the chip target if l_target is not a chip
TARGETING::Target* l_myChipTarget = NULL;
l_err = getCfamChipTarget(l_target, l_myChipTarget);
if (l_err)
{
FAPI_ERR("platModifyCfamRegister: getCfamChipTarget returns error!");
l_rc.setPlatDataPtr(reinterpret_cast<void *> (l_err));
break;
}
// Read current value
// Address needs to be multiply by 4 because register addresses are word
// offsets but the FSI addresses are byte offsets.
// However, we need to preserve the engine's offset of 0x0C00 and 0x1000
uint64_t l_addr = ((i_address & CFAM_ADDRESS_MASK) << 2) |
(i_address & CFAM_ENGINE_OFFSET);
buffer<uint32_t> l_data = 0;
size_t l_size = sizeof(uint32_t);
l_err = deviceRead(l_myChipTarget,
&l_data(),
l_size,
DEVICE_FSI_ADDRESS(l_addr));
if (l_err)
{
FAPI_ERR("platModifyCfamRegister: deviceRead returns error!");
l_rc.setPlatDataPtr(reinterpret_cast<void *> (l_err));
break;
}
// Applying modification
platProcess32BitModifyMode(i_modifyMode, i_data, l_data);
// Write back
l_err = deviceWrite(l_target,
&l_data(),
l_size,
DEVICE_FSI_ADDRESS(l_addr));
if (l_err)
{
FAPI_ERR("platModifyCfamRegister: deviceWrite returns error!");
l_rc.setPlatDataPtr(reinterpret_cast<void *> (l_err));
break;
}
} while (0);
if (l_rc != fapi2::FAPI2_RC_SUCCESS)
{
FAPI_ERR("platModifyCfamRegister failed - Target %s, Addr %.8X",
l_targName, i_address);
}
if( l_traceit )
{
uint32_t l_data = (uint32_t)i_data;
FAPI_SCAN( "TRACE : MODCFAMREG : %s : %.8X %.8X %s",
l_targName,
i_address,
l_data,
l_modeString );
}
FAPI_DBG(EXIT_MRK "platModifyCfamRegister");
return l_rc;
}
/// @brief Platform-level implementation called by getCfamRegister()
ReturnCode platGetCfamRegister(const Target<TARGET_TYPE_ALL>& i_target,
const uint32_t i_address,
buffer<uint32_t>& o_data)
{
FAPI_DBG(ENTER_MRK "platGetCfamRegister");
ReturnCode l_rc;
errlHndl_t l_err = NULL;
bool l_traceit = platIsScanTraceEnabled();
// Grab the name of the target
TARGETING::ATTR_FAPI_NAME_type l_targName = {0};
fapi2::toString(i_target, l_targName, sizeof(l_targName));
do
{
// Extract the target pointer
TARGETING::Target* l_target =
reinterpret_cast<TARGETING::Target*>(i_target.get());
// Get the chip target if l_target is not a chip
TARGETING::Target* l_myChipTarget = NULL;
l_err = getCfamChipTarget(l_target, l_myChipTarget);
if (l_err)
{
FAPI_ERR("platGetCfamRegister: getCfamChipTarget returns error!");
FAPI_ERR("fapiGetCfamRegister failed - Target %s, Addr %.8X",
l_targName, i_address);
l_rc.setPlatDataPtr(reinterpret_cast<void *> (l_err));
break;
}
// Can't access cfam engine on master processor
l_err = verifyCfamAccessTarget(i_target,i_address);
if (l_err)
{
FAPI_ERR("platGetCfamRegister: verifyCfamAccessTarget returns error!");
l_rc.setPlatDataPtr(reinterpret_cast<void *> (l_err));
break;
}
// Perform CFAM read via FSI
// Address needs to be multiply by 4 because register addresses are
// word offsets but the FSI addresses are byte offsets.
// However, we need to preserve the engine's offset in the top byte
uint64_t l_addr = ((i_address & CFAM_ADDRESS_MASK) << 2) |
(i_address & CFAM_ENGINE_OFFSET);
size_t l_size = sizeof(uint32_t);
l_err = deviceRead(l_myChipTarget,
&o_data(),
l_size,
DEVICE_FSI_ADDRESS(l_addr));
if (l_err)
{
FAPI_ERR("platGetCfamRegister: deviceRead returns error!");
l_rc.setPlatDataPtr(reinterpret_cast<void *> (l_err));
break;
}
} while(0);
if (l_rc != fapi2::FAPI2_RC_SUCCESS)
{
FAPI_ERR("fapiGetCfamRegister failed - Target %s, Addr %.8X",
l_targName, i_address);
}
if( l_traceit )
{
uint32_t l_data = (uint32_t)o_data;
FAPI_SCAN( "TRACE : GETCFAMREG : %s : %.8X %.8X",
l_targName,
i_address,
l_data);
}
FAPI_DBG(EXIT_MRK "platGetCfamRegister");
return l_rc;
}
/// @brief Platform-level implementation called by putScomUnderMask()
ReturnCode platPutScomUnderMask(const Target<TARGET_TYPE_ALL>& i_target,
const uint64_t i_address,
const buffer<uint64_t> i_data,
const buffer<uint64_t> i_mask)
{
ReturnCode l_rc;
errlHndl_t l_err = NULL;
FAPI_DBG(ENTER_MRK "platPutScomUnderMask");
// Note: Trace is placed here in plat code because PPE doesn't support
// trace in common fapi2_hw_access.H
bool l_traceit = platIsScanTraceEnabled();
// Grab the name of the target
TARGETING::ATTR_FAPI_NAME_type l_targName = {0};
fapi2::toString(i_target, l_targName, sizeof(l_targName));
do
{
// Extract the component pointer
TARGETING::Target* l_target =
reinterpret_cast<TARGETING::Target*>(i_target.get());
// Get current value from HW
uint64_t l_data = 0;
size_t l_size = sizeof(uint64_t);
l_err = deviceRead(l_target,
&l_data,
l_size,
DEVICE_SCOM_ADDRESS(i_address,opMode));
if (l_err && !(opMode & fapi2::IGNORE_HW_ERROR))
{
FAPI_ERR("platPutScomUnderMask: deviceRead returns error!");
l_rc.setPlatDataPtr(reinterpret_cast<void *> (l_err));
break;
}
else if(l_err)
{
delete l_err;
l_err = nullptr;
break;
}
// Calculate new value to write to reg
uint64_t l_inMaskInverted = ~i_mask; // Write mask inverted
uint64_t l_newMask = (i_data & i_mask); // Retain set data bits
// l_data = current data set bits
l_data &= l_inMaskInverted;
// l_data = current data set bit + set mask bits
l_data |= l_newMask;
// Write new value
l_err = deviceWrite(l_target,
&l_data,
l_size,
DEVICE_SCOM_ADDRESS(i_address,opMode));
if (l_err && !(opMode & fapi2::IGNORE_HW_ERROR))
{
FAPI_ERR("platPutScomUnderMask: deviceWrite returns error!");
l_rc.setPlatDataPtr(reinterpret_cast<void *> (l_err));
break;
}
else if (l_err)
{
delete l_err;
l_err = nullptr;
break;
}
} while (0);
if(l_err && (pib_err_mask != 0x00))
{
checkPibMask(l_err);
}
if (l_rc != fapi2::FAPI2_RC_SUCCESS)
{
FAPI_ERR("platPutScomUnderMask failed - Target %s, Addr %.16llX",
l_targName, i_address);
}
if( l_traceit )
{
uint64_t l_data = i_data;
uint64_t l_mask = i_mask;
FAPI_SCAN( "TRACE : PUTSCOMMASK : %s : %.16llX %.16llX %.16llX",
l_targName,
i_address,
l_data,
l_mask);
}
FAPI_DBG(EXIT_MRK "platPutScomUnderMask");
return l_rc;
}
