diff options
Diffstat (limited to 'src/usr/fapi2/test/fapi2GetChipletNumTest.H')
-rw-r--r-- | src/usr/fapi2/test/fapi2GetChipletNumTest.H | 606 |
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 + |