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>

5 files changed, 998 insertions, 3 deletions

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>