FAPI2 GetParent Interface

This commit addes the getParent function the fapi2::target interface.
Also in this commit I remove some old fapi dependencies, and
changed some reasoncode information that was causing naming collisions.

Change-Id: Ib9ba92eaccf29709dafcdead9c82ccc8f8b139c1
RTC:129517
Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/837
Tested-by: Jenkins Server
Tested-by: FSP CI Jenkins
Reviewed-by: Nicholas E. Bofferding <bofferdn@us.ibm.com>
Reviewed-by: Thi N. Tran <thi@us.ibm.com>
Reviewed-by: Daniel M. Crowell <dcrowell@us.ibm.com>

7 files changed, 1274 insertions, 20 deletions

diff --git a/src/include/usr/fapi2/target.H b/src/include/usr/fapi2/target.H
index 93e5c521c..e38f24585 100644
--- a/src/include/usr/fapi2/target.H
+++ b/src/include/usr/fapi2/target.H
@@ -5,7 +5,7 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2012,2016                        */
+/* Contributors Listed Below - COPYRIGHT 2015,2016                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
 /*                                                                        */
@@ -42,6 +42,7 @@
 #include <fapi2_target.H>
 #include <target_types.H>
 
+
 // HB platform support
 #include <fapiPlatTrace.H>
 #include <targeting/common/target.H>
@@ -53,6 +54,8 @@ namespace fapi2
 
 ///
 /// @brief Assignment Operator.
+/// @tparam K The type of target of 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
 ///
@@ -62,6 +65,8 @@ Target<K, V>& Target<K, V>::operator=(const Target& i_right)
 
 ///
 /// @brief Equality Comparison Operator
+/// @tparam K The type of target of 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.
 /// @note Platforms need to define this so that the physical
@@ -73,6 +78,8 @@ bool Target<K, V>::operator==(const Target& i_right) const
 
 ///
 /// @brief Inquality Comparison Operator
+/// @tparam K The type of target of 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.
 /// @note Platforms need to define this so that the physical
@@ -82,6 +89,7 @@ template<TargetType K, typename V>
 bool Target<K, V>::operator!=(const Target& i_right) const
 { return i_right.iv_handle != iv_handle; }
 
+
 ///
 /// @brief This function takes in a FAPI2 Type and returns the corresponding
 ///         TARGETING::Target type
@@ -183,20 +191,269 @@ inline TARGETING::TYPE convertFapi2TypeToTargeting(fapi2::TargetType 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 V the type of the target's Value
 /// @return Target<T> a target representing the parent
 ///
 template<TargetType K, typename V>
 template<TargetType T>
 inline Target<T> Target<K, V>::getParent(void) const
 {
-  //@TODO RTC:129517 fapi2 getParent
-    // For testing
-    return Target<T>(iv_handle);
+
+    FAPI_DBG(ENTER_MRK "getParent. Type of parent 0x%08x", T);
+
+    // General compound chiplet check for proc parent
+
+    const fapi2::TargetType TARGET_TYPE_PROC_CHIPLETS = fapi2::TARGET_TYPE_EX |
+            fapi2::TARGET_TYPE_MCS |
+            fapi2::TARGET_TYPE_XBUS |
+            fapi2::TARGET_TYPE_CORE |
+            fapi2::TARGET_TYPE_EQ |
+            fapi2::TARGET_TYPE_MCA |
+            fapi2::TARGET_TYPE_MCBIST |
+            fapi2::TARGET_TYPE_MI |
+            fapi2::TARGET_TYPE_CAPP |
+            fapi2::TARGET_TYPE_DMI |
+            fapi2::TARGET_TYPE_OBUS |
+            fapi2::TARGET_TYPE_NV |
+            fapi2::TARGET_TYPE_SBE |
+            fapi2::TARGET_TYPE_PPE |
+            fapi2::TARGET_TYPE_PERV |
+            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)),
+                   "fapi2::TARGET_TYPE_PROC_CHIP is not a valid parent" );
+
+    const fapi2::TargetType TARGET_TYPE_PERV_CHIPLETS = fapi2::TARGET_TYPE_EQ |
+            fapi2::TARGET_TYPE_CORE |
+            fapi2::TARGET_TYPE_XBUS |
+            fapi2::TARGET_TYPE_OBUS |
+            fapi2::TARGET_TYPE_CAPP |
+            fapi2::TARGET_TYPE_NV |
+            fapi2::TARGET_TYPE_MCBIST |
+            fapi2::TARGET_TYPE_MCS |
+            fapi2::TARGET_TYPE_MCA |
+            fapi2::TARGET_TYPE_MI |
+            fapi2::TARGET_TYPE_DMI |
+            fapi2::TARGET_TYPE_PEC |
+            fapi2::TARGET_TYPE_PHB;
+
+    static_assert( !((T == fapi2::TARGET_TYPE_PERV) &&
+                     ((K & TARGET_TYPE_PERV_CHIPLETS) == fapi2::TARGET_TYPE_NONE)),
+                   "fapi2::TARGET_TYPE_PERV is not a valid parent" );
+
+    // Specific parent checks for each TargetType
+
+    // 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)),
+                  "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)),
+                  "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)),
+                  "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)),
+                  "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)),
+                  "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)),
+                  "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)),
+                  "improper parent of fapi2::TARGET_TYPE_L4");
+
+    // valid parents for CORE
+    // CORE -> EX
+    // 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)),
+                  "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)),
+                  "improper parent of fapi2::TARGET_TYPE_EQ");
+
+    // valid parents for MCA
+    // MCA -> MCS
+    // 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)),
+                  "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)),
+                  "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)),
+                  "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)),
+                  "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)),
+                  "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)),
+                  "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)),
+                  "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)),
+                  "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)),
+                  "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)),
+                  "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)),
+                  "improper parent of fapi2::TARGET_TYPE_OBUS");
+
+    // valid parents for NV
+    // NV -> PERV
+    // NV -> PROC
+    static_assert(!((K == fapi2::TARGET_TYPE_NV) &&
+                    (T != fapi2::TARGET_TYPE_PERV) &&
+                    (T != fapi2::TARGET_TYPE_PROC_CHIP)),
+                  "improper parent of fapi2::TARGET_TYPE_NV");
+
+    // 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)),
+                  "improper parent of fapi2::TARGET_TYPE_CAPP");
+
+
+
+    TARGETING::TargetHandleList l_parentList;
+
+    TARGETING::TYPE requiredPType = fapi2::convertFapi2TypeToTargeting(T);
+
+    TARGETING::getParentAffinityTargetsByState(l_parentList,
+                                    static_cast<TARGETING::Target*>(this->get()),
+                                    TARGETING::CLASS_NA,
+                                    requiredPType,
+                                    TARGETING::UTIL_FILTER_ALL);
+
+    assert(l_parentList.size() == 1, "Found %d parents of the same type. Target HUID %x , \
+          looking for parents of type %x", l_parentList.size(), TARGETING::get_huid(this->get()) , requiredPType);
+
+    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)
+
+
+    Target<T> 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 V the type of the target's Value
 /// @param[in] i_state The desired TargetState of the children
 /// @return std::vector<Target<T> > a vector of present/functional
 /// children
@@ -210,7 +467,6 @@ inline std::vector<Target<T> >
 {
 
 FAPI_DBG(ENTER_MRK "getChildren. Type 0x%08x State:0x%08x", T, i_state);
-        // FIXME check for MULTICAST
 #define INVALID_CHILD(PARENT, CHILD) \
     static_assert(!((K == PARENT) && (T == CHILD)), \
                   #CHILD " is not a child of " #PARENT );
@@ -386,17 +642,6 @@ FAPI_DBG(ENTER_MRK "getChildren. Type 0x%08x State:0x%08x", T, i_state);
             chipletIter != l_childList.end();
             ++chipletIter)
     {
-        TARGETING::HwasState l_state =
-            (*chipletIter)->getAttr<TARGETING::ATTR_HWAS_STATE>();
-
-        // HWPs/FAPI considers partial good chiplets as present, but
-        // firmware considers them not-present. Return all chiplets
-        // in the model when caller requests PRESENT
-        if ((fapi2::TARGET_STATE_FUNCTIONAL == i_state) &&
-            !l_state.functional)
-        {
-            continue;
-        }
         fapi2::Target<T> l_target(*chipletIter);
         l_children.push_back(l_target);
     }
@@ -405,9 +650,13 @@ FAPI_DBG(ENTER_MRK "getChildren. Type 0x%08x State:0x%08x", T, i_state);
     return l_children;
 }
 
+
+
 ///
 /// @brief Get the target at the other end of a bus - dimm included
 /// @tparam T The type of the parent
+/// @tparam K The type of target of which this is called
+/// @tparam V the type of the target's Value
 /// @param[in] i_state The desired TargetState of the children
 /// @return Target<T> a target representing the thing on the other end
 /// @note Can be easily changed to a vector if needed
diff --git a/src/include/usr/targeting/common/utilFilter.H b/src/include/usr/targeting/common/utilFilter.H
index 589dcdb67..9c501f418 100644
--- a/src/include/usr/targeting/common/utilFilter.H
+++ b/src/include/usr/targeting/common/utilFilter.H
@@ -5,7 +5,7 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2012,2015                        */
+/* Contributors Listed Below - COPYRIGHT 2012,2016                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
 /*                                                                        */
@@ -254,6 +254,16 @@ void getParentAffinityTargets ( TARGETING::TargetHandleList& o_vector,
 const Target * getParentChip( const Target * i_pChiplet );
 
 /**
+ * @brief return the parent target of the specified input unit
+ *
+ * @parm[in]  i_unit, unit target used for finding the parent target
+ * @parm[in]  i_pType, type of the parent
+ *
+ * @return Parent target pointer or NULL if error
+ */
+const Target * getParent( const Target * i_unit , TARGETING::TYPE &i_pType);
+
+/**
  * @brief return the EX target of the specified input core chiplet
  *
  * @parm[in]  i_pCoreChiplet, core chiplet target for retrieving the
diff --git a/src/usr/fapi2/fapi2.mk b/src/usr/fapi2/fapi2.mk
index 4fe67e6b0..cea9203de 100755
--- a/src/usr/fapi2/fapi2.mk
+++ b/src/usr/fapi2/fapi2.mk
@@ -30,6 +30,7 @@
 
 EXTRAINCDIR += ${ROOTPATH}/src/import/hwpf/fapi2/include/
 EXTRAINCDIR += ${ROOTPATH}/src/include/usr/fapi2/
+EXTRAINCDIR += ${ROOTPATH}/src/import/chips/p9/utils/
 
 #Hostboot objects
 OBJS += plat_utils.o
diff --git a/src/usr/fapi2/test/fapi2GetParentTest.C b/src/usr/fapi2/test/fapi2GetParentTest.C
new file mode 100644
index 000000000..c83f5bac7
--- /dev/null
+++ b/src/usr/fapi2/test/fapi2GetParentTest.C
@@ -0,0 +1,957 @@
+/* IBM_PROLOG_BEGIN_TAG                                                   */
+/* This is an automatically generated prolog.                             */
+/*                                                                        */
+/* $Source: src/usr/fapi2/test/fapi2GetParentTest.C $                     */
+/*                                                                        */
+/* OpenPOWER HostBoot Project                                             */
+/*                                                                        */
+/* Contributors Listed Below - COPYRIGHT 2015,2016                        */
+/* [+] International Business Machines Corp.                              */
+/*                                                                        */
+/*                                                                        */
+/* Licensed under the Apache License, Version 2.0 (the "License");        */
+/* you may not use this file except in compliance with the License.       */
+/* You may obtain a copy of the License at                                */
+/*                                                                        */
+/*     http://www.apache.org/licenses/LICENSE-2.0                         */
+/*                                                                        */
+/* Unless required by applicable law or agreed to in writing, software    */
+/* distributed under the License is distributed on an "AS IS" BASIS,      */
+/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
+/* implied. See the License for the specific language governing           */
+/* permissions and limitations under the License.                         */
+/*                                                                        */
+/* IBM_PROLOG_END_TAG                                                     */
+
+#include <errl/errlmanager.H>
+#include <errl/errlentry.H>
+#include <fapi2.H>
+#include <hwpf_fapi2_reasoncodes.H>
+#include <fapi2TestUtils.H>
+
+using namespace fapi2;
+
+namespace fapi2
+{
+
+//@TODO RTC:148577 need to add tests to get the PERV parent of targets
+//******************************************************************************
+// fapi2GetParentTest
+//******************************************************************************
+errlHndl_t fapi2GetParentTest()
+{
+    int numTests = 0;
+    int numFails = 0;
+    errlHndl_t l_err = NULL;
+    do
+    {
+        // Create a vector of TARGETING::Target pointers
+        TARGETING::TargetHandleList l_chipList;
+
+        // Get a list of all of the proc chips
+        TARGETING::getAllChips(l_chipList, TARGETING::TYPE_PROC, false);
+
+        TARGETING::Target * l_nimbusProc = NULL;
+
+        //Take the first NIMBUS proc and use it
+        for(uint32_t i = 0; i < l_chipList.size(); i++)
+        {
+            if(TARGETING::MODEL_NIMBUS ==
+            l_chipList[i]->getAttr<TARGETING::ATTR_MODEL>())
+            {
+              l_nimbusProc = l_chipList[i];
+              break;
+            }
+        }
+
+        if(l_nimbusProc == NULL)
+        {
+            // Send an errorlog because we cannot find any NIMBUS procs.
+            FAPI_ERR("FAPI2_GETPARENT:: could not find Nimbus proc, skipping tests");
+            numFails++;
+            /*@
+            * @errortype    ERRORLOG::ERRL_SEV_UNRECOVERABLE
+            * @moduleid     fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
+            * @reasoncode   fapi2::RC_NO_PROCS_FOUND
+            * @userdata1    Model Type we looked for
+            * @userdata2    Unused
+            * @devdesc      Could not find NIMBUS procs in system model
+            */
+            l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
+                                          fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
+                                          fapi2::RC_NO_PROCS_FOUND,
+                                          TARGETING::MODEL_NIMBUS,
+                                          NULL,
+                                          true/*SW Error*/);
+            errlCommit(l_err,HWPF_COMP_ID);
+            break;
+        }
+
+        TARGETING::Target* targeting_targets[NUM_TARGETS];
+        generateTargets(l_nimbusProc, targeting_targets);
+
+        for( uint64_t x = 0; x < NUM_TARGETS; x++ )
+        {
+            if(targeting_targets[x] == NULL)
+            {
+                FAPI_ERR("Unable to find target for item %d in targeting_targets", x);
+
+                /*@
+                * @errortype    ERRORLOG::ERRL_SEV_UNRECOVERABLE
+                * @moduleid     fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
+                * @reasoncode   fapi2::RC_NO_PATH_TO_TARGET_FOUND
+                * @userdata1    Index of target in array of objects
+                * @userdata2    Unused
+                * @devdesc      Could not find a path to the target of that type
+                */
+                l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
+                                          fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
+                                          fapi2::RC_NO_PATH_TO_TARGET_FOUND,
+                                          x,
+                                          NULL,
+                                          true/*SW Error*/);
+                errlCommit(l_err,HWPF_COMP_ID);
+            }
+        }
+
+
+        Target<fapi2::TARGET_TYPE_PROC_CHIP> fapi2_procTarget(
+                l_nimbusProc);
+        Target<fapi2::TARGET_TYPE_EQ> fapi2_eqTarget(
+                targeting_targets[MY_EQ]);
+        Target<fapi2::TARGET_TYPE_EX> fapi2_exTarget(
+                targeting_targets[MY_EX]);
+        Target<fapi2::TARGET_TYPE_CORE> fapi2_coreTarget(
+                targeting_targets[MY_CORE]);
+        Target<fapi2::TARGET_TYPE_MCS> fapi2_mcsTarget(
+                targeting_targets[MY_MCS]);
+        Target<fapi2::TARGET_TYPE_MCA> fapi2_mcaTarget(
+                targeting_targets[MY_MCA]);
+        Target<fapi2::TARGET_TYPE_MCBIST> fapi2_mcbistTarget(
+                targeting_targets[MY_MCBIST]);
+        Target<fapi2::TARGET_TYPE_PEC> fapi2_pecTarget(
+                targeting_targets[MY_PEC]);
+        Target<fapi2::TARGET_TYPE_PHB> fapi2_phbTarget(
+                targeting_targets[MY_PHB]);
+        Target<fapi2::TARGET_TYPE_XBUS> fapi2_xbusTarget(
+                targeting_targets[MY_XBUS]);
+        Target<fapi2::TARGET_TYPE_OBUS> fapi2_obusTarget(
+                targeting_targets[MY_OBUS]);
+        Target<fapi2::TARGET_TYPE_NV> fapi2_nvbusTarget(
+                targeting_targets[MY_NVBUS]);
+        Target<fapi2::TARGET_TYPE_PPE> fapi2_ppeTarget(
+                targeting_targets[MY_PPE]);
+        Target<fapi2::TARGET_TYPE_PERV> fapi2_pervTarget(
+                targeting_targets[MY_PERV]);
+        Target<fapi2::TARGET_TYPE_SBE> fapi2_sbeTarget(
+                targeting_targets[MY_SBE]);
+        Target<fapi2::TARGET_TYPE_CAPP> fapi2_cappTarget(
+                targeting_targets[MY_CAPP]);
+
+        TARGETING::Target * l_tempTargetingParent =
+            static_cast<TARGETING::Target*>(
+                fapi2_coreTarget.getParent<TARGET_TYPE_EX>());
+
+        //Check CORE's parents
+        numTests++;
+        if(TARGETING::get_huid(targeting_targets[MY_EX]) !=
+           TARGETING::get_huid(l_tempTargetingParent))
+        {
+            uint8_t l_instance = 0;
+            targeting_targets[MY_CORE]->
+            tryGetAttr<TARGETING::ATTR_CHIP_UNIT>(l_instance);
+
+            /*@
+            * @errortype          ERRORLOG::ERRL_SEV_UNRECOVERABLE
+            * @moduleid           fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
+            * @reasoncode         fapi2::RC_CORE_NO_EX_FOUND
+            * @userdata1[0:31]    Expected Parent HUID
+            * @userdata1[32:63]   Actual Parent HUID
+            * @userdata2[0:31]    Instance of core
+            * @userdata2[32:63]   fapi2 Type of expected parent
+            * @devdesc            Could not find the parent EX of this
+            *                     CORE target
+            */
+            l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
+                                          fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
+                                          fapi2::RC_CORE_NO_EX_FOUND,
+                                          TWO_UINT32_TO_UINT64(
+                                          TO_UINT32(
+                                          TARGETING::get_huid(
+                                          targeting_targets[MY_EX])),
+                                          TO_UINT32(
+                                          TARGETING::get_huid(
+                                          l_tempTargetingParent))),
+                                          TWO_UINT32_TO_UINT64(
+                                          TO_UINT32(l_instance),
+                                          TO_UINT32(TARGET_TYPE_EX)),
+                                          true/*SW Error*/);
+            errlCommit(l_err,HWPF_COMP_ID);
+            TS_FAIL("fapi2TargetTest::Unable to find CORE's EX parent!");
+            numFails++;
+        }
+
+
+        l_tempTargetingParent =
+            static_cast<TARGETING::Target*>(
+                fapi2_coreTarget.getParent<TARGET_TYPE_EQ>());
+
+        numTests++;
+        if(TARGETING::get_huid(targeting_targets[MY_EQ]) !=
+           TARGETING::get_huid(l_tempTargetingParent))
+        {
+            uint8_t l_instance = 0;
+            targeting_targets[MY_CORE]->
+            tryGetAttr<TARGETING::ATTR_CHIP_UNIT>(l_instance);
+            /*@
+            * @errortype          ERRORLOG::ERRL_SEV_UNRECOVERABLE
+            * @moduleid           fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
+            * @reasoncode         fapi2::RC_CORE_NO_EQ_FOUND
+            * @userdata1[0:31]    Expected Parent HUID
+            * @userdata1[32:63]   Actual Parent HUID
+            * @userdata2[0:31]    Instance of core
+            * @userdata2[32:63]   fapi2 Type of expected parent
+            * @devdesc            Could not find the parent EQ of this
+            *                     CORE target
+            */
+            l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
+                                          fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
+                                          fapi2::RC_CORE_NO_EQ_FOUND,
+                                          TWO_UINT32_TO_UINT64(
+                                          TO_UINT32(
+                                          TARGETING::get_huid(
+                                          targeting_targets[MY_EQ])),
+                                          TO_UINT32(
+                                          TARGETING::get_huid(
+                                          l_tempTargetingParent))),
+                                          TWO_UINT32_TO_UINT64(
+                                          TO_UINT32(l_instance),
+                                          TO_UINT32(TARGET_TYPE_EQ)),
+                                          true/*SW Error*/);
+            errlCommit(l_err,HWPF_COMP_ID);
+            TS_FAIL( "fapi2TargetTest::Unable to find CORE's EQ parent!");
+            numFails++;
+        }
+
+
+        l_tempTargetingParent =
+            static_cast<TARGETING::Target*>(
+                fapi2_coreTarget.getParent<TARGET_TYPE_PROC_CHIP>());
+
+        numTests++;
+        if(TARGETING::get_huid(l_nimbusProc) !=
+           TARGETING::get_huid(l_tempTargetingParent))
+        {
+            uint8_t l_instance = 0;
+            targeting_targets[MY_CORE]->
+            tryGetAttr<TARGETING::ATTR_CHIP_UNIT>(l_instance);
+            /*@
+            * @errortype          ERRORLOG::ERRL_SEV_UNRECOVERABLE
+            * @moduleid           fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
+            * @reasoncode         fapi2::RC_CORE_NO_PROC_FOUND
+            * @userdata1[0:31]    Expected Parent HUID
+            * @userdata1[32:63]   Actual Parent HUID
+            * @userdata2[0:31]    Instance of core
+            * @userdata2[32:63]   fapi2 Type of expected parent
+            * @devdesc            Could not find the parent PROC of this
+            *                     CORE target
+            */
+            l_err = new ERRORLOG::ErrlEntry(
+                                ERRORLOG::ERRL_SEV_UNRECOVERABLE,
+                                fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
+                                fapi2::RC_CORE_NO_PROC_FOUND,
+                                TWO_UINT32_TO_UINT64(
+                                TO_UINT32(
+                                TARGETING::get_huid(
+                                l_nimbusProc)),
+                                TO_UINT32(
+                                TARGETING::get_huid(
+                                l_tempTargetingParent))),
+                                TWO_UINT32_TO_UINT64(
+                                TO_UINT32(l_instance),
+                                TO_UINT32(TARGET_TYPE_PROC_CHIP)),
+                                true/*SW Error*/);
+            errlCommit(l_err,HWPF_COMP_ID);
+            TS_FAIL( "fapi2TargetTest::Unable to find CORE's PROC parent!");
+            numFails++;
+        }
+
+
+        l_tempTargetingParent =
+            static_cast<TARGETING::Target*>(
+                fapi2_exTarget.getParent<TARGET_TYPE_EQ>());
+
+        //Check EX's parents
+        numTests++;
+        if(TARGETING::get_huid(targeting_targets[MY_EQ]) !=
+           TARGETING::get_huid(l_tempTargetingParent))
+        {
+
+          uint8_t l_instance = 0;
+          targeting_targets[MY_EX]->
+          tryGetAttr<TARGETING::ATTR_CHIP_UNIT>(l_instance);
+          /*@
+          * @errortype          ERRORLOG::ERRL_SEV_UNRECOVERABLE
+          * @moduleid           fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
+          * @reasoncode         fapi2::RC_EX_NO_EQ_FOUND
+          * @userdata1[0:31]    Expected Parent HUID
+          * @userdata1[32:63]   Actual Parent HUID
+          * @userdata2[0:31]    Instance of EX
+          * @userdata2[32:63]   fapi2 Type of expected parent
+          * @devdesc            Could not find the parent EQ of this EX target
+          */
+          l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
+                                        fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
+                                        fapi2::RC_EX_NO_EQ_FOUND,
+                                        TWO_UINT32_TO_UINT64(
+                                        TO_UINT32(
+                                        TARGETING::get_huid(
+                                        targeting_targets[MY_EQ])),
+                                        TO_UINT32(
+                                        TARGETING::get_huid(
+                                        l_tempTargetingParent))),
+                                        TWO_UINT32_TO_UINT64(
+                                        TO_UINT32(l_instance),
+                                        TO_UINT32(TARGET_TYPE_EQ)),
+                                        true/*SW Error*/);
+            errlCommit(l_err,HWPF_COMP_ID);
+            TS_FAIL( "fapi2TargetTest::Unable to find EX's EQ parent!");
+            numFails++;
+        }
+
+
+        l_tempTargetingParent =
+            static_cast<TARGETING::Target*>(
+                fapi2_exTarget.getParent<TARGET_TYPE_PROC_CHIP>());
+
+        //Check EX's parents
+        numTests++;
+        if(TARGETING::get_huid(l_nimbusProc) !=
+           TARGETING::get_huid(l_tempTargetingParent))
+        {
+            uint8_t l_instance = 0;
+            targeting_targets[MY_EX]->
+            tryGetAttr<TARGETING::ATTR_CHIP_UNIT>(l_instance);
+            /*@
+            * @errortype          ERRORLOG::ERRL_SEV_UNRECOVERABLE
+            * @moduleid           fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
+            * @reasoncode         fapi2::RC_EX_NO_PROC_FOUND
+            * @userdata1[0:31]    Expected Parent HUID
+            * @userdata1[32:63]   Actual Parent HUID
+            * @userdata2[0:31]    Instance of EX
+            * @userdata2[32:63]   fapi2 Type of expected parent
+            * @devdesc           Could not find the parent PROC of this
+            *                    EX target
+            */
+            l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
+                                          fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
+                                          fapi2::RC_EX_NO_PROC_FOUND,
+                                          TWO_UINT32_TO_UINT64(
+                                          TO_UINT32(
+                                          TARGETING::get_huid(
+                                          l_nimbusProc)),
+                                          TO_UINT32(
+                                          TARGETING::get_huid(
+                                          l_tempTargetingParent))),
+                                          TWO_UINT32_TO_UINT64(
+                                          TO_UINT32(l_instance),
+                                          TO_UINT32(TARGET_TYPE_PROC_CHIP)),
+                                          true/*SW Error*/);
+            errlCommit(l_err,HWPF_COMP_ID);
+            TS_FAIL( "fapi2TargetTest::Unable to find EXs's PROC parent!");
+            numFails++;
+        }
+
+        l_tempTargetingParent =
+            static_cast<TARGETING::Target*>(
+                fapi2_eqTarget.getParent<TARGET_TYPE_PROC_CHIP>());
+
+        //Check EQ's parents
+        numTests++;
+        if(TARGETING::get_huid(l_nimbusProc) !=
+           TARGETING::get_huid(l_tempTargetingParent))
+        {
+            uint8_t l_instance = 0;
+            targeting_targets[MY_EQ]->
+            tryGetAttr<TARGETING::ATTR_CHIP_UNIT>(l_instance);
+            /*@
+            * @errortype          ERRORLOG::ERRL_SEV_UNRECOVERABLE
+            * @moduleid           fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
+            * @reasoncode         fapi2::RC_EQ_NO_PROC_FOUND
+            * @userdata1[0:31]    Expected Parent HUID
+            * @userdata1[32:63]   Actual Parent HUID
+            * @userdata2[0:31]    Instance of EQ
+            * @userdata2[32:63]   fapi2 Type of expected parent
+            * @devdesc            Could not find the parent PROC of this
+            *                     EQ target
+            */
+            l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
+                                          fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
+                                          fapi2::RC_EQ_NO_PROC_FOUND,
+                                          TWO_UINT32_TO_UINT64(
+                                          TO_UINT32(
+                                          TARGETING::get_huid(
+                                          l_nimbusProc)),
+                                          TO_UINT32(
+                                          TARGETING::get_huid(
+                                          l_tempTargetingParent))),
+                                          TWO_UINT32_TO_UINT64(
+                                          TO_UINT32(l_instance),
+                                          TO_UINT32(TARGET_TYPE_PROC_CHIP)),
+                                          true/*SW Error*/);
+            errlCommit(l_err,HWPF_COMP_ID);
+            TS_FAIL( "fapi2TargetTest::Unable to find EQs's PROC parent!");
+            numFails++;
+        }
+
+        l_tempTargetingParent =
+            static_cast<TARGETING::Target*>(
+                fapi2_mcaTarget.getParent<TARGET_TYPE_MCS>());
+
+        //Check MCA's parents
+        numTests++;
+        if(TARGETING::get_huid(targeting_targets[MY_MCS]) !=
+           TARGETING::get_huid(l_tempTargetingParent))
+        {
+            uint8_t l_instance = 0;
+            targeting_targets[MY_MCA]->
+            tryGetAttr<TARGETING::ATTR_CHIP_UNIT>(l_instance);
+            /*@
+            * @errortype          ERRORLOG::ERRL_SEV_UNRECOVERABLE
+            * @moduleid           fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
+            * @reasoncode         fapi2::RC_MCA_NO_MCS_FOUND
+            * @userdata1[0:31]    Expected Parent HUID
+            * @userdata1[32:63]   Actual Parent HUID
+            * @userdata2[0:31]    Instance of MCA
+            * @userdata2[32:63]   fapi2 Type of expected parent
+            * @devdesc            Could not find the parent MSC of this
+            *                     MCA target
+            */
+            l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
+                                          fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
+                                          fapi2::RC_MCA_NO_MCS_FOUND,
+                                          TWO_UINT32_TO_UINT64(
+                                          TO_UINT32(
+                                          TARGETING::get_huid(
+                                          targeting_targets[MY_MCS])),
+                                          TO_UINT32(
+                                          TARGETING::get_huid(
+                                          l_tempTargetingParent))),
+                                          TWO_UINT32_TO_UINT64(
+                                          TO_UINT32(l_instance),
+                                          TO_UINT32(TARGET_TYPE_MCS)),
+                                          true/*SW Error*/);
+            errlCommit(l_err,HWPF_COMP_ID);
+            TS_FAIL( "fapi2TargetTest::Unable to find MCA's MCS parent!");
+            numFails++;
+        }
+
+        l_tempTargetingParent =
+            static_cast<TARGETING::Target*>(
+                fapi2_mcaTarget.getParent<TARGET_TYPE_PROC_CHIP>());
+
+        numTests++;
+
+        if(TARGETING::get_huid(l_nimbusProc) !=
+           TARGETING::get_huid(l_tempTargetingParent))
+        {
+            uint8_t l_instance = 0;
+            targeting_targets[MY_MCA]->
+            tryGetAttr<TARGETING::ATTR_CHIP_UNIT>(l_instance);
+            /*@
+            * @errortype          ERRORLOG::ERRL_SEV_UNRECOVERABLE
+            * @moduleid           fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
+            * @reasoncode         fapi2::RC_MCA_NO_PROC_FOUND
+            * @userdata1[0:31]    Expected Parent HUID
+            * @userdata1[32:63]   Actual Parent HUID
+            * @userdata2[0:31]    Instance of MCA
+            * @userdata2[32:63]   fapi2 Type of expected parent
+            * @devdesc            Could not find the parent PROC of this
+            *                     MCA target
+            */
+            l_err = new ERRORLOG::ErrlEntry(
+                                  ERRORLOG::ERRL_SEV_UNRECOVERABLE,
+                                  fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
+                                  fapi2::RC_MCA_NO_PROC_FOUND,
+                                  TWO_UINT32_TO_UINT64(
+                                  TO_UINT32(
+                                  TARGETING::get_huid(
+                                  l_nimbusProc)),
+                                  TO_UINT32(
+                                  TARGETING::get_huid(
+                                  l_tempTargetingParent))),
+                                  TWO_UINT32_TO_UINT64(
+                                  TO_UINT32(l_instance),
+                                  TO_UINT32(TARGET_TYPE_PROC_CHIP)),
+                                  true/*SW Error*/);
+            errlCommit(l_err,HWPF_COMP_ID);
+            TS_FAIL( "fapi2TargetTest::Unable to find MCA's PROC parent!");
+            numFails++;
+        }
+
+        //Check MCS's parents
+
+        l_tempTargetingParent =
+            static_cast<TARGETING::Target*>(
+                fapi2_mcsTarget.getParent<TARGET_TYPE_PROC_CHIP>());
+
+        numTests++;
+        if(TARGETING::get_huid(l_nimbusProc) !=
+           TARGETING::get_huid(l_tempTargetingParent))
+        {
+            uint8_t l_instance = 0;
+            targeting_targets[MY_MCS]->
+            tryGetAttr<TARGETING::ATTR_CHIP_UNIT>(l_instance);
+            /*@
+            * @errortype          ERRORLOG::ERRL_SEV_UNRECOVERABLE
+            * @moduleid           fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
+            * @reasoncode         fapi2::RC_MCS_NO_PROC_FOUND
+            * @userdata1[0:31]    Expected Parent HUID
+            * @userdata1[32:63]   Actual Parent HUID
+            * @userdata2[0:31]    Instance of MCS
+            * @userdata2[32:63]   fapi2 Type of expected parent
+            * @devdesc            Could not find the parent PROC of this
+            *                     MCS target
+            */
+            l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
+                                          fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
+                                          fapi2::RC_MCS_NO_PROC_FOUND,
+                                          TWO_UINT32_TO_UINT64(
+                                          TO_UINT32(
+                                          TARGETING::get_huid(
+                                          l_nimbusProc)),
+                                          TO_UINT32(
+                                          TARGETING::get_huid(
+                                          l_tempTargetingParent))),
+                                          TWO_UINT32_TO_UINT64(
+                                          TO_UINT32(l_instance),
+                                          TO_UINT32(TARGET_TYPE_PROC_CHIP)),
+                                          true/*SW Error*/);
+            errlCommit(l_err,HWPF_COMP_ID);
+            TS_FAIL( "fapi2TargetTest::Unable to find MCS's PROC parent!");
+            numFails++;
+        }
+
+        //Check MCBIST's parents
+        l_tempTargetingParent =
+            static_cast<TARGETING::Target*>(
+                fapi2_mcbistTarget.getParent<TARGET_TYPE_PROC_CHIP>());
+
+        numTests++;
+        if(TARGETING::get_huid(l_nimbusProc) !=
+           TARGETING::get_huid(l_tempTargetingParent))
+        {
+            uint8_t l_instance = 0;
+            targeting_targets[MY_MCBIST]->
+            tryGetAttr<TARGETING::ATTR_CHIP_UNIT>(l_instance);
+            /*@
+            * @errortype          ERRORLOG::ERRL_SEV_UNRECOVERABLE
+            * @moduleid           fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
+            * @reasoncode         fapi2::RC_MCBIST_NO_PROC_FOUND
+            * @userdata1[0:31]    Expected Parent HUID
+            * @userdata1[32:63]   Actual Parent HUID
+            * @userdata2[0:31]    Instance of MCS
+            * @userdata2[32:63]   fapi2 Type of expected parent
+            * @devdesc            Could not find the parent PROC of this
+            *                     MCBIST target
+            */
+            l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
+                                          fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
+                                          fapi2::RC_MCBIST_NO_PROC_FOUND,
+                                          TWO_UINT32_TO_UINT64(
+                                          TO_UINT32(
+                                          TARGETING::get_huid(
+                                          l_nimbusProc)),
+                                          TO_UINT32(
+                                          TARGETING::get_huid(
+                                          l_tempTargetingParent))),
+                                          TWO_UINT32_TO_UINT64(
+                                          TO_UINT32(l_instance),
+                                          TO_UINT32(TARGET_TYPE_PROC_CHIP)),
+                                          true/*SW Error*/);
+            errlCommit(l_err,HWPF_COMP_ID);
+            TS_FAIL( "fapi2TargetTest::Unable to find MCBIST's PROC parent!");
+            numFails++;
+        }
+
+//         //Check PHB's parents
+        l_tempTargetingParent =
+            static_cast<TARGETING::Target*>(
+                fapi2_phbTarget.getParent<TARGET_TYPE_PROC_CHIP>());
+
+        numTests++;
+        if(TARGETING::get_huid(l_nimbusProc) !=
+           TARGETING::get_huid(l_tempTargetingParent))
+        {
+            uint8_t l_instance = 0;
+            targeting_targets[MY_PHB]->
+            tryGetAttr<TARGETING::ATTR_CHIP_UNIT>(l_instance);
+            /*@
+            * @errortype          ERRORLOG::ERRL_SEV_UNRECOVERABLE
+            * @moduleid           fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
+            * @reasoncode         fapi2::RC_PHB_NO_PROC_FOUND
+            * @userdata1[0:31]    Expected Parent HUID
+            * @userdata1[32:63]   Actual Parent HUID
+            * @userdata2[0:31]    Instance of PHB
+            * @userdata2[32:63]   fapi2 Type of expected parent
+            * @devdesc            Could not find the parent PROC of this
+            *                     PHB target
+            */
+            l_err = new ERRORLOG::ErrlEntry(
+                                ERRORLOG::ERRL_SEV_UNRECOVERABLE,
+                                fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
+                                fapi2::RC_PHB_NO_PROC_FOUND,
+                                TWO_UINT32_TO_UINT64(
+                                TO_UINT32(
+                                TARGETING::get_huid(
+                                l_nimbusProc)),
+                                TO_UINT32(
+                                TARGETING::get_huid(
+                                l_tempTargetingParent))),
+                                TWO_UINT32_TO_UINT64(
+                                TO_UINT32(l_instance),
+                                TO_UINT32(TARGET_TYPE_PROC_CHIP)),
+                                true/*SW Error*/);
+            errlCommit(l_err,HWPF_COMP_ID);
+            TS_FAIL( "fapi2TargetTest::Unable to find PHB's PROC parent!");
+            numFails++;
+        }
+
+        //Check PEC's parents
+
+        l_tempTargetingParent =
+            static_cast<TARGETING::Target*>(
+                fapi2_pecTarget.getParent<TARGET_TYPE_PROC_CHIP>());
+        numTests++;
+        if(TARGETING::get_huid(l_nimbusProc) !=
+           TARGETING::get_huid(l_tempTargetingParent))
+        {
+            uint8_t l_instance = 0;
+            targeting_targets[MY_PEC]->
+            tryGetAttr<TARGETING::ATTR_CHIP_UNIT>(l_instance);
+            /*@
+            * @errortype          ERRORLOG::ERRL_SEV_UNRECOVERABLE
+            * @moduleid           fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
+            * @reasoncode         fapi2::RC_PEC_NO_PROC_FOUND
+            * @userdata1[0:31]    Expected Parent HUID
+            * @userdata1[32:63]   Actual Parent HUID
+            * @userdata2[0:31]    Instance of PEC
+            * @userdata2[32:63]   fapi2 Type of expected parent
+            * @devdesc            Could not find the parent PROC of this
+            *                     PEC target
+            */
+            l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
+                                          fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
+                                          fapi2::RC_PEC_NO_PROC_FOUND,
+                                          TWO_UINT32_TO_UINT64(
+                                          TO_UINT32(
+                                          TARGETING::get_huid(
+                                          l_nimbusProc)),
+                                          TO_UINT32(
+                                          TARGETING::get_huid(
+                                          l_tempTargetingParent))),
+                                          TWO_UINT32_TO_UINT64(
+                                          TO_UINT32(l_instance),
+                                          TO_UINT32(TARGET_TYPE_PROC_CHIP)),
+                                          true/*SW Error*/);
+            errlCommit(l_err,HWPF_COMP_ID);
+            TS_FAIL( "fapi2TargetTest::Unable to find PEC's PROC parent!");
+            numFails++;
+        }
+
+        //Check XBUS's parents
+        l_tempTargetingParent =
+            static_cast<TARGETING::Target*>(
+                fapi2_xbusTarget.getParent<TARGET_TYPE_PROC_CHIP>());
+        numTests++;
+        if(TARGETING::get_huid(l_nimbusProc) !=
+           TARGETING::get_huid(l_tempTargetingParent))
+        {
+            uint8_t l_instance = 0;
+            targeting_targets[MY_XBUS]->
+            tryGetAttr<TARGETING::ATTR_CHIP_UNIT>(l_instance);
+            /*@
+            * @errortype          ERRORLOG::ERRL_SEV_UNRECOVERABLE
+            * @moduleid           fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
+            * @reasoncode         fapi2::RC_XBUS_NO_PROC_FOUND
+            * @userdata1[0:31]    Expected Parent HUID
+            * @userdata1[32:63]   Actual Parent HUID
+            * @userdata2[0:31]    Instance of XBUS
+            * @userdata2[32:63]   fapi2 Type of expected parent
+            * @devdesc            Could not find the parent PROC of this
+            *                     XBUS target
+            */
+            l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
+                                          fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
+                                          fapi2::RC_XBUS_NO_PROC_FOUND,
+                                          TWO_UINT32_TO_UINT64(
+                                          TO_UINT32(
+                                          TARGETING::get_huid(
+                                          l_nimbusProc)),
+                                          TO_UINT32(
+                                          TARGETING::get_huid(
+                                          l_tempTargetingParent))),
+                                          TWO_UINT32_TO_UINT64(
+                                          TO_UINT32(l_instance),
+                                          TO_UINT32(TARGET_TYPE_PROC_CHIP)),
+                                          true/*SW Error*/);
+            errlCommit(l_err,HWPF_COMP_ID);
+            TS_FAIL( "fapi2TargetTest::Unable to find XBUS's PROC parent!");
+            numFails++;
+        }
+
+        //Check OBUS's parents
+        l_tempTargetingParent =
+            static_cast<TARGETING::Target*>(
+                fapi2_obusTarget.getParent<TARGET_TYPE_PROC_CHIP>());
+        numTests++;
+        if(TARGETING::get_huid(l_nimbusProc) !=
+           TARGETING::get_huid(l_tempTargetingParent))
+        {
+            uint8_t l_instance = 0;
+            targeting_targets[MY_OBUS]->
+            tryGetAttr<TARGETING::ATTR_CHIP_UNIT>(l_instance);
+            /*@
+            * @errortype          ERRORLOG::ERRL_SEV_UNRECOVERABLE
+            * @moduleid           fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
+            * @reasoncode         fapi2::RC_OBUS_NO_PROC_FOUND
+            * @userdata1[0:31]    Expected Parent HUID
+            * @userdata1[32:63]   Actual Parent HUID
+            * @userdata2[0:31]    Instance of OBUS
+            * @userdata2[32:63]   fapi2 Type of expected parent
+            * @devdesc            Could not find the parent PROC of this
+            *                     OBUS target
+            */
+            l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
+                                          fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
+                                          fapi2::RC_OBUS_NO_PROC_FOUND,
+                                          TWO_UINT32_TO_UINT64(
+                                          TO_UINT32(
+                                          TARGETING::get_huid(
+                                          l_nimbusProc)),
+                                          TO_UINT32(
+                                          TARGETING::get_huid(
+                                          l_tempTargetingParent))),
+                                          TWO_UINT32_TO_UINT64(
+                                          TO_UINT32(l_instance),
+                                          TO_UINT32(TARGET_TYPE_PROC_CHIP)),
+                                          true/*SW Error*/);
+           errlCommit(l_err,HWPF_COMP_ID);
+           TS_FAIL( "fapi2TargetTest::Unable to find OBUS's PROC parent!");
+           numFails++;
+        }
+
+        //Check NVBUS's parents
+        l_tempTargetingParent =
+            static_cast<TARGETING::Target*>(
+                fapi2_nvbusTarget.getParent<TARGET_TYPE_PROC_CHIP>());
+        numTests++;
+        if(TARGETING::get_huid(l_nimbusProc) !=
+           TARGETING::get_huid(l_tempTargetingParent))
+        {
+            uint8_t l_instance = 0;
+            targeting_targets[MY_NVBUS]->
+            tryGetAttr<TARGETING::ATTR_CHIP_UNIT>(l_instance);
+            /*@
+            * @errortype          ERRORLOG::ERRL_SEV_UNRECOVERABLE
+            * @moduleid           fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
+            * @reasoncode         fapi2::RC_NVBUS_NO_PROC_FOUND
+            * @userdata1[0:31]    Expected Parent HUID
+            * @userdata1[32:63]   Actual Parent HUID
+            * @userdata2[0:31]    Instance of NVBUS
+            * @userdata2[32:63]   fapi2 Type of expected parent
+            * @devdesc            Could not find the parent PROC of this
+            *                     NVBUS target
+            */
+            l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
+                                          fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
+                                          fapi2::RC_NVBUS_NO_PROC_FOUND,
+                                          TWO_UINT32_TO_UINT64(
+                                          TO_UINT32(
+                                          TARGETING::get_huid(
+                                          l_nimbusProc)),
+                                          TO_UINT32(
+                                          TARGETING::get_huid(
+                                          l_tempTargetingParent))),
+                                          TWO_UINT32_TO_UINT64(
+                                          TO_UINT32(l_instance),
+                                          TO_UINT32(TARGET_TYPE_PROC_CHIP)),
+                                          true/*SW Error*/);
+            errlCommit(l_err,HWPF_COMP_ID);
+            TS_FAIL( "fapi2TargetTest::Unable to find NVBUS's PROC parent!");
+            numFails++;
+        }
+
+        //Check PPE's parents
+        l_tempTargetingParent =
+            static_cast<TARGETING::Target*>(
+                fapi2_ppeTarget.getParent<TARGET_TYPE_PROC_CHIP>());
+        numTests++;
+        if(TARGETING::get_huid(l_nimbusProc) !=
+           TARGETING::get_huid(l_tempTargetingParent))
+        {
+            uint8_t l_instance = 0;
+            targeting_targets[MY_PPE]->
+            tryGetAttr<TARGETING::ATTR_CHIP_UNIT>(l_instance);
+            /*@
+            * @errortype          ERRORLOG::ERRL_SEV_UNRECOVERABLE
+            * @moduleid           fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
+            * @reasoncode         fapi2::RC_PPE_NO_PROC_FOUND
+            * @userdata1[0:31]    Expected Parent HUID
+            * @userdata1[32:63]   Actual Parent HUID
+            * @userdata2[0:31]    Instance of PPE
+            * @userdata2[32:63]   fapi2 Type of expected parent
+            * @devdesc            Could not find the parent PROC of this
+            *                     PPE target
+            */
+            l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
+                                          fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
+                                          fapi2::RC_PPE_NO_PROC_FOUND,
+                                          TWO_UINT32_TO_UINT64(
+                                          TO_UINT32(
+                                          TARGETING::get_huid(
+                                          l_nimbusProc)),
+                                          TO_UINT32(
+                                          TARGETING::get_huid(
+                                          l_tempTargetingParent))),
+                                          TWO_UINT32_TO_UINT64(
+                                          TO_UINT32(l_instance),
+                                          TO_UINT32(TARGET_TYPE_PROC_CHIP)),
+                                          true/*SW Error*/);
+            errlCommit(l_err,HWPF_COMP_ID);
+            TS_FAIL( "fapi2TargetTest::Unable to find PPE's PROC parent!");
+            numFails++;
+        }
+
+        //Check PERV's parents
+        l_tempTargetingParent =
+            static_cast<TARGETING::Target*>(
+                fapi2_pervTarget.getParent<TARGET_TYPE_PROC_CHIP>());
+        numTests++;
+        if(TARGETING::get_huid(l_nimbusProc) !=
+           TARGETING::get_huid(l_tempTargetingParent))
+        {
+            uint8_t l_instance = 0;
+            targeting_targets[MY_PERV]->
+              tryGetAttr<TARGETING::ATTR_CHIP_UNIT>(l_instance);
+            /*@
+            * @errortype          ERRORLOG::ERRL_SEV_UNRECOVERABLE
+            * @moduleid           fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
+            * @reasoncode         fapi2::RC_PERV_NO_PROC_FOUND
+            * @userdata1[0:31]    Expected Parent HUID
+            * @userdata1[32:63]   Actual Parent HUID
+            * @userdata2[0:31]    Instance of PERV
+            * @userdata2[32:63]   fapi2 Type of expected parent
+            * @devdesc            Could not find the parent PROC of this
+            *                     PERV target
+            */
+            l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
+                                          fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
+                                          fapi2::RC_PERV_NO_PROC_FOUND,
+                                          TWO_UINT32_TO_UINT64(
+                                          TO_UINT32(
+                                          TARGETING::get_huid(
+                                          l_nimbusProc)),
+                                          TO_UINT32(
+                                          TARGETING::get_huid(
+                                          l_tempTargetingParent))),
+                                          TWO_UINT32_TO_UINT64(
+                                          TO_UINT32(l_instance),
+                                          TO_UINT32(TARGET_TYPE_PROC_CHIP)),
+                                          true/*SW Error*/);
+           errlCommit(l_err,HWPF_COMP_ID);
+           TS_FAIL( "fapi2TargetTest::Unable to find PERV's PROC parent!");
+           numFails++;
+        }
+
+        //Check CAPP's parents
+        l_tempTargetingParent =
+            static_cast<TARGETING::Target*>(
+                fapi2_cappTarget.getParent<TARGET_TYPE_PROC_CHIP>());
+        numTests++;
+        if(TARGETING::get_huid(l_nimbusProc) !=
+           TARGETING::get_huid(l_tempTargetingParent))
+        {
+            uint8_t l_instance = 0;
+            targeting_targets[MY_CAPP]->
+              tryGetAttr<TARGETING::ATTR_CHIP_UNIT>(l_instance);
+            /*@
+            * @errortype          ERRORLOG::ERRL_SEV_UNRECOVERABLE
+            * @moduleid           fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
+            * @reasoncode         fapi2::RC_CAPP_NO_PROC_FOUND
+            * @userdata1[0:31]    Expected Parent HUID
+            * @userdata1[32:63]   Actual Parent HUID
+            * @userdata2[0:31]    Instance of CAPP
+            * @userdata2[32:63]   fapi2 Type of expected parent
+            * @devdesc            Could not find the parent PROC of this
+            *                     CAPP target
+            */
+            l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
+                                          fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
+                                          fapi2::RC_CAPP_NO_PROC_FOUND,
+                                          TWO_UINT32_TO_UINT64(
+                                          TO_UINT32(
+                                          TARGETING::get_huid(
+                                          l_nimbusProc)),
+                                          TO_UINT32(
+                                          TARGETING::get_huid(
+                                          l_tempTargetingParent))),
+                                          TWO_UINT32_TO_UINT64(
+                                          TO_UINT32(l_instance),
+                                          TO_UINT32(TARGET_TYPE_PROC_CHIP)),
+                                          true/*SW Error*/);
+           errlCommit(l_err,HWPF_COMP_ID);
+           TS_FAIL( "fapi2TargetTest::Unable to find CAPP's PROC parent!");
+           numFails++;
+        }
+
+        //Check SBE's parents
+        l_tempTargetingParent =
+            static_cast<TARGETING::Target*>(
+                fapi2_sbeTarget.getParent<TARGET_TYPE_PROC_CHIP>());
+        numTests++;
+        if(TARGETING::get_huid(l_nimbusProc) !=
+           TARGETING::get_huid(l_tempTargetingParent))
+        {
+            uint8_t l_instance = 0;
+            targeting_targets[MY_SBE]->
+            tryGetAttr<TARGETING::ATTR_CHIP_UNIT>(l_instance);
+            /*@
+            * @errortype          ERRORLOG::ERRL_SEV_UNRECOVERABLE
+            * @moduleid           fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST
+            * @reasoncode         fapi2::RC_SBE_NO_PROC_FOUND
+            * @userdata1[0:31]    Expected Parent HUID
+            * @userdata1[32:63]   Actual Parent HUID
+            * @userdata2[0:31]    Instance of SBE
+            * @userdata2[32:63]   fapi2 Type of expected parent
+            * @devdesc            Could not find the parent PROC of this
+            *                     SBE target
+            */
+            l_err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
+                                          fapi2::MOD_FAPI2_PLAT_GET_PARENT_TEST,
+                                          fapi2::RC_SBE_NO_PROC_FOUND,
+                                          TWO_UINT32_TO_UINT64(
+                                          TO_UINT32(
+                                          TARGETING::get_huid(
+                                          l_nimbusProc)),
+                                          TO_UINT32(
+                                          TARGETING::get_huid(
+                                          l_tempTargetingParent))),
+                                          TWO_UINT32_TO_UINT64(
+                                          TO_UINT32(l_instance),
+                                          TO_UINT32(TARGET_TYPE_PROC_CHIP)),
+                                          true/*SW Error*/);
+            errlCommit(l_err,HWPF_COMP_ID);
+            TS_FAIL( "fapi2TargetTest::UnAble to find SBE's PROC parent!");
+            numFails++;
+        }
+
+    }while(0);
+    FAPI_INF("fapi2TargetTest:: Test Complete. %d/%d fails", numTests, numFails);
+    return l_err;
+}
+
+
+
+
+}
\ No newline at end of file
diff --git a/src/usr/fapi2/test/fapi2Test.H b/src/usr/fapi2/test/fapi2Test.H
index 1111ec9c9..366921dbb 100644
--- a/src/usr/fapi2/test/fapi2Test.H
+++ b/src/usr/fapi2/test/fapi2Test.H
@@ -44,6 +44,7 @@
 #include <fapi2TestUtils.H>
 #include <hwpf_fapi2_reasoncodes.H>
 
+#include "fapi2GetParentTest.C"
 #include "fapi2HwpTest.C"
 #include "fapi2GetChildrenTest.C"
 
@@ -60,6 +61,8 @@ public:
 */
 void test_fapi2Test(void)
 {
+    FAPI_INF(">>>>>>test_fapi2Test starting...");
+
     FAPI_INF(">>test_fapi2HwpTest starting...");
     fapi2HwpTest();
     FAPI_INF("<<test_fapi2HwpTest exiting...");
@@ -67,6 +70,12 @@ void test_fapi2Test(void)
     FAPI_INF(">>test_fapi2GetChildrenTest starting...");
     fapi2GetChildrenTest();
     FAPI_INF("<<test_fapi2ChildTest exiting...");
+
+    FAPI_INF(">>fapi2TargetTest::testFapi2GetParent starting...");
+    fapi2GetParentTest();
+    FAPI_INF("<<FAPI2: testFapi2GetParent exiting...");
+
+    FAPI_INF("<<<<<<test_fapi2Test exiting...");
 }
 
 };
diff --git a/src/usr/targeting/common/utilFilter.C b/src/usr/targeting/common/utilFilter.C
index 4783d12ee..aeca62ad3 100644
--- a/src/usr/targeting/common/utilFilter.C
+++ b/src/usr/targeting/common/utilFilter.C
@@ -5,7 +5,7 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2012,2015                        */
+/* Contributors Listed Below - COPYRIGHT 2012,2016                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
 /*                                                                        */
@@ -429,6 +429,34 @@ const Target * getParentChip( const Target * i_pChiplet )
     return l_pChip;
 }
 
+const Target * getParent( const Target * i_unit , TARGETING::TYPE &i_pType)
+{
+    const Target * l_parent = NULL;
+    TARGETING::PredicateCTM l_predicate;
+
+    l_predicate.setType(i_pType);
+
+    // Create a vector of TARGETING::Target pointers
+    TARGETING::TargetHandleList l_chipList;
+
+    // Get parent
+    TARGETING::targetService().getAssociated(l_chipList, i_unit,
+                          TARGETING::TargetService::PARENT,
+                          TARGETING::TargetService::ALL, &l_predicate);
+
+    if (l_chipList.size() == 1)
+    {
+        l_parent = l_chipList[0];
+    }
+    else
+    {
+        TARG_ERR("Number of Parent chip is not 1, but %d",l_chipList.size());
+    }
+
+    return l_parent;
+}
+
+
 const Target * getExChiplet( const Target * i_pCoreChiplet )
 {
     const Target * l_pExChiplet = NULL;
diff --git a/src/usr/targeting/common/xmltohb/simics_NIMBUS.system.xml b/src/usr/targeting/common/xmltohb/simics_NIMBUS.system.xml
index ec0efabff..5c92ce454 100644
--- a/src/usr/targeting/common/xmltohb/simics_NIMBUS.system.xml
+++ b/src/usr/targeting/common/xmltohb/simics_NIMBUS.system.xml
@@ -2554,7 +2554,7 @@
     </attribute>
     <attribute>
         <id>AFFINITY_PATH</id>
-        <default>physical:sys-0/node-0/proc-0/capp-0</default>
+        <default>affinity:sys-0/node-0/proc-0/capp-0</default>
     </attribute>
     <attribute>
         <id>CHIP_UNIT</id>
@@ -2572,7 +2572,7 @@
     </attribute>
     <attribute>
         <id>AFFINITY_PATH</id>
-        <default>physical:sys-0/node-0/proc-0/capp-1</default>
+        <default>affinity:sys-0/node-0/proc-0/capp-1</default>
     </attribute>
     <attribute>
         <id>CHIP_UNIT</id>