summaryrefslogtreecommitdiffstats
path: root/src/usr/fapi2/test/fapi2GetChipletNumTest.H
diff options
context:
space:
mode:
Diffstat (limited to 'src/usr/fapi2/test/fapi2GetChipletNumTest.H')
-rw-r--r--src/usr/fapi2/test/fapi2GetChipletNumTest.H606
1 files changed, 606 insertions, 0 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
+
OpenPOWER on IntegriCloud