Add getChipletNumber to Target Class

Chiplet Ids are as follows:
    - EQ 0-5     Ids: 0x10 - 0x15
    - EX 0-11    Ids: 0x10, 0x10, 0x11, 0x11, --- (parent's id)
    - Cores 0-23 Ids: 0x20 - 0x37
    - Pervasive  Id:  0x01
    - Xbus       Id:  0x06
    - Mcbist 0-1 Ids: 0x07 - 0x08
    - Mcs 0-3    Ids: 0x07, 0x07, 0x08, 0x08 (parent's id)
    - Mca 0-3    Ids: 0x07, 0x07, 0x07, 0x07 (parent's id)
    - Mca 4-7    Ids: 0x08, 0x08, 0x08, 0x08 (parent's id)
    - Obus0      Id:  0x09
    - Obus3      Id:  0x0C

Change-Id: I89be032654c191b8930fac07a1b64061e381fe14
RTC: 156120
Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/27339
Tested-by: Jenkins Server <pfd-jenkins+hostboot@us.ibm.com>
Reviewed-by: Christian R. Geddes <crgeddes@us.ibm.com>
Tested-by: FSP CI Jenkins <fsp-CI-jenkins+hostboot@us.ibm.com>
Reviewed-by: Daniel M. Crowell <dcrowell@us.ibm.com>

2 files changed, 628 insertions, 6 deletions

diff --git a/src/usr/fapi2/test/fapi2GetChipletNumTest.H b/src/usr/fapi2/test/fapi2GetChipletNumTest.H
new file mode 100644
index 000000000..970b5bcf0
--- /dev/null
+++ b/src/usr/fapi2/test/fapi2GetChipletNumTest.H
@@ -0,0 +1,606 @@
+/* IBM_PROLOG_BEGIN_TAG                                                   */
+/* This is an automatically generated prolog.                             */
+/*                                                                        */
+/* $Source: src/usr/fapi2/test/fapi2GetChipletNumTest.H $                 */
+/*                                                                        */
+/* OpenPOWER HostBoot Project                                             */
+/*                                                                        */
+/* Contributors Listed Below - COPYRIGHT 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 <fapi2.H>
+#include <commontargeting.H>
+#include <cxxtest/TestSuite.H>
+#include "fapi2TestUtils.H"
+
+
+namespace fapi2
+{
+
+class Fapi2GetChipletNum : public CxxTest::TestSuite
+{
+    public:
+
+    void testVerifyMcbistChipletNum()
+    {
+        uint8_t  l_chiplet_id = 0;
+        uint8_t  l_exp_chiplet_id = 0;
+        uint8_t  chipUnit = 0;
+
+        FAPI_INF ("Start testVerifyMcbistChipletNum");
+        do
+        {
+            // find the unit
+            TARGETING::Target * pSys;
+            TARGETING::targetService().getTopLevelTarget(pSys);
+            TARGETING::PredicateCTM predMcbist(TARGETING::CLASS_UNIT,
+                    TARGETING::TYPE_MCBIST);
+
+            TARGETING::TargetHandleList pMcbistList;
+            TARGETING::targetService().getAssociated( pMcbistList, pSys,
+                    TARGETING::TargetService::CHILD,
+                    TARGETING::TargetService::ALL,
+                    &predMcbist);
+
+            if (pMcbistList.empty())
+            {
+                TS_FAIL("testVerifyMcbistChipletNum: empty pMcbistList");
+                break;
+            }
+
+            // Iterate through present procs
+            for (TARGETING::TargetHandleList::const_iterator
+                 l_mcbistIter = pMcbistList.begin();
+                 l_mcbistIter != pMcbistList.end();
+                 ++l_mcbistIter)
+            {
+
+                TARGETING::Target * pTarTarget = *l_mcbistIter;
+
+                // map Targeting Type to fapi2 Type
+                Target<fapi2::TARGET_TYPE_MCBIST> fapi2_Target( pTarTarget);
+                l_chiplet_id = fapi2_Target.getChipletNumber();
+
+                FAPI_DBG("testVerifyMcbistChipletNum HUID: %.8X, ChipletId: %.8X",
+                    TARGETING::get_huid(pTarTarget), l_chiplet_id);
+
+                chipUnit = pTarTarget->getAttr<TARGETING::ATTR_CHIP_UNIT>();
+                l_exp_chiplet_id = chipUnit + START_MCBIST_CHIPLET_NUM;
+
+                if (l_chiplet_id != l_exp_chiplet_id)
+                {
+                    TS_FAIL("testVerifyMcbistChipletNum: Mismatch - Expected: %.8X:, Found: %.8X",
+                         l_exp_chiplet_id, l_chiplet_id);
+                    break;
+                }
+            }
+        } while(0);
+        FAPI_INF("Complete testVerifyMcbistChipletNum");
+    }
+
+    void testVerifyMcsChipletNum()
+    {
+        uint8_t  l_chiplet_id = 0;
+        uint8_t  l_exp_chiplet_id = 0;
+
+        FAPI_INF("Start testVerifyMcsChipletNum");
+        do
+        {
+            // find the unit
+            TARGETING::Target * pSys;
+            TARGETING::targetService().getTopLevelTarget(pSys);
+            TARGETING::PredicateCTM predMcs(TARGETING::CLASS_UNIT,
+                    TARGETING::TYPE_MCS);
+
+            TARGETING::TargetHandleList pMcsList;
+            TARGETING::targetService().getAssociated( pMcsList, pSys,
+                    TARGETING::TargetService::CHILD,
+                    TARGETING::TargetService::ALL,
+                    &predMcs);
+
+            if (pMcsList.empty())
+            {
+                TS_FAIL("testVerifyMcsChipletNum: empty pMcsList");
+                break;
+            }
+
+            // Iterate through present procs
+            for (TARGETING::TargetHandleList::const_iterator
+                 l_mcsIter = pMcsList.begin();
+                 l_mcsIter != pMcsList.end();
+                 ++l_mcsIter)
+            {
+                TARGETING::Target * pTarTarget = *l_mcsIter;
+
+                // map Targeting Type to fapi2 Type
+                Target<fapi2::TARGET_TYPE_MCS> fapi2_Target(pTarTarget);
+                l_chiplet_id = fapi2_Target.getChipletNumber();
+
+                FAPI_DBG("testVerifyMcsChipletNum HUID: %.8X, ChipletId: %.8X",
+                    TARGETING::get_huid(pTarTarget),
+                    l_chiplet_id);
+
+                ReturnCode l_rc;
+                fapi2::ATTR_CHIP_UNIT_POS_Type chipPos = 0;
+                l_rc = FAPI_ATTR_GET(fapi2::ATTR_CHIP_UNIT_POS,
+                            pTarTarget,chipPos);
+                if( l_rc )
+                {
+                    TS_FAIL("testVerifyMcsChipletNum: Error getting fapi::ATTR_CHIP_UNIT_POS");
+                    break;
+                }
+
+                l_exp_chiplet_id = (chipPos/2) + START_MCBIST_CHIPLET_NUM;
+
+                if (l_chiplet_id != l_exp_chiplet_id)
+                {
+                    TS_FAIL("testVerifyMcsChipletNum: Mismatch - Expected: %.8X:, Found: %.8X",
+                         l_exp_chiplet_id, l_chiplet_id);
+                    break;
+                }
+            }
+        } while(0);
+        FAPI_INF("Complete testVerifyMcsChipletNum");
+    }
+
+    void testVerifyMcaChipletNum()
+    {
+        uint8_t  l_chiplet_id = 0;
+        uint8_t  l_exp_chiplet_id = 0;
+        uint8_t  chipUnit = 0;
+
+        FAPI_INF("Start testVerifyMcaChipletNum");
+        do
+        {
+            // find the unit
+            TARGETING::Target * pSys;
+            TARGETING::targetService().getTopLevelTarget(pSys);
+            TARGETING::PredicateCTM predMca(TARGETING::CLASS_UNIT,
+                    TARGETING::TYPE_MCA);
+
+            TARGETING::TargetHandleList pMcaistList;
+            TARGETING::targetService().getAssociated( pMcaistList, pSys,
+                    TARGETING::TargetService::CHILD,
+                    TARGETING::TargetService::ALL,
+                    &predMca);
+
+            if (pMcaistList.empty())
+            {
+                TS_FAIL("testVerifyMcaChipletNum: empty pMcbistList");
+                break;
+            }
+
+            // Iterate through present procs
+            for (TARGETING::TargetHandleList::const_iterator
+                 l_mcaistIter = pMcaistList.begin();
+                 l_mcaistIter != pMcaistList.end();
+                 ++l_mcaistIter)
+            {
+
+                TARGETING::Target * pTarTarget = *l_mcaistIter;
+
+                // map Targeting Type to fapi2 Type
+                Target<fapi2::TARGET_TYPE_MCBIST> fapi2_Target( pTarTarget);
+                l_chiplet_id = fapi2_Target.getChipletNumber();
+
+                FAPI_DBG("testVerifyMcaChipletNum HUID: %.8X, ChipletId: %.8X",
+                    TARGETING::get_huid(pTarTarget), l_chiplet_id);
+
+                chipUnit = pTarTarget->getAttr<TARGETING::ATTR_CHIP_UNIT>();
+                l_exp_chiplet_id = chipUnit / 4 + START_MCBIST_CHIPLET_NUM;
+
+                if (l_chiplet_id != l_exp_chiplet_id)
+                {
+                    TS_FAIL("testVerifyMcaChipletNum: Mismatch - Expected: %.8X:, Found: %.8X",
+                         l_exp_chiplet_id, l_chiplet_id);
+                    break;
+                }
+            }
+        } while(0);
+        FAPI_INF("Complete testVerifyMcaChipletNum");
+    }
+
+    void testVerifyObusChipletNum()
+    {
+        uint8_t  l_chiplet_id = 0;
+        uint8_t  l_exp_chiplet_id = 0;
+        uint8_t  chipUnit = 0;
+
+        FAPI_INF("Start testVerifyObusChipletNum");
+        do
+        {
+            // find the unit
+            TARGETING::Target * pSys;
+            TARGETING::targetService().getTopLevelTarget(pSys);
+            TARGETING::PredicateCTM predObus(TARGETING::CLASS_UNIT,
+                    TARGETING::TYPE_OBUS);
+
+            TARGETING::TargetHandleList pObusList;
+            TARGETING::targetService().getAssociated( pObusList, pSys,
+                    TARGETING::TargetService::CHILD,
+                    TARGETING::TargetService::ALL,
+                    &predObus);
+
+            if (pObusList.empty())
+            {
+                TS_FAIL("testVerifyObusChipletNum: empty pObusList");
+                break;
+            }
+
+            // Iterate through present procs
+            for (TARGETING::TargetHandleList::const_iterator
+                 l_obusIter = pObusList.begin();
+                 l_obusIter != pObusList.end();
+                 ++l_obusIter)
+            {
+                TARGETING::Target * pTarTarget = *l_obusIter;
+
+                // map Targeting Type to fapi2 Type
+                Target<fapi2::TARGET_TYPE_OBUS> fapi2_Target( pTarTarget);
+                l_chiplet_id = fapi2_Target.getChipletNumber();
+
+                FAPI_DBG("testVerifyObusChipletNum HUID: %.8X, ChipletId: %.8X",
+                    TARGETING::get_huid(pTarTarget),
+                    l_chiplet_id);
+
+                ReturnCode l_rc;
+                fapi2::ATTR_CHIP_UNIT_POS_Type chipPos = 0;
+                l_rc = FAPI_ATTR_GET(fapi2::ATTR_CHIP_UNIT_POS,
+                            pTarTarget,chipPos);
+                if( l_rc )
+                {
+                    TS_FAIL("testVerifyObusChipletNum: Error getting fapi::ATTR_CHIP_UNIT_POS");
+                    break;
+                }
+
+                // Nimbus has two obuses 0 & 3
+                chipUnit = pTarTarget->getAttr<TARGETING::ATTR_CHIP_UNIT>();
+                l_exp_chiplet_id = chipUnit + START_OBUS_CHIPLET_NUM;
+
+                if (l_chiplet_id != l_exp_chiplet_id)
+                {
+                    TS_FAIL("testVerifyObusChipletNum: Mismatch - Expected: %.8X:, Found: %.8X",
+                         l_exp_chiplet_id, l_chiplet_id);
+                    break;
+                }
+            }
+        } while(0);
+        FAPI_INF("Complete testVerifyObusChipletNum");
+    }
+
+    void testVerifyXbusChipletNum()
+    {
+        uint8_t  l_chiplet_id = 0;
+
+        FAPI_INF("Start testVerifyXbusChipletNum");
+        do
+        {
+            // find the unit
+            TARGETING::Target * pSys;
+            TARGETING::targetService().getTopLevelTarget(pSys);
+            TARGETING::PredicateCTM predXbus(TARGETING::CLASS_UNIT,
+                    TARGETING::TYPE_XBUS);
+
+            TARGETING::TargetHandleList pXbusList;
+            TARGETING::targetService().getAssociated( pXbusList, pSys,
+                    TARGETING::TargetService::CHILD,
+                    TARGETING::TargetService::ALL,
+                    &predXbus);
+
+            if (pXbusList.empty())
+            {
+                TS_FAIL("testVerifyXbusChipletNum: empty pXbusList");
+                break;
+            }
+
+            // Iterate through present procs
+            for (TARGETING::TargetHandleList::const_iterator
+                 l_xbusIter = pXbusList.begin();
+                 l_xbusIter != pXbusList.end();
+                 ++l_xbusIter)
+            {
+                TARGETING::Target * pTarTarget = *l_xbusIter;
+
+                // map Targeting Type to fapi2 Type
+                Target<fapi2::TARGET_TYPE_XBUS> fapi2_Target( pTarTarget);
+                l_chiplet_id = fapi2_Target.getChipletNumber();
+
+                FAPI_DBG("testVerifyXbusChipletNum HUID: %.8X, ChipletId: %.8X",
+                    TARGETING::get_huid(pTarTarget),
+                    l_chiplet_id);
+
+                if (l_chiplet_id != START_XBUS_CHIPLET_NUM)
+                {
+                    TS_FAIL("testVerifyXbusChipletNum: Mismatch - Expected: %.8X:, Found: %.8X",
+                         START_XBUS_CHIPLET_NUM, l_chiplet_id);
+                    break;
+                }
+            }
+        } while(0);
+        FAPI_INF("Complete testVerifyXbusChipletNum");
+    }
+    void testVerifyPervChipletNum()
+    {
+        uint8_t  l_chiplet_id = 0;
+        uint8_t  chipUnit = 0;
+
+        FAPI_INF("Start testVerifyPervChipletNum");
+        do
+        {
+            // find the unit
+            TARGETING::Target * pSys;
+            TARGETING::targetService().getTopLevelTarget(pSys);
+            TARGETING::PredicateCTM predPerv(TARGETING::CLASS_UNIT,
+                    TARGETING::TYPE_PERV);
+
+            TARGETING::TargetHandleList pPervList;
+            TARGETING::targetService().getAssociated( pPervList, pSys,
+                    TARGETING::TargetService::CHILD,
+                    TARGETING::TargetService::ALL,
+                    &predPerv );
+
+            if (pPervList.empty())
+            {
+                TS_FAIL("testVerifyPervChipletNum: empty pPervList");
+                break;
+            }
+
+            // Iterate through present procs
+            for (TARGETING::TargetHandleList::const_iterator
+                 l_pervIter = pPervList.begin();
+                 l_pervIter != pPervList.end();
+                 ++l_pervIter)
+            {
+                TARGETING::Target * pTarTarget = *l_pervIter;
+
+                // map Targeting Type to fapi2 Type
+                Target<fapi2::TARGET_TYPE_PERV> fapi2_Target( pTarTarget);
+                l_chiplet_id = fapi2_Target.getChipletNumber();
+
+                FAPI_DBG("testVerifyPervChipletNum HUID: %.8X, ChipletId: %.8X",
+                    TARGETING::get_huid(pTarTarget),
+                    l_chiplet_id);
+
+                chipUnit = pTarTarget->getAttr<TARGETING::ATTR_CHIP_UNIT>();
+
+                if (l_chiplet_id != chipUnit)
+                {
+                    TS_FAIL("testVerifyPervChipletNum: Mismatch - Expected: %.8X:, Found: %.8X",
+                         chipUnit, l_chiplet_id);
+                    break;
+                }
+            }
+        } while(0);
+        FAPI_INF("Complete testVerifyPervChipletNum");
+    }
+
+    void testVerifyEQChipletNum()
+    {
+        uint8_t  l_chiplet_id = 0;
+        uint8_t  l_exp_chiplet_id = 0;
+        uint8_t  chipUnit = 0;
+
+        FAPI_INF("Start testVerifyEQChipletNum");
+        do
+        {
+            // find the unit
+            TARGETING::Target * pSys;
+            TARGETING::targetService().getTopLevelTarget(pSys);
+            TARGETING::PredicateCTM predEq(TARGETING::CLASS_UNIT,
+                    TARGETING::TYPE_EQ);
+
+            TARGETING::TargetHandleList pEqList;
+            TARGETING::targetService().getAssociated( pEqList, pSys,
+                    TARGETING::TargetService::CHILD,
+                    TARGETING::TargetService::ALL,
+                    &predEq );
+
+            if (pEqList.empty())
+            {
+                TS_FAIL("testVerifyEQChipletNum: empty pEqList");
+                break;
+            }
+
+            // Iterate through present procs
+            for (TARGETING::TargetHandleList::const_iterator
+                 l_eqIter = pEqList.begin();
+                 l_eqIter != pEqList.end();
+                 ++l_eqIter)
+            {
+                TARGETING::Target * pTarTarget = *l_eqIter;
+
+                // map Targeting Type to fapi2 Type
+                Target<fapi2::TARGET_TYPE_EQ> fapi2_Target( pTarTarget);
+                l_chiplet_id = fapi2_Target.getChipletNumber();
+
+                FAPI_DBG("testVerifyEQChipletNum HUID: %.8X, ChipletId: %.8X",
+                    TARGETING::get_huid(pTarTarget),
+                    l_chiplet_id);
+
+                chipUnit = pTarTarget->getAttr<TARGETING::ATTR_CHIP_UNIT>();
+                l_exp_chiplet_id = chipUnit + START_EQ_CHIPLET_NUM;
+
+                if (l_chiplet_id != l_exp_chiplet_id)
+                {
+                    TS_FAIL("testVerifyEQChipletNum: Mismatch - Expected: %.8X:, Found: %.8X",
+                         l_exp_chiplet_id, l_chiplet_id);
+                    break;
+                }
+            }
+        } while(0);
+        FAPI_INF("Complete testVerifyEQChipletNum");
+    }
+
+    void testVerifyEXChipletNum()
+    {
+        uint8_t  l_chiplet_id = 0;
+        uint8_t  l_exp_chiplet_id = 0;
+
+        FAPI_INF("Start testVerifyEXChipletNum");
+        do
+        {
+            // find the unit
+            TARGETING::Target * pSys;
+            TARGETING::targetService().getTopLevelTarget(pSys);
+            TARGETING::PredicateCTM predEx(TARGETING::CLASS_UNIT,
+                    TARGETING::TYPE_EX);
+
+            TARGETING::TargetHandleList pExList;
+            TARGETING::targetService().getAssociated( pExList, pSys,
+                    TARGETING::TargetService::CHILD,
+                    TARGETING::TargetService::ALL,
+                    &predEx );
+
+            if (pExList.empty())
+            {
+                TS_FAIL("testVerifyEXChipletNum: empty pExList");
+                break;
+            }
+
+            // Iterate through present procs
+            for (TARGETING::TargetHandleList::const_iterator
+                 l_exIter = pExList.begin();
+                 l_exIter != pExList.end();
+                 ++l_exIter)
+            {
+                TARGETING::Target * pTarTarget = *l_exIter;
+
+                // map Targeting Type to fapi2 Type
+                Target<fapi2::TARGET_TYPE_EX> fapi2_Target( pTarTarget);
+                l_chiplet_id = fapi2_Target.getChipletNumber();
+
+                FAPI_DBG("testVerifyEXChipletNum HUID: %.8X, ChipletId: %.8X",
+                    TARGETING::get_huid(pTarTarget),
+                    l_chiplet_id);
+
+                ReturnCode l_rc;
+                fapi2::ATTR_CHIP_UNIT_POS_Type chipPos = 0;
+                l_rc = FAPI_ATTR_GET(fapi2::ATTR_CHIP_UNIT_POS,
+                            pTarTarget,chipPos);
+                if( l_rc )
+                {
+                    TS_FAIL("testVerifyEXChipletNum: Error getting fapi::ATTR_CHIP_UNIT_POS");
+                    break;
+                }
+
+                l_exp_chiplet_id = (chipPos/2) + START_EQ_CHIPLET_NUM;
+
+                if (l_chiplet_id != l_exp_chiplet_id)
+                {
+                    TS_FAIL("testVerifyEXChipletNum: Mismatch - Expected: %.8X:, Found: %.8X",
+                         l_exp_chiplet_id, l_chiplet_id);
+                    break;
+                }
+            }
+        } while(0);
+        FAPI_INF("Complete testVerifyEXChipletNum");
+    }
+
+    void testVerifyCoreChipletNum()
+    {
+        FAPI_INF("Start testVerifyCoreChipletNum");
+
+        uint8_t  l_chiplet_id = 0;
+        uint8_t  l_exp_chiplet_id = 0;
+        uint8_t  chipUnit = 0;
+
+        do
+        {
+            // find the unit
+            TARGETING::Target * pSys;
+            TARGETING::targetService().getTopLevelTarget(pSys);
+            TARGETING::PredicateCTM predCore(TARGETING::CLASS_UNIT,
+                    TARGETING::TYPE_CORE);
+
+            TARGETING::TargetHandleList pCoreList;
+            TARGETING::targetService().getAssociated( pCoreList, pSys,
+                    TARGETING::TargetService::CHILD,
+                    TARGETING::TargetService::ALL,
+                    &predCore );
+
+            if (pCoreList.empty())
+            {
+                TS_FAIL("testVerifyCoreChipletNum: empty pCoreList");
+                break;
+            }
+
+            // Iterate through present cores
+            for (TARGETING::TargetHandleList::const_iterator
+                 l_coreIter = pCoreList.begin();
+                 l_coreIter != pCoreList.end();
+                 ++l_coreIter)
+            {
+                TARGETING::Target * pTarTarget = *l_coreIter;
+
+                // map Targeting Type to fapi2 Type
+                Target<fapi2::TARGET_TYPE_CORE> fapi2_Target( pTarTarget);
+                l_chiplet_id = fapi2_Target.getChipletNumber();
+
+                FAPI_DBG("testVerifyCoreChipletNum HUID: %.8X, ChipletId: %.8X",
+                    TARGETING::get_huid(pTarTarget),
+                    l_chiplet_id);
+
+                chipUnit = pTarTarget->getAttr<TARGETING::ATTR_CHIP_UNIT>();
+                l_exp_chiplet_id = chipUnit + START_CORE_CHIPLET_NUM;
+
+                if (l_chiplet_id != l_exp_chiplet_id)
+                {
+                    TS_FAIL("testVerifyCoreChipletNum: Mismatch - Expected: %.8X:, Found: %.8X",
+                         l_exp_chiplet_id, l_chiplet_id);
+                    break;
+                }
+            }
+        } while(0);
+        FAPI_INF("Complete testVerifyCoreChipletNum");
+    }
+
+    //**************************************************************************
+    // test_fapi2GetChipletNum
+    //**************************************************************************
+    void test_fapi2ChipletNum()
+    {
+
+        FAPI_DBG("Enter test_fapi2GetChipletNum");
+        do
+        {
+
+            testVerifyEQChipletNum();
+
+            testVerifyEXChipletNum();
+
+            testVerifyCoreChipletNum();
+
+            testVerifyPervChipletNum();
+
+            testVerifyXbusChipletNum();
+
+            testVerifyObusChipletNum();
+
+            testVerifyMcbistChipletNum();
+
+            testVerifyMcsChipletNum();
+
+            testVerifyMcaChipletNum();
+
+        } while(0);
+        FAPI_DBG("test_fapi2ChipletNum Test Complete.");
+    } // end test_fapi2ChipletNum()
+
+}; // end class
+
+}// end namespace fapi2
+
diff --git a/src/usr/fapi2/test/fapi2TestUtils.H b/src/usr/fapi2/test/fapi2TestUtils.H
index 21ba562d7..ccc90146d 100644
--- a/src/usr/fapi2/test/fapi2TestUtils.H
+++ b/src/usr/fapi2/test/fapi2TestUtils.H
@@ -33,15 +33,31 @@
 #ifndef FAPI2TESTUTILS_H_
 #define FAPI2TESTUTILS_H_
 
-#define EQ_PER_PROC 6
-#define EX_PER_EQ 2
-#define CORE_PER_EX 2
-#define MCS_PER_PROC 4
-#define MCA_PER_MCS 2
-#define MCBIST_PER_PROC 2
+#define EQ_PER_PROC          6
+#define EX_PER_EQ            2
+#define CORE_PER_EX          2
+#define MCS_PER_PROC         4
+#define MCA_PER_MCS          2
+#define MCBIST_PER_PROC      2
+#define MCS_PER_MCBIST       2
+#define PERV_PER_PROC        43
+#define XBUS_PER_PROC        1
+#define OBUS_PER_PROC        2
 
 #define SIMULATED_GOOD_CORES 4
 
+// non-core and non-cache chiplet ids
+#define START_PERV_CHIPLET_NUM    0x01
+#define START_XBUS_CHIPLET_NUM    0x06
+#define START_MCBIST_CHIPLET_NUM  0x07
+#define START_OBUS_CHIPLET_NUM    0x09
+
+// All Cache Chiplets
+#define START_EQ_CHIPLET_NUM      0x10
+
+// All Core Chiplets
+#define START_CORE_CHIPLET_NUM    0x20
+
 #include <fapi2.H>
 
 namespace fapi2