From 274a64b5cb71867019f4cecf47cfc0e12262238e Mon Sep 17 00:00:00 2001 From: Dan Crowell Date: Wed, 14 Jun 2017 12:21:25 -0500 Subject: [PATCH] Fix fapi getChildren for DIMMs Found a swapped template parameter that made a check bad Cleaned up some variable names to prevent similar errors Change-Id: Ie86184a8d8842bfd42c9d022d05ed874f5c0ceda Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/41838 Tested-by: Jenkins Server Tested-by: Jenkins OP Build CI Tested-by: FSP CI Jenkins Reviewed-by: Martin Gloff Reviewed-by: Christian R. Geddes Reviewed-by: Daniel M. Crowell --- src/include/usr/fapi2/target.H | 337 +++++++++++++++++---------------- src/usr/fapi2/plat_utils.C | 2 +- 2 files changed, 170 insertions(+), 169 deletions(-) diff --git a/src/include/usr/fapi2/target.H b/src/include/usr/fapi2/target.H index 92bc43e1806..a039e5acfc4 100644 --- a/src/include/usr/fapi2/target.H +++ b/src/include/usr/fapi2/target.H @@ -96,7 +96,7 @@ inline Target /// /// @brief Assignment Operator. -/// @tparam K The type of target of which this is called +/// @tparam K The type of target on which this is called /// @tparam V the type of the target's Value /// @param[in] i_right Reference to Target to assign from. /// @return Reference to 'this' Target @@ -107,7 +107,7 @@ Target& Target::operator=(const Target& i_right) /// /// @brief Equality Comparison Operator -/// @tparam K The type of target of which this is called +/// @tparam K The type of target on which this is called /// @tparam V the type of the target's Value /// @param[in] i_right Reference to Target to compare. /// @return bool. True if equal. @@ -121,7 +121,7 @@ bool Target::operator==(const Target& i_right) const /// /// @brief Inquality Comparison Operator -/// @tparam K The type of target of which this is called +/// @tparam K The type of target on which this is called /// @tparam V the type of the target's Value /// @param[in] i_right Reference to Target to compare. /// @return bool. True if not equal. @@ -343,17 +343,17 @@ inline fapi2::TargetType convertTargetingTypeToFapi2(TARGETING::TYPE i_T) /// /// @brief Get this target's immediate parent -/// @tparam T The desired type of the parent target -/// @tparam K The type of target of which this is called +/// @tparam T_SELF The type of target on which this is called +/// @tparam K_PARENT The desired type of the parent target /// @tparam V the type of the target's Value /// @return Target a target representing the parent /// -template -template -inline Target Target::getParent(void) const +template +template +inline Target Target::getParent(void) const { - FAPI_DBG(ENTER_MRK "getParent. Type of parent 0x%08x", T); + FAPI_DBG(ENTER_MRK "getParent. Type of parent 0x%08x", K_PARENT); // General compound chiplet check for proc parent @@ -375,8 +375,8 @@ inline Target Target::getParent(void) const fapi2::TARGET_TYPE_PEC | fapi2::TARGET_TYPE_PHB; - static_assert( !((T == fapi2::TARGET_TYPE_PROC_CHIP) && - ((K & TARGET_TYPE_PROC_CHIPLETS) == fapi2::TARGET_TYPE_NONE)), + static_assert( !((K_PARENT == fapi2::TARGET_TYPE_PROC_CHIP) && + ((T_SELF & TARGET_TYPE_PROC_CHIPLETS) == fapi2::TARGET_TYPE_NONE)), "fapi2::TARGET_TYPE_PROC_CHIP is not a valid parent" ); const fapi2::TargetType TARGET_TYPE_PERV_CHIPLETS = fapi2::TARGET_TYPE_EQ | @@ -393,8 +393,8 @@ inline Target Target::getParent(void) const fapi2::TARGET_TYPE_PEC | fapi2::TARGET_TYPE_PHB; - static_assert( !((T == fapi2::TARGET_TYPE_PERV) && - ((K & TARGET_TYPE_PERV_CHIPLETS) == fapi2::TARGET_TYPE_NONE)), + static_assert( !((K_PARENT == fapi2::TARGET_TYPE_PERV) && + ((T_SELF & TARGET_TYPE_PERV_CHIPLETS) == fapi2::TARGET_TYPE_NONE)), "fapi2::TARGET_TYPE_PERV is not a valid parent" ); // Specific parent checks for each TargetType @@ -402,53 +402,53 @@ inline Target Target::getParent(void) const // valid parents for DIMM // DIMM -> MCA // DIMM -> MBA - static_assert(!((K == fapi2::TARGET_TYPE_DIMM) && - (T != fapi2::TARGET_TYPE_MCA) && - (T != fapi2::TARGET_TYPE_MBA)), + static_assert(!((T_SELF == fapi2::TARGET_TYPE_DIMM) && + (K_PARENT != fapi2::TARGET_TYPE_MCA) && + (K_PARENT != fapi2::TARGET_TYPE_MBA)), "improper parent of fapi2::TARGET_TYPE_DIMM"); // valid parents for PROC // PROC -> SYSTEM - static_assert(!((K == fapi2::TARGET_TYPE_PROC_CHIP) && - (T != fapi2::TARGET_TYPE_SYSTEM)), + static_assert(!((T_SELF == fapi2::TARGET_TYPE_PROC_CHIP) && + (K_PARENT != fapi2::TARGET_TYPE_SYSTEM)), "improper parent of fapi2::TARGET_TYPE_PROC_CHIP"); // valid parents for MEMBUF // MEMBUF -> SYSTEM // MEMBUF -> DMI - static_assert(!((K == fapi2::TARGET_TYPE_MEMBUF_CHIP) && - (T != fapi2::TARGET_TYPE_SYSTEM) && - (T != fapi2::TARGET_TYPE_DMI)), + static_assert(!((T_SELF == fapi2::TARGET_TYPE_MEMBUF_CHIP) && + (K_PARENT != fapi2::TARGET_TYPE_SYSTEM) && + (K_PARENT != fapi2::TARGET_TYPE_DMI)), "improper parent of fapi2::TARGET_TYPE_MEMBUF_CHIP"); // valid parents for EX // EX -> EQ // EX -> PROC - static_assert(!((K == fapi2::TARGET_TYPE_EX) && - (T != fapi2::TARGET_TYPE_EQ) && - (T != fapi2::TARGET_TYPE_PROC_CHIP)), + static_assert(!((T_SELF == fapi2::TARGET_TYPE_EX) && + (K_PARENT != fapi2::TARGET_TYPE_EQ) && + (K_PARENT != fapi2::TARGET_TYPE_PROC_CHIP)), "improper parent of fapi2::TARGET_TYPE_EX"); // valid parents for MBA // MBA -> MEMBUF - static_assert(!((K == fapi2::TARGET_TYPE_MBA) && - (T != fapi2::TARGET_TYPE_MEMBUF_CHIP)), + static_assert(!((T_SELF == fapi2::TARGET_TYPE_MBA) && + (K_PARENT != fapi2::TARGET_TYPE_MEMBUF_CHIP)), "improper parent of fapi2::TARGET_TYPE_MBA"); // valid parents for MCS // MCS -> MCBIST // MCS -> PERV // MCS -> PROC - static_assert(!((K == fapi2::TARGET_TYPE_MCS) && - (T != fapi2::TARGET_TYPE_MCBIST) && - (T != fapi2::TARGET_TYPE_PERV) && - (T != fapi2::TARGET_TYPE_PROC_CHIP)), + static_assert(!((T_SELF == fapi2::TARGET_TYPE_MCS) && + (K_PARENT != fapi2::TARGET_TYPE_MCBIST) && + (K_PARENT != fapi2::TARGET_TYPE_PERV) && + (K_PARENT != fapi2::TARGET_TYPE_PROC_CHIP)), "improper parent of fapi2::TARGET_TYPE_MCS"); // valid parents for L4 // L4 -> MEMBUF - static_assert(!((K == fapi2::TARGET_TYPE_L4) && - (T != fapi2::TARGET_TYPE_MEMBUF_CHIP)), + static_assert(!((T_SELF == fapi2::TARGET_TYPE_L4) && + (K_PARENT != fapi2::TARGET_TYPE_MEMBUF_CHIP)), "improper parent of fapi2::TARGET_TYPE_L4"); // valid parents for CORE @@ -456,19 +456,19 @@ inline Target Target::getParent(void) const // CORE -> EQ // CORE -> PERV // CORE -> PROC - static_assert(!((K == fapi2::TARGET_TYPE_CORE) && - (T != fapi2::TARGET_TYPE_EX) && - (T != fapi2::TARGET_TYPE_EQ) && - (T != fapi2::TARGET_TYPE_PERV) && - (T != fapi2::TARGET_TYPE_PROC_CHIP)), + static_assert(!((T_SELF == fapi2::TARGET_TYPE_CORE) && + (K_PARENT != fapi2::TARGET_TYPE_EX) && + (K_PARENT != fapi2::TARGET_TYPE_EQ) && + (K_PARENT != fapi2::TARGET_TYPE_PERV) && + (K_PARENT != fapi2::TARGET_TYPE_PROC_CHIP)), "improper parent of fapi2::TARGET_TYPE_CORE"); // valid parents for EQ // EQ -> PROC // EQ -> PERV - static_assert(!((K == fapi2::TARGET_TYPE_EQ) && - (T != fapi2::TARGET_TYPE_PERV) && - (T != fapi2::TARGET_TYPE_PROC_CHIP)), + static_assert(!((T_SELF == fapi2::TARGET_TYPE_EQ) && + (K_PARENT != fapi2::TARGET_TYPE_PERV) && + (K_PARENT != fapi2::TARGET_TYPE_PROC_CHIP)), "improper parent of fapi2::TARGET_TYPE_EQ"); // valid parents for MCA @@ -476,114 +476,115 @@ inline Target Target::getParent(void) const // MCA -> MCBIST // MCA -> PERV // MCA -> PROC - static_assert(!((K == fapi2::TARGET_TYPE_MCA) && - (T != fapi2::TARGET_TYPE_MCS) && - (T != fapi2::TARGET_TYPE_MCBIST) && - (T != fapi2::TARGET_TYPE_PERV) && - (T != fapi2::TARGET_TYPE_PROC_CHIP)), + static_assert(!((T_SELF == fapi2::TARGET_TYPE_MCA) && + (K_PARENT != fapi2::TARGET_TYPE_MCS) && + (K_PARENT != fapi2::TARGET_TYPE_MCBIST) && + (K_PARENT != fapi2::TARGET_TYPE_PERV) && + (K_PARENT != fapi2::TARGET_TYPE_PROC_CHIP)), "improper parent of fapi2::TARGET_TYPE_MCA"); // valid parents for MCBIST // MCBIST -> PERV // MCBIST -> PROC - static_assert(!((K == fapi2::TARGET_TYPE_MCBIST) && - (T != fapi2::TARGET_TYPE_PERV) && - (T != fapi2::TARGET_TYPE_PROC_CHIP)), + static_assert(!((T_SELF == fapi2::TARGET_TYPE_MCBIST) && + (K_PARENT != fapi2::TARGET_TYPE_PERV) && + (K_PARENT != fapi2::TARGET_TYPE_PROC_CHIP)), "improper parent of fapi2::TARGET_TYPE_MCBIST"); // valid parents for MI // MI -> PERV // MI -> PROC - static_assert(!((K == fapi2::TARGET_TYPE_MI) && - (T != fapi2::TARGET_TYPE_PERV) && - (T != fapi2::TARGET_TYPE_PROC_CHIP)), + static_assert(!((T_SELF == fapi2::TARGET_TYPE_MI) && + (K_PARENT != fapi2::TARGET_TYPE_PERV) && + (K_PARENT != fapi2::TARGET_TYPE_PROC_CHIP)), "improper parent of fapi2::TARGET_TYPE_MI"); // valid parents for DMI // DMI -> MI // DMI -> PERV // DMI -> PROC - static_assert(!((K == fapi2::TARGET_TYPE_DMI) && - (T != fapi2::TARGET_TYPE_MI) && - (T != fapi2::TARGET_TYPE_PERV) && - (T != fapi2::TARGET_TYPE_PROC_CHIP)), + static_assert(!((T_SELF == fapi2::TARGET_TYPE_DMI) && + (K_PARENT != fapi2::TARGET_TYPE_MI) && + (K_PARENT != fapi2::TARGET_TYPE_PERV) && + (K_PARENT != fapi2::TARGET_TYPE_PROC_CHIP)), "improper parent of fapi2::TARGET_TYPE_DMI"); // valid parents for SBE // SBE -> PROC - static_assert(!((K == fapi2::TARGET_TYPE_SBE) && - (T != fapi2::TARGET_TYPE_PROC_CHIP)), + static_assert(!((T_SELF == fapi2::TARGET_TYPE_SBE) && + (K_PARENT != fapi2::TARGET_TYPE_PROC_CHIP)), "improper parent of fapi2::TARGET_TYPE_SBE"); // valid parents for PPE // PPE -> PROC - static_assert(!((K == fapi2::TARGET_TYPE_PPE) && - (T != fapi2::TARGET_TYPE_PROC_CHIP)), + static_assert(!((T_SELF == fapi2::TARGET_TYPE_PPE) && + (K_PARENT != fapi2::TARGET_TYPE_PROC_CHIP)), "improper parent of fapi2::TARGET_TYPE_PPE"); // valid parents for PERV // PERV -> PROC - static_assert(!((K == fapi2::TARGET_TYPE_PERV) && - (T != fapi2::TARGET_TYPE_PROC_CHIP)), + static_assert(!((T_SELF == fapi2::TARGET_TYPE_PERV) && + (K_PARENT != fapi2::TARGET_TYPE_PROC_CHIP)), "improper parent of fapi2::TARGET_TYPE_PERV"); // valid parents for PEC // PEC -> PERV // PEC -> PROC - static_assert(!((K == fapi2::TARGET_TYPE_PEC) && - (T != fapi2::TARGET_TYPE_PERV) && - (T != fapi2::TARGET_TYPE_PROC_CHIP)), + static_assert(!((T_SELF == fapi2::TARGET_TYPE_PEC) && + (K_PARENT != fapi2::TARGET_TYPE_PERV) && + (K_PARENT != fapi2::TARGET_TYPE_PROC_CHIP)), "improper parent of fapi2::TARGET_TYPE_PEC"); // valid parents for PHB // PHB -> PERV // PHB -> PROC - static_assert(!((K == fapi2::TARGET_TYPE_PHB) && - (T != fapi2::TARGET_TYPE_PERV) && - (T != fapi2::TARGET_TYPE_PROC_CHIP)), + static_assert(!((T_SELF == fapi2::TARGET_TYPE_PHB) && + (K_PARENT != fapi2::TARGET_TYPE_PERV) && + (K_PARENT != fapi2::TARGET_TYPE_PROC_CHIP)), "improper parent of fapi2::TARGET_TYPE_PHB"); // valid parents for XBUS // XBUS -> PERV // XBUS -> PROC - static_assert(!((K == fapi2::TARGET_TYPE_XBUS) && - (T != fapi2::TARGET_TYPE_PERV) && - (T != fapi2::TARGET_TYPE_PROC_CHIP)), + static_assert(!((T_SELF == fapi2::TARGET_TYPE_XBUS) && + (K_PARENT != fapi2::TARGET_TYPE_PERV) && + (K_PARENT != fapi2::TARGET_TYPE_PROC_CHIP)), "improper parent of fapi2::TARGET_TYPE_XBUS"); // valid parents for OBUS // OBUS -> PERV // OBUS -> PROC - static_assert(!((K == fapi2::TARGET_TYPE_OBUS) && - (T != fapi2::TARGET_TYPE_PERV) && - (T != fapi2::TARGET_TYPE_PROC_CHIP)), + static_assert(!((T_SELF == fapi2::TARGET_TYPE_OBUS) && + (K_PARENT != fapi2::TARGET_TYPE_PERV) && + (K_PARENT != fapi2::TARGET_TYPE_PROC_CHIP)), "improper parent of fapi2::TARGET_TYPE_OBUS"); // valid parents for OBUS_BRICK // OBUS_BRICK -> PERV // OBUS_BRICK -> OBUS // OBUS_BRICK -> PROC - static_assert(!((K == fapi2::TARGET_TYPE_OBUS_BRICK) && - (T != fapi2::TARGET_TYPE_PERV) && - (T != fapi2::TARGET_TYPE_OBUS) && - (T != fapi2::TARGET_TYPE_PROC_CHIP)), + static_assert(!((T_SELF == fapi2::TARGET_TYPE_OBUS_BRICK) && + (K_PARENT != fapi2::TARGET_TYPE_PERV) && + (K_PARENT != fapi2::TARGET_TYPE_OBUS) && + (K_PARENT != fapi2::TARGET_TYPE_PROC_CHIP)), "improper parent of fapi2::TARGET_TYPE_OBUS_BRICK"); // valid parents for CAPP // CAPP -> PERV // CAPP -> PROC - static_assert(!((K == fapi2::TARGET_TYPE_CAPP) && - (T != fapi2::TARGET_TYPE_PERV) && - (T != fapi2::TARGET_TYPE_PROC_CHIP)), + static_assert(!((T_SELF == fapi2::TARGET_TYPE_CAPP) && + (K_PARENT != fapi2::TARGET_TYPE_PERV) && + (K_PARENT != fapi2::TARGET_TYPE_PROC_CHIP)), "improper parent of fapi2::TARGET_TYPE_CAPP"); TARGETING::TargetHandleList l_parentList; - TARGETING::TYPE requiredPType = fapi2::convertFapi2TypeToTargeting(T); + TARGETING::TYPE requiredPType = + fapi2::convertFapi2TypeToTargeting(K_PARENT); - if(T == fapi2::TARGET_TYPE_PERV) + if(K_PARENT == fapi2::TARGET_TYPE_PERV) { TARGETING::getParentPervasiveTargetsByState( l_parentList, @@ -608,19 +609,19 @@ inline Target Target::getParent(void) const TARGETING::Target * l_parentTarget = l_parentList[0]; assert(l_parentTarget != NULL, - "No parent of type %x was found for the target of type %x \ - Found required parent plat type to be %x", T, K, requiredPType) + "No parent of type %x was found for the target of type %x, Found required parent plat type to be %x", + K_PARENT, T_SELF, requiredPType) - Target outTarget(l_parentTarget); + Target outTarget(l_parentTarget); FAPI_DBG(EXIT_MRK "getParent"); return outTarget; } /// /// @brief Get this target's children -/// @tparam T The desired type of child target -/// @tparam K The type of target of which this is called +/// @tparam T_SELF The type of target on which this is called +/// @tparam K_CHILD The desired type of child target /// @tparam V the type of the target's Value /// @param[in] i_state The desired TargetState of the children /// @return std::vector > a vector of present/functional @@ -628,16 +629,15 @@ inline Target Target::getParent(void) const /// @warning The children of EX's (cores) are expected to be returned /// in order. That is, core 0 is std::vector[0]. /// -template -template< TargetType T> -inline std::vector > - Target::getChildren(const TargetState i_state) const +template +template< TargetType K_CHILD> +inline std::vector > + Target::getChildren(const TargetState i_state) const { - -FAPI_DBG(ENTER_MRK "getChildren. Type 0x%08x State:0x%08x", T, i_state); -#define INVALID_CHILD(PARENT, CHILD) \ - static_assert(!((K == PARENT) && (T == CHILD)), \ - #CHILD " is not a child of " #PARENT ); + FAPI_DBG(ENTER_MRK "getChildren. Type 0x%08x State:0x%08x", K_CHILD, i_state); +#define INVALID_CHILD(_PARENT, _CHILD) \ + static_assert(!((T_SELF == _PARENT) && (K_CHILD == _CHILD)), \ + #_CHILD " is not a child of " #_PARENT ); // invalid children for proc INVALID_CHILD(fapi2::TARGET_TYPE_PROC_CHIP, fapi2::TARGET_TYPE_NONE) @@ -662,130 +662,130 @@ FAPI_DBG(ENTER_MRK "getChildren. Type 0x%08x State:0x%08x", T, i_state); // PERV -> PHB // PERV -> MI // PERV -> DMI - static_assert(!((K == fapi2::TARGET_TYPE_PERV) && - (T != fapi2::TARGET_TYPE_EQ) && - (T != fapi2::TARGET_TYPE_CORE) && - (T != fapi2::TARGET_TYPE_XBUS) && - (T != fapi2::TARGET_TYPE_OBUS) && - (T != fapi2::TARGET_TYPE_CAPP) && - (T != fapi2::TARGET_TYPE_OBUS_BRICK) && - (T != fapi2::TARGET_TYPE_MCBIST) && - (T != fapi2::TARGET_TYPE_MCS) && - (T != fapi2::TARGET_TYPE_MCA) && - (T != fapi2::TARGET_TYPE_PEC) && - (T != fapi2::TARGET_TYPE_PHB) && - (T != fapi2::TARGET_TYPE_MI) && - (T != fapi2::TARGET_TYPE_DMI)), + static_assert(!((T_SELF == fapi2::TARGET_TYPE_PERV) && + (K_CHILD != fapi2::TARGET_TYPE_EQ) && + (K_CHILD != fapi2::TARGET_TYPE_CORE) && + (K_CHILD != fapi2::TARGET_TYPE_XBUS) && + (K_CHILD != fapi2::TARGET_TYPE_OBUS) && + (K_CHILD != fapi2::TARGET_TYPE_CAPP) && + (K_CHILD != fapi2::TARGET_TYPE_OBUS_BRICK) && + (K_CHILD != fapi2::TARGET_TYPE_MCBIST) && + (K_CHILD != fapi2::TARGET_TYPE_MCS) && + (K_CHILD != fapi2::TARGET_TYPE_MCA) && + (K_CHILD != fapi2::TARGET_TYPE_PEC) && + (K_CHILD != fapi2::TARGET_TYPE_PHB) && + (K_CHILD != fapi2::TARGET_TYPE_MI) && + (K_CHILD != fapi2::TARGET_TYPE_DMI)), "improper child of fapi2::TARGET_TYPE_PERV"); // valid children for MEMBUF // MEMBUF -> L4 // MEMBUF -> MBA - static_assert(!((K == fapi2::TARGET_TYPE_MEMBUF_CHIP) && - (T != fapi2::TARGET_TYPE_L4) && - (T != fapi2::TARGET_TYPE_MBA)), + static_assert(!((T_SELF == fapi2::TARGET_TYPE_MEMBUF_CHIP) && + (K_CHILD != fapi2::TARGET_TYPE_L4) && + (K_CHILD != fapi2::TARGET_TYPE_MBA)), "improper child of fapi2::TARGET_TYPE_MEMBUF_CHIP"); // valid children for system // SYSTEM -> PROC // SYSTEM -> MEMBUF // SYSTEM -> DIMM ??? disabled for now - static_assert(!((K == fapi2::TARGET_TYPE_SYSTEM) && - (T != fapi2::TARGET_TYPE_PROC_CHIP) && - (T != fapi2::TARGET_TYPE_MEMBUF_CHIP)), + static_assert(!((T_SELF == fapi2::TARGET_TYPE_SYSTEM) && + (K_CHILD != fapi2::TARGET_TYPE_PROC_CHIP) && + (K_CHILD != fapi2::TARGET_TYPE_MEMBUF_CHIP)), "improper child of fapi2::TARGET_TYPE_SYSTEM"); // valid children for EQ // EQ -> CORE // EQ -> EX - static_assert(!((K == fapi2::TARGET_TYPE_EQ) && - (T != fapi2::TARGET_TYPE_CORE) && - (T != fapi2::TARGET_TYPE_EX)), + static_assert(!((T_SELF == fapi2::TARGET_TYPE_EQ) && + (K_CHILD != fapi2::TARGET_TYPE_CORE) && + (K_CHILD != fapi2::TARGET_TYPE_EX)), "improper child of fapi2::TARGET_TYPE_EQ"); // valid children for EX // EX -> CORE - static_assert(!((K == fapi2::TARGET_TYPE_EX) && - (T != fapi2::TARGET_TYPE_CORE)), + static_assert(!((T_SELF == fapi2::TARGET_TYPE_EX) && + (K_CHILD != fapi2::TARGET_TYPE_CORE)), "improper child of fapi2::TARGET_TYPE_EX"); // Nimbus Memory // valid children for MCS // MCS -> MCA - static_assert(!((K == fapi2::TARGET_TYPE_MCS) && - (T != fapi2::TARGET_TYPE_MCA)), + static_assert(!((T_SELF == fapi2::TARGET_TYPE_MCS) && + (K_CHILD != fapi2::TARGET_TYPE_MCA)), "improper child of fapi2::TARGET_TYPE_MCS"); // valid children for MCA // MCA -> DIMM - static_assert(!((K == fapi2::TARGET_TYPE_MCA) && - (T != fapi2::TARGET_TYPE_DIMM)), + static_assert(!((T_SELF == fapi2::TARGET_TYPE_MCA) && + (K_CHILD != fapi2::TARGET_TYPE_DIMM)), "improper child of fapi2::TARGET_TYPE_MCA"); // valid children for MCBIST // MCBIST -> MCA // MCBIST -> MCS - static_assert(!((K == fapi2::TARGET_TYPE_MCBIST) && - (T != fapi2::TARGET_TYPE_MCA) && - (T != fapi2::TARGET_TYPE_MCS)), + static_assert(!((T_SELF == fapi2::TARGET_TYPE_MCBIST) && + (K_CHILD != fapi2::TARGET_TYPE_MCA) && + (K_CHILD != fapi2::TARGET_TYPE_MCS)), "improper child of fapi2::TARGET_TYPE_MCBIST"); // Cumulus Memory // valid children for MI // MI -> DMI - static_assert(!((K == fapi2::TARGET_TYPE_MI) && - (T != fapi2::TARGET_TYPE_DMI)), + static_assert(!((T_SELF == fapi2::TARGET_TYPE_MI) && + (K_CHILD != fapi2::TARGET_TYPE_DMI)), "improper child of fapi2::TARGET_TYPE_MI"); // valid children for DMI // DMI -> MEMBUF - static_assert(!((K == fapi2::TARGET_TYPE_DMI) && - (T != fapi2::TARGET_TYPE_MEMBUF_CHIP)), + static_assert(!((T_SELF == fapi2::TARGET_TYPE_DMI) && + (K_CHILD != fapi2::TARGET_TYPE_MEMBUF_CHIP)), "improper child of fapi2::TARGET_TYPE_DMI"); // valid children for MBA // MBA -> DIMM - static_assert(!((K == fapi2::TARGET_TYPE_MBA) && - (T != fapi2::TARGET_TYPE_DIMM)), + static_assert(!((T_SELF == fapi2::TARGET_TYPE_MBA) && + (K_CHILD != fapi2::TARGET_TYPE_DIMM)), "improper child of fapi2::TARGET_TYPE_MBA"); //Check that we are not calling this on a target with no children - static_assert((K != fapi2::TARGET_TYPE_NONE), + static_assert((T_SELF != fapi2::TARGET_TYPE_NONE), "fapi2::TARGET_TYPE_NONE has no children"); - static_assert((K != fapi2::TARGET_TYPE_XBUS), + static_assert((T_SELF != fapi2::TARGET_TYPE_XBUS), "fapi2::TARGET_TYPE_XBUS has no children"); - static_assert((K != fapi2::TARGET_TYPE_ABUS), + static_assert((T_SELF != fapi2::TARGET_TYPE_ABUS), "fapi2::TARGET_TYPE_ABUS has no children"); - static_assert((K != fapi2::TARGET_TYPE_L4), + static_assert((T_SELF != fapi2::TARGET_TYPE_L4), "fapi2::TARGET_TYPE_L4 has no children"); - static_assert((K != fapi2::TARGET_TYPE_CORE), + static_assert((T_SELF != fapi2::TARGET_TYPE_CORE), "fapi2::TARGET_TYPE_CORE has no children"); - static_assert((K != fapi2::TARGET_TYPE_CAPP), + static_assert((T_SELF != fapi2::TARGET_TYPE_CAPP), "fapi2::TARGET_TYPE_CAPP has no children"); - static_assert((K != fapi2::TARGET_TYPE_OBUS), + static_assert((T_SELF != fapi2::TARGET_TYPE_OBUS), "fapi2::TARGET_TYPE_OBUS has no children"); - static_assert((K != fapi2::TARGET_TYPE_OBUS_BRICK), + static_assert((T_SELF != fapi2::TARGET_TYPE_OBUS_BRICK), "fapi2::TARGET_TYPE_OBUS_BRICK has no children"); - static_assert((K != fapi2::TARGET_TYPE_SBE), + static_assert((T_SELF != fapi2::TARGET_TYPE_SBE), "fapi2::TARGET_TYPE_SBE has no children"); - static_assert((K != fapi2::TARGET_TYPE_PPE), + static_assert((T_SELF != fapi2::TARGET_TYPE_PPE), "fapi2::TARGET_TYPE_PPE has no children"); - static_assert((K != fapi2::TARGET_TYPE_PEC), + static_assert((T_SELF != fapi2::TARGET_TYPE_PEC), "fapi2::TARGET_TYPE_PEC has no children"); - static_assert((K != fapi2::TARGET_TYPE_PHB), + static_assert((T_SELF != fapi2::TARGET_TYPE_PHB), "fapi2::TARGET_TYPE_PHB has no children"); - std::vector> l_children; + std::vector> l_children; //Get the platform target type of the current fapi2::target - TARGETING::TYPE l_type = fapi2::convertFapi2TypeToTargeting(T); + TARGETING::TYPE l_type = fapi2::convertFapi2TypeToTargeting(K_CHILD); TARGETING::TargetHandleList l_childList; bool l_functional = (i_state & fapi2::TARGET_STATE_FUNCTIONAL)? true:false; if(!l_functional) { // PERV targets use a special interface - if(K == fapi2::TARGET_TYPE_PERV) + if(T_SELF == fapi2::TARGET_TYPE_PERV) { TARGETING::getPervasiveChildTargetsByState(l_childList, static_cast(this->get()), @@ -795,7 +795,7 @@ FAPI_DBG(ENTER_MRK "getChildren. Type 0x%08x State:0x%08x", T, i_state); } // DIMMs need to use PRESENT so that we don't report things // that aren't installed - else if(K == fapi2::TARGET_TYPE_DIMM) + else if(K_CHILD == fapi2::TARGET_TYPE_DIMM) { TARGETING::getChildAffinityTargetsByState(l_childList, static_cast(this->get()), @@ -816,7 +816,7 @@ FAPI_DBG(ENTER_MRK "getChildren. Type 0x%08x State:0x%08x", T, i_state); } else { - if(K == fapi2::TARGET_TYPE_PERV) + if(T_SELF == fapi2::TARGET_TYPE_PERV) { TARGETING::getPervasiveChildTargetsByState(l_childList, static_cast(this->get()), @@ -844,7 +844,7 @@ FAPI_DBG(ENTER_MRK "getChildren. Type 0x%08x State:0x%08x", T, i_state); chipletIter != l_childList.end(); ++chipletIter) { - fapi2::Target l_target(*chipletIter); + fapi2::Target l_target(*chipletIter); l_children.push_back(l_target); } FAPI_DBG(EXIT_MRK "getChildren. %d results", l_children.size()); @@ -856,17 +856,17 @@ FAPI_DBG(ENTER_MRK "getChildren. Type 0x%08x State:0x%08x", T, i_state); /// /// @brief Get this target's children, filtered /// @tparam T The type of the parent -/// @tparam K The type of target of which this is called +/// @tparam T_SELF The type of target on which this is called /// @tparam V the type of the target's Value /// @param[in] i_filter The desired chiplet filter /// @param[in] i_state The desired TargetState of the children /// @return std::vector > a vector of present/functional /// children /// -template +template template< TargetType T> inline std::vector > - Target::getChildren(const TargetFilter i_filter, + Target::getChildren(const TargetFilter i_filter, const TargetState i_state) const { std::vector> l_children; @@ -874,13 +874,14 @@ inline std::vector > l_children = this->getChildren(i_state); FAPI_DBG("getChildrenFilter: Tgt=0x%.8X, i_filter=0x%.16X," - "K-Type=0x%.8X, T-Type=0x%.8X, sizeA=%d", - TARGETING::get_huid(this->get()), i_filter, K, T, l_children.size()); + "T_SELF-Type=0x%.8X, T-Type=0x%.8X, sizeA=%d", + TARGETING::get_huid(this->get()), i_filter, + T_SELF, T, l_children.size()); // Limit to getting Pervasive children from proc_chip parent for now //@TODO RTC:155755 to track possible additional support static_assert(((T == fapi2::TARGET_TYPE_PERV) && - (K == fapi2::TARGET_TYPE_PROC_CHIP)), + (T_SELF == fapi2::TARGET_TYPE_PROC_CHIP)), "fapi2::getChildren-Filter only supports getting fapi2::TARGET_TYPE_PERV children on a fapi2::TARGET_TYPE_PROC_CHIP"); for ( auto childIter = l_children.begin(); @@ -936,10 +937,10 @@ inline std::vector > /// ReturnCode in the event of failure /// @note o_target is only valid if return is FAPI2_RC_SUCCESS /// -template +template template inline fapi2::ReturnCodes -Target::getOtherEnd(fapi2::Target& o_target, +Target::getOtherEnd(fapi2::Target& o_target, const TargetState i_state) const { ReturnCodes l_rc; @@ -952,10 +953,10 @@ Target::getOtherEnd(fapi2::Target& o_target, // ABUS <-> ABUS // OBUS <-> OBUS - static_assert( K==T, "both ends must be of same fapi2::TARGET_TYPE"); - static_assert ( ( (K==fapi2::TARGET_TYPE_XBUS) || - (K==fapi2::TARGET_TYPE_ABUS) || - (K==fapi2::TARGET_TYPE_OBUS) ), + static_assert( T_SELF==T, "both ends must be of same fapi2::TARGET_TYPE"); + static_assert ( ( (T_SELF==fapi2::TARGET_TYPE_XBUS) || + (T_SELF==fapi2::TARGET_TYPE_ABUS) || + (T_SELF==fapi2::TARGET_TYPE_OBUS) ), "Only types of XBUS, ABUS, and OBUS are supported"); // for the supported types above, only one option supported @@ -1052,8 +1053,8 @@ Target::getOtherEnd(fapi2::Target& o_target, /// @brief Determine whether the target is functional or not /// @return true if the target is functional, false otherwise /// -template< TargetType K, typename V > -inline bool Target< K, V >::isFunctional(void) const +template< TargetType T_SELF, typename V > +inline bool Target< T_SELF, V >::isFunctional(void) const { TARGETING::PredicateIsFunctional l_functional; return l_functional(static_cast(this->get())); @@ -1248,8 +1249,8 @@ inline Target getTarget(uint64_t i_ordinal_id ) /// @note For logical targets such as the EX, the chiplet number of /// their immediate parent chiplet is returned /// -template< TargetType K, typename V > -inline uint8_t Target< K, V >::getChipletNumber(void) const +template< TargetType T_SELF, typename V > +inline uint8_t Target< T_SELF, V >::getChipletNumber(void) const { const TARGETING::Target * l_pTarget = static_cast(this->get()); diff --git a/src/usr/fapi2/plat_utils.C b/src/usr/fapi2/plat_utils.C index fb63fc3f234..39c20b7b163 100644 --- a/src/usr/fapi2/plat_utils.C +++ b/src/usr/fapi2/plat_utils.C @@ -965,7 +965,7 @@ void logError( fapi2::errlSeverity_t i_sev, bool i_unitTestError ) { - FAPI_DBG("Entering logError" ); + FAPI_INF("logError(rc=%x, sev=%d)", (uint32_t)io_rc, i_sev ); createPlatLog( io_rc, i_sev );