From 99761f93896da24de7ad18561ecd3519645d4f1e Mon Sep 17 00:00:00 2001 From: "Daniel M. Crowell" Date: Sun, 14 Oct 2018 13:07:08 -0500 Subject: Revert "P10 prep: Infrastructure (IS) ring Id metadata and API changes" This reverts commit 52b76be222254e59959db984606c09dae854270b. Accidental merge before ekb was complete. Change-Id: I59412ecad661596322aaba5cb5cf83190727d64f Reviewed-on: http://rchgit01.rchland.ibm.com/gerrit1/67455 Reviewed-by: Daniel M. Crowell Tested-by: Daniel M. Crowell --- .../chips/common/utils/imageProcs/common_ringId.C | 820 +++------------------ .../chips/common/utils/imageProcs/common_ringId.H | 327 ++++---- 2 files changed, 238 insertions(+), 909 deletions(-) (limited to 'src/import/chips/common') diff --git a/src/import/chips/common/utils/imageProcs/common_ringId.C b/src/import/chips/common/utils/imageProcs/common_ringId.C index d52c92072..c568468f8 100644 --- a/src/import/chips/common/utils/imageProcs/common_ringId.C +++ b/src/import/chips/common/utils/imageProcs/common_ringId.C @@ -34,7 +34,6 @@ namespace CEN_RID }; #include - // These strings must adhere precisely to the enum of PpeType. const char* ppeTypeName[] = { "SBE", "CME", @@ -76,7 +75,7 @@ static int get_ipl_ring_path_param( RingVariant_t i_ringVariant, char*& o_ringPa if (o_ringPath == NULL) { - MY_ERR("get_ipl_ring_path_param(): IPL env parm for ringVariant=%d not set\n", + MY_ERR("get_ipl_ring_path_param(): IPL env parm for ringVariant=0x%x not set.\n", i_ringVariant); return INFRASTRUCT_RC_ENV_ERROR; } @@ -119,7 +118,7 @@ static int get_runtime_ring_path_param( RingVariant_t i_ringVariant, char*& o_ri if (o_ringPath == NULL) { - MY_ERR("get_runtime_ring_path_param(): RUNTIME env parm for ringVariant(=%d) not set\n", + MY_ERR("get_runtime_ring_path_param(): RUNTIME env parm for ringVariant=0x%x not set.\n", i_ringVariant); return INFRASTRUCT_RC_ENV_ERROR; } @@ -155,7 +154,8 @@ int ringid_get_raw_ring_file_path( uint32_t i_magic, } else { - MY_ERR("Invalid ringVariant(=%d) for TOR magic=0x%08x\n", i_ringVariant, i_magic); + MY_ERR("Invalid ringVariant(=%d) for TOR magic=0x%08x\n", + i_ringVariant, i_magic); rc = TOR_INVALID_VARIANT; } @@ -186,7 +186,8 @@ int ringid_get_raw_ring_file_path( uint32_t i_magic, } else { - MY_ERR("Invalid ringVariant(=%d) for TOR magic=0x%08x\n", i_ringVariant, i_magic); + MY_ERR("Invalid ringVariant(=%d) for TOR magic=0x%08x\n", + i_ringVariant, i_magic); rc = TOR_INVALID_VARIANT; } @@ -207,7 +208,8 @@ int ringid_get_raw_ring_file_path( uint32_t i_magic, } else { - MY_ERR("Invalid ringVariant(=%d) for TOR magic=0x%08x\n", i_ringVariant, i_magic); + MY_ERR("Invalid ringVariant(=%d) for TOR magic=0x%08x\n", + i_ringVariant, i_magic); rc = TOR_INVALID_VARIANT; } @@ -226,7 +228,7 @@ int ringid_get_raw_ring_file_path( uint32_t i_magic, } else { - MY_ERR("Unsupported value of TOR magic(=0x%08x)\n", i_magic); + MY_ERR("Unsupported value of TOR magic(=0x%X)\n", i_magic); rc = TOR_INVALID_MAGIC_NUMBER; } @@ -239,26 +241,27 @@ int ringid_get_raw_ring_file_path( uint32_t i_magic, #endif // End of ifndef __HOSTBOOT_MODULE -int ringid_get_num_ring_ids( ChipId_t i_chipId, - RingId_t* o_numRingIds ) +int ringid_get_noof_ring_ids( ChipType_t i_chipType, + RingId_t* o_numRingIds) { int rc = INFRASTRUCT_RC_SUCCESS; - switch (i_chipId) + switch (i_chipType) { - case CID_P9N: - case CID_P9C: - case CID_P9A: + case CT_P9N: + case CT_P9C: + case CT_P9A: *o_numRingIds = P9_RID::NUM_RING_IDS; break; - case CID_CEN: + case CT_CEN: *o_numRingIds = CEN_RID::NUM_RING_IDS; break; default: - MY_ERR("ringid_get_num_ring_ids(): Unsupported chipId(=%d) supplied\n", i_chipId); - rc = TOR_INVALID_CHIP_ID; + MY_ERR("ringid_get_noof_ring_ids(): Unsupported chipType (=%d) supplied", + i_chipType); + rc = TOR_INVALID_CHIPTYPE; break; } @@ -266,108 +269,116 @@ int ringid_get_num_ring_ids( ChipId_t i_chipId, } -int ringid_get_num_chiplets( ChipId_t i_chipId, - uint32_t i_torMagic, - uint8_t* o_numChiplets ) +int ringid_get_ring_list( ChipType_t i_chipType, + RingId_t i_ringId, + GenRingIdList** o_ringIdList) { - switch (i_chipId) + int rc = INFRASTRUCT_RC_SUCCESS; + + switch (i_chipType) { - case CID_P9N: - case CID_P9C: - case CID_P9A: + case CT_P9N: + case CT_P9C: + case CT_P9A: + *o_ringIdList = P9_RID::_ringid_get_ring_list(i_ringId); + break; + + case CT_CEN: + *o_ringIdList = CEN_RID::_ringid_get_ring_list(i_ringId); + break; + + default: + MY_ERR("ringid_get_ring_list(): Unsupported chipType (=%d) supplied", + i_chipType); + rc = TOR_INVALID_CHIPTYPE; + break; + } + + return rc; +} + + +int ringid_get_noof_chiplets( ChipType_t i_chipType, + uint32_t i_torMagic, + uint8_t* o_numChiplets ) +{ + switch (i_chipType) + { + case CT_P9N: + case CT_P9C: + case CT_P9A: if ( i_torMagic == TOR_MAGIC_SBE || i_torMagic == TOR_MAGIC_OVRD || i_torMagic == TOR_MAGIC_OVLY ) { - *o_numChiplets = P9_RID::SBE_NUM_CHIPLETS; + *o_numChiplets = P9_RID::SBE_NOOF_CHIPLETS; } else if ( i_torMagic == TOR_MAGIC_CME ) { - *o_numChiplets = P9_RID::CME_NUM_CHIPLETS; + *o_numChiplets = P9_RID::CME_NOOF_CHIPLETS; } else if ( i_torMagic == TOR_MAGIC_SGPE ) { - *o_numChiplets = P9_RID::SGPE_NUM_CHIPLETS; + *o_numChiplets = P9_RID::SGPE_NOOF_CHIPLETS; } else { - MY_ERR("ringid_get_num_chiplets(): Invalid torMagic(=0x%08x) for chipId(=CID_P9x=%d)\n", i_torMagic, i_chipId); + MY_ERR("Invalid torMagic (=0x%08x) for chipType (=CT_P9x=%d)\n", i_torMagic, i_chipType); return TOR_INVALID_MAGIC_NUMBER; } break; - case CID_CEN: + case CT_CEN: if ( i_torMagic == TOR_MAGIC_CEN || i_torMagic == TOR_MAGIC_OVRD ) { - *o_numChiplets = CEN_RID::CEN_NUM_CHIPLETS; + *o_numChiplets = CEN_RID::CEN_NOOF_CHIPLETS; } else { - MY_ERR("Invalid torMagic(=0x%08x) for chipId(=CID_CEN)\n", i_torMagic); + MY_ERR("Invalid torMagic (=0x%08x) for chipType (=CT_CEN)\n", i_torMagic); return TOR_INVALID_MAGIC_NUMBER; } break; default: - MY_ERR("Invalid chipId(=%d)\n", i_chipId); - return TOR_INVALID_CHIP_ID; + MY_ERR("Invalid chipType (=0x%02x)\n", i_chipType); + return TOR_INVALID_CHIPTYPE; } return TOR_SUCCESS; } -int ringid_get_ringProps( ChipId_t i_chipId, - RingProperties_t** o_ringProps ) -{ - int rc = INFRASTRUCT_RC_SUCCESS; - - switch (i_chipId) - { - case CID_P9N: - case CID_P9C: - case CID_P9A: - *o_ringProps = (RingProperties_t*)&P9_RID::RING_PROPERTIES; - break; - - case CID_CEN: - *o_ringProps = (RingProperties_t*)&CEN_RID::RING_PROPERTIES; - break; - - default: - MY_ERR("ringid_get_ringProps(): Unsupported chipId (=%d) supplied\n", i_chipId); - rc = TOR_INVALID_CHIP_ID; - break; - } - - return rc; -} - - -int ringid_get_chipletProps( ChipId_t i_chipId, - uint32_t i_torMagic, - uint8_t i_torVersion, - ChipletType_t i_chipletType, - ChipletData_t** o_chipletData, - uint8_t* o_numVariants ) +int ringid_get_properties( ChipType_t i_chipType, + uint32_t i_torMagic, + uint8_t i_torVersion, + ChipletType_t i_chipletType, + ChipletData_t** o_chipletData, + GenRingIdList** o_ringIdListCommon, + GenRingIdList** o_ringIdListInstance, + RingVariantOrder** o_ringVariantOrder, + RingProperties_t** o_ringProps, + uint8_t* o_numVariants ) { - switch (i_chipId) + switch (i_chipType) { - case CID_P9N: - case CID_P9C: - case CID_P9A: + case CT_P9N: + case CT_P9C: + case CT_P9A: if ( i_torMagic == TOR_MAGIC_SBE || i_torMagic == TOR_MAGIC_OVRD || i_torMagic == TOR_MAGIC_OVLY ) { P9_RID::ringid_get_chiplet_properties( i_chipletType, - o_chipletData); - - *o_numVariants = (*o_chipletData)->numCommonRingVariants; + o_chipletData, + o_ringIdListCommon, + o_ringIdListInstance, + o_ringVariantOrder, + o_numVariants); if ( i_torVersion < 7 && (i_chipletType == P9_RID::EQ_TYPE || i_chipletType == P9_RID::EC_TYPE) ) @@ -384,7 +395,10 @@ int ringid_get_chipletProps( ChipId_t i_chipId, else if ( i_torMagic == TOR_MAGIC_CME ) { *o_chipletData = (ChipletData_t*)&P9_RID::EC::g_chipletData; - *o_numVariants = (*o_chipletData)->numCommonRingVariants; + *o_ringIdListCommon = (GenRingIdList*)P9_RID::EC::RING_ID_LIST_COMMON; + *o_ringIdListInstance = (GenRingIdList*)P9_RID::EC::RING_ID_LIST_INSTANCE; + *o_ringVariantOrder = (RingVariantOrder*)P9_RID::EC::RING_VARIANT_ORDER; + *o_numVariants = P9_RID::EC::g_chipletData.iv_num_common_ring_variants; if (i_torVersion < 7) { @@ -394,7 +408,10 @@ int ringid_get_chipletProps( ChipId_t i_chipId, else if ( i_torMagic == TOR_MAGIC_SGPE ) { *o_chipletData = (ChipletData_t*)&P9_RID::EQ::g_chipletData; - *o_numVariants = (*o_chipletData)->numCommonRingVariants; + *o_ringIdListCommon = (GenRingIdList*)P9_RID::EQ::RING_ID_LIST_COMMON; + *o_ringIdListInstance = (GenRingIdList*)P9_RID::EQ::RING_ID_LIST_INSTANCE; + *o_ringVariantOrder = (RingVariantOrder*)P9_RID::EQ::RING_VARIANT_ORDER; + *o_numVariants = P9_RID::EQ::g_chipletData.iv_num_common_ring_variants; if (i_torVersion < 7) { @@ -403,21 +420,25 @@ int ringid_get_chipletProps( ChipId_t i_chipId, } else { - MY_ERR("Invalid torMagic(=0x%08x) for chipId=CID_P9x=%d\n", i_torMagic, i_chipId); + MY_ERR("Invalid torMagic (=0x%08x) for chipType=CT_P9x=%d\n", i_torMagic, i_chipType); return TOR_INVALID_MAGIC_NUMBER; } + *o_ringProps = (RingProperties_t*)P9_RID::RING_PROPERTIES; + break; - case CID_CEN: + case CT_CEN: if ( i_torMagic == TOR_MAGIC_CEN || i_torMagic == TOR_MAGIC_OVRD ) { CEN_RID::ringid_get_chiplet_properties( i_chipletType, - o_chipletData); - - *o_numVariants = (*o_chipletData)->numCommonRingVariants; + o_chipletData, + o_ringIdListCommon, + o_ringIdListInstance, + o_ringVariantOrder, + o_numVariants); if ( i_torMagic == TOR_MAGIC_OVRD) { @@ -426,650 +447,19 @@ int ringid_get_chipletProps( ChipId_t i_chipId, } else { - MY_ERR("Invalid torMagic(=0x%08x) for chipId=CID_CEN\n", i_torMagic); - return TOR_INVALID_MAGIC_NUMBER; - } - - break; - - default: - MY_ERR("Invalid chipId(=%d)\n", i_chipId); - return TOR_INVALID_CHIP_ID; - - } - - return TOR_SUCCESS; -} - - -int ringid_get_scanScomAddr( ChipId_t i_chipId, - RingId_t i_ringId, - uint32_t* o_scanScomAddr ) -{ - int rc = INFRASTRUCT_RC_SUCCESS; - uint32_t l_scanScomAddr = UNDEFINED_SCOM_ADDR; - - switch (i_chipId) - { - case CID_P9N: - case CID_P9C: - case CID_P9A: - if (i_ringId >= P9_RID::NUM_RING_IDS) - { - MY_ERR("ringid_get_scanScomAddr(): ringId(=0x%x) >= NUM_RING_IDS(=0x%x) not" - " allowed\n", - i_ringId, P9_RID::NUM_RING_IDS); - rc = TOR_INVALID_RING_ID; - break; - } - - l_scanScomAddr = P9_RID::RING_PROPERTIES[i_ringId].scanScomAddr; - break; - - case CID_CEN: - if (i_ringId >= CEN_RID::NUM_RING_IDS) - { - MY_ERR("ringid_get_scanScomAddr(): ringId(=0x%x) >= NUM_RING_IDS(=0x%x) not" - " allowed\n", - i_ringId, CEN_RID::NUM_RING_IDS); - rc = TOR_INVALID_RING_ID; - break; - } - - l_scanScomAddr = CEN_RID::RING_PROPERTIES[i_ringId].scanScomAddr; - break; - - default: - MY_ERR("ringid_get_scanScomAddr(): Unsupported chipId (=%d) supplied\n", i_chipId); - rc = TOR_INVALID_CHIP_ID; - break; - } - - *o_scanScomAddr = l_scanScomAddr; - - return rc; -} - - -int ringid_get_ringClass( ChipId_t i_chipId, - RingId_t i_ringId, - RingClass_t* o_ringClass ) -{ - int rc = INFRASTRUCT_RC_SUCCESS; - RingClass_t l_ringClass = UNDEFINED_RING_CLASS; - - switch (i_chipId) - { - case CID_P9N: - case CID_P9C: - case CID_P9A: - if (i_ringId >= P9_RID::NUM_RING_IDS) - { - MY_ERR("ringid_get_ringClass(): ringId(=0x%x) >= NUM_RING_IDS(=0x%x) not allowed\n", - i_ringId, P9_RID::NUM_RING_IDS); - rc = TOR_INVALID_RING_ID; - break; - } - - l_ringClass = P9_RID::RING_PROPERTIES[i_ringId].ringClass; - break; - - case CID_CEN: - if (i_ringId >= CEN_RID::NUM_RING_IDS) - { - MY_ERR("ringid_get_ringClass(): ringId(=0x%x) >= NUM_RING_IDS(=0x%x) not allowed\n", - i_ringId, CEN_RID::NUM_RING_IDS); - rc = TOR_INVALID_RING_ID; - break; - } - - l_ringClass = CEN_RID::RING_PROPERTIES[i_ringId].ringClass; - break; - - default: - MY_ERR("ringid_get_ringClass(): Unsupported chipId (=%d) supplied\n", i_chipId); - rc = TOR_INVALID_CHIP_ID; - break; - } - - *o_ringClass = l_ringClass; - - return rc; -} - - -int ringid_check_ringId( ChipId_t i_chipId, - RingId_t i_ringId ) -{ - int rc = INFRASTRUCT_RC_SUCCESS; - - switch (i_chipId) - { - case CID_P9N: - case CID_P9C: - case CID_P9A: - if ( i_ringId >= P9_RID::NUM_RING_IDS && i_ringId != UNDEFINED_RING_ID ) - { - MY_ERR("ringid_check_ringId(): ringId(=0x%x) >= NUM_RING_IDS(=0x%x) not allowed\n", - i_ringId, P9_RID::NUM_RING_IDS); - rc = TOR_INVALID_RING_ID; - break; - } - - break; - - case CID_CEN: - if ( i_ringId >= CEN_RID::NUM_RING_IDS && i_ringId != UNDEFINED_RING_ID ) - { - MY_ERR("ringid_check_ringId(): ringId(=0x%x) >= NUM_RING_IDS(=0x%x) not allowed\n", - i_ringId, CEN_RID::NUM_RING_IDS); - rc = TOR_INVALID_RING_ID; - break; - } - - break; - - default: - MY_ERR("ringid_check_ringId(): Unsupported chipId (=%d) supplied\n", i_chipId); - rc = TOR_INVALID_CHIP_ID; - break; - } - - return rc; -} - - -int ringid_get_chipletIndex( ChipId_t i_chipId, - uint32_t i_torMagic, - ChipletType_t i_chipletType, - ChipletType_t* o_chipletIndex ) -{ - int rc = INFRASTRUCT_RC_SUCCESS; - - switch (i_chipId) - { - case CID_P9N: - case CID_P9C: - case CID_P9A: - if ( i_torMagic == TOR_MAGIC_SBE || - i_torMagic == TOR_MAGIC_OVRD || - i_torMagic == TOR_MAGIC_OVLY ) - { - if ( i_chipletType < P9_RID::SBE_NUM_CHIPLETS ) - { - *o_chipletIndex = i_chipletType; - } - else - { - rc = TOR_INVALID_CHIPLET_TYPE; - } - } - else if ( i_torMagic == TOR_MAGIC_CME ) - { - if ( i_chipletType == P9_RID::EC_TYPE ) - { - *o_chipletIndex = 0; - } - else - { - rc = TOR_INVALID_CHIPLET_TYPE; - } - } - else if ( i_torMagic == TOR_MAGIC_SGPE ) - { - if ( i_chipletType == P9_RID::EQ_TYPE ) - { - *o_chipletIndex = 0; - } - else - { - rc = TOR_INVALID_CHIPLET_TYPE; - } - } - else - { - MY_ERR("Invalid torMagic(=0x%08x) for chipId=CID_P9x=%d\n", i_torMagic, i_chipId); - return TOR_INVALID_MAGIC_NUMBER; - } - - break; - - case CID_CEN: - if ( i_torMagic == TOR_MAGIC_CEN || - i_torMagic == TOR_MAGIC_OVRD ) - { - if ( i_chipletType < CEN_RID::CEN_NUM_CHIPLETS ) - { - *o_chipletIndex = i_chipletType; - } - else - { - rc = TOR_INVALID_CHIPLET_TYPE; - } - } - else - { - MY_ERR("Invalid torMagic(=0x%08x) for chipId=CID_CEN\n", i_torMagic); + MY_ERR("Invalid torMagic (=0x%08x) for chipType=CT_CEN\n", i_torMagic); return TOR_INVALID_MAGIC_NUMBER; } - break; - - default: - MY_ERR("ringid_get_chipletIndex(): Unsupported chipId (=%d) supplied\n", i_chipId); - rc = TOR_INVALID_CHIP_ID; - break; - } - - return rc; -} - - -#if !defined(__PPE__) && !defined(NO_STD_LIB_IN_PPE) && !defined(__HOSTBOOT_MODULE) && !defined(FIPSODE) - -// The following defines are needed by the initCompiler and so it's practical to use C++ -// features. - -// ** Important ** -// If updates are made to the below three maps, corresponding updates to the two -// maps in ./tools/ifCompiler/initCompiler/initCompiler.y may also have to be made. -// @TODO: RTC192378 -// For P10 we should have just the two maps from initCompiler.y. And they should -// be located in central place like ./chips/common/utils/imageProcs/infrastructure. - -// Mapping from our [InfraStructure's} chipId to the chipType name -std::map chipIdIsMap -{ - { UNDEFINED_CHIP_ID, "" }, - { (ChipId_t)CID_CEN, "cen" }, - { (ChipId_t)CID_P9N, "p9n" }, - { (ChipId_t)CID_P9C, "p9c" }, - { (ChipId_t)CID_P9A, "p9a" } -}; - -// Mapping from chipType name to our [InfraStructure's} chipId (revers of above map) -std::map chipTypeIsMap -{ - { "", UNDEFINED_CHIP_ID }, - { "cen", (ChipId_t)CID_CEN }, - { "p9n", (ChipId_t)CID_P9N }, - { "p9c", (ChipId_t)CID_P9C }, - { "p9a", (ChipId_t)CID_P9A } -}; - -// Mapping from InitCompiler's chipId to InfraStructure's chipId -std::map chipIdIcToIsMap -{ - { 0x0, UNDEFINED_CHIP_ID }, - { 0x3, (ChipId_t)CID_CEN }, - { 0x5, (ChipId_t)CID_P9N }, - { 0x6, (ChipId_t)CID_P9C }, - { 0x7, (ChipId_t)CID_P9A } -}; - -int ringidGetRootRingId( ChipId_t i_chipId, - uint32_t i_scanScomAddr, - RingId_t& o_ringId, - bool i_bTest ) -{ - int rc = INFRASTRUCT_RC_SUCCESS; - RingProperties_t* ringProps = NULL; - RingId_t numRingIds = UNDEFINED_RING_ID; - RingId_t iRingId = UNDEFINED_RING_ID; // ringId loop counter - RingId_t l_ringId = UNDEFINED_RING_ID; - bool bFound = false; + *o_ringProps = (RingProperties_t*)CEN_RID::RING_PROPERTIES; - switch (i_chipId) - { - case CID_P9N: - case CID_P9C: - case CID_P9A: - ringProps = (RingProperties_t*)&P9_RID::RING_PROPERTIES; - numRingIds = P9_RID::NUM_RING_IDS; - break; - - case CID_CEN: - ringProps = (RingProperties_t*)&CEN_RID::RING_PROPERTIES; - numRingIds = CEN_RID::NUM_RING_IDS; break; default: - MY_ERR("ringidGetRootRingId(): Unsupported chipId (=%d) supplied\n", i_chipId); - rc = TOR_INVALID_CHIP_ID; - break; - } + MY_ERR("Invalid chipType (=0x%02x)\n", i_chipType); + return TOR_INVALID_CHIPTYPE; - if (!rc) - { - for ( iRingId = 0; iRingId < numRingIds; iRingId++ ) - { - if ( ringProps[iRingId].scanScomAddr == i_scanScomAddr ) - { - if ( ringProps[iRingId].ringClass & RCLS_ROOT_RING ) - { - if (bFound) - { - MY_ERR("ringidGetRootRingId(): Two rings w/same addr cannot both be" - " ROOT_RING. Fix RING_PROPERTIES list for chipId=%d at ringId=0x%x" - " and ringId=0x%x\n", - i_chipId, l_ringId, iRingId); - rc = INFRASTRUCT_RC_CODE_BUG; - l_ringId = UNDEFINED_RING_ID; - break; - } - else - { - l_ringId = iRingId; - bFound = true; - - if (!i_bTest) - { - // Stop testing and break out of ringId loop - break; - } - - // Continue testing to see if duplicate root rings found - } - } - } - } } - if (!rc && !bFound) - { - MY_DBG("ringidGetRootRingId(): Did not find match for scanScomAddr=0x%08x for chipId=%d." - " (Note, l_ringId=0x%x better be equal to UNDEFINED_RING_ID=0x%x)\n", - i_scanScomAddr, i_chipId, l_ringId, UNDEFINED_RING_ID); - rc = TOR_SCOM_ADDR_NOT_FOUND; - } - - o_ringId = l_ringId; - - return rc; -} - - -int ringidGetRingId1( ChipId_t i_chipId, - std::string i_ringName, - RingId_t& o_ringId, - bool i_bTest ) -{ - int rc = INFRASTRUCT_RC_SUCCESS; - RingProperties_t* ringProps = NULL; - RingId_t numRingIds = UNDEFINED_RING_ID; - RingId_t iRingId = UNDEFINED_RING_ID; // ringId loop counter - RingId_t l_ringId = UNDEFINED_RING_ID; - bool bFound = false; - - switch (i_chipId) - { - case CID_P9N: - case CID_P9C: - case CID_P9A: - ringProps = (RingProperties_t*)&P9_RID::RING_PROPERTIES; - numRingIds = P9_RID::NUM_RING_IDS; - break; - - case CID_CEN: - ringProps = (RingProperties_t*)&CEN_RID::RING_PROPERTIES; - numRingIds = CEN_RID::NUM_RING_IDS; - break; - - default: - MY_ERR("ringidGetRingId1(): Unsupported chipId (=%d) supplied\n", i_chipId); - rc = TOR_INVALID_CHIP_ID; - break; - } - - if (!rc) - { - for ( iRingId = 0; iRingId < numRingIds; iRingId++ ) - { - if ( !(i_ringName.compare(ringProps[iRingId].ringName)) ) - { - if (bFound) - { - MY_ERR("ringidGetRingId1(): Two rings cannot have the same ringName=%s. Fix" - " RING_PROPERTIES list for chipId=%d at ringId=0x%x and ringId=0x%x\n", - i_ringName.c_str(), i_chipId, l_ringId, iRingId); - rc = INFRASTRUCT_RC_CODE_BUG; - l_ringId = UNDEFINED_RING_ID; - break; - } - else - { - l_ringId = iRingId; - bFound = true; - - if (!i_bTest) - { - // Stop testing and break our of ringId loop - break; - } - - // Continue testing to see if duplicate ringNames found - } - } - } - } - - if (!rc && !bFound) - { - MY_DBG("ringidGetRingId1(): Did not find match to ringName=%s for chipId=%d." - " (Note, l_ringId=0x%x better be equal to UNDEFINED_RING_ID=0x%x)\n", - i_ringName.c_str(), i_chipId, l_ringId, UNDEFINED_RING_ID); - rc = TOR_RING_NAME_NOT_FOUND; - } - - o_ringId = l_ringId; - - return rc; -} - - -int ringidGetRingId2( ChipId_t i_chipId, - uint32_t i_torMagic, - ChipletType_t i_chipletType, // Ignored if only one chiplet in torMagic - uint8_t i_idxRing, // The effective ring index within chiplet's - // common or instance ring section - MyBool_t i_bInstCase, - RingId_t& o_ringId, - bool i_bTest ) -{ - int rc = INFRASTRUCT_RC_SUCCESS; - ChipletType_t l_chipletType = UNDEFINED_CHIPLET_TYPE; - RingProperties_t* ringProps = NULL; - RingId_t numRingIds = UNDEFINED_RING_ID; - RingId_t iRingId = UNDEFINED_RING_ID; // ringId loop counter - RingId_t l_ringId = UNDEFINED_RING_ID; - uint8_t l_idxRing = INVALID_RING_OFFSET; - bool bFound = false; - bool bOverlap = false; - - // First, select the main ring list we need (P9's or Centaur's). And while we're at it, - // convert input chipletType, which can be ignored for ring sections (i.e. torMagic) - // with only one chiplet, to a valid chipletType - switch (i_chipId) - { - case CID_P9N: - case CID_P9C: - case CID_P9A: - ringProps = (RingProperties_t*)&P9_RID::RING_PROPERTIES; - numRingIds = P9_RID::NUM_RING_IDS; - - if ( i_torMagic == TOR_MAGIC_SBE || - i_torMagic == TOR_MAGIC_OVRD || - i_torMagic == TOR_MAGIC_OVLY ) - { - l_chipletType = i_chipletType; - } - else if ( i_torMagic == TOR_MAGIC_CME ) - { - l_chipletType = P9_RID::EC_TYPE; - } - else if ( i_torMagic == TOR_MAGIC_SGPE ) - { - l_chipletType = P9_RID::EQ_TYPE; - } - else - { - MY_ERR("Invalid torMagic(=0x%08x) for chipId=CID_P9x=%d\n", i_torMagic, i_chipId); - return TOR_INVALID_MAGIC_NUMBER; - } - - break; - - case CID_CEN: - ringProps = (RingProperties_t*)&CEN_RID::RING_PROPERTIES; - numRingIds = CEN_RID::NUM_RING_IDS; - - if ( i_torMagic == TOR_MAGIC_CEN || - i_torMagic == TOR_MAGIC_OVRD ) - { - l_chipletType = CEN_RID::CEN_TYPE; - } - else - { - MY_ERR("Invalid torMagic(=0x%08x) for chipId=CID_CEN\n", i_torMagic); - return TOR_INVALID_MAGIC_NUMBER; - } - - break; - - default: - MY_ERR("ringidGetRingId2(): Unsupported chipId (=%d) supplied\n", i_chipId); - rc = TOR_INVALID_CHIP_ID; - break; - } - - // Second, convert effective input ring index (which has no instance marker) to the - // common/instance specific index - l_idxRing = i_bInstCase ? - i_idxRing | INSTANCE_RING_MARK : - i_idxRing; - - if (!rc) - { - for ( iRingId = 0; iRingId < numRingIds; iRingId++ ) - { - if ( ringProps[iRingId].chipletType == l_chipletType && - ringProps[iRingId].idxRing == l_idxRing ) - { - if (bFound) - { - // Allow ring index overlap between a root and a non-root ring - // and let the non-root (i.e., the bucket ring) "win" - if ( !bOverlap && - ( (ringProps[iRingId].ringClass & RCLS_ROOT_RING) != - (ringProps[l_ringId].ringClass & RCLS_ROOT_RING) ) ) - { - if ( (ringProps[iRingId].ringClass & RCLS_ROOT_RING) != RCLS_ROOT_RING ) - { - l_ringId = iRingId; - } - else - { - // Keep l_ringId as is since it must already be the non-root ring - } - - bOverlap = true; // Indicate we found an overlap match - - if (!i_bTest) - { - // Stop testing and break our of ringId loop - break; - } - } - else - { - MY_ERR("ringidGetRingId2(): Two root, or two non-root, rings within a" - " chiplet (chipletType=%d) cannot have the same ring index" - " (idxRing=%d, bInst=%d). Fix RING_PROPERTIES list for chipId=%d" - " at ringId=0x%x and ringId=0x%x\n", - l_chipletType, i_idxRing, i_bInstCase, i_chipId, l_ringId, iRingId); - rc = INFRASTRUCT_RC_CODE_BUG; - l_ringId = UNDEFINED_RING_ID; - break; - } - } - else - { - l_ringId = iRingId; - bFound = true; // Indicate we found a first match - - // Continue searching for ring index overlap due to bucket ring or code bug - } - } - } - } - - if (!rc && !bFound) - { - MY_ERR("ringidGetRingId2(): Could not find a match for (chipId,chipletType,idxRing,bInst) =" - " (%d, %d, %d, %d). Fix RING_PROPERTIES list for chipId=%d (Note, l_ringId=0x%x" - " better be equal to UNDEFINED_RING_ID=0x%x)\n", - i_chipId, l_chipletType, i_idxRing, i_bInstCase, - i_chipId, l_ringId, UNDEFINED_RING_ID); - rc = INFRASTRUCT_RC_CODE_BUG; - } - - o_ringId = l_ringId; - - return rc; -} - - -int ringidGetRingName( ChipId_t i_chipId, - RingId_t i_ringId, - std::string& o_ringName ) -{ - int rc = INFRASTRUCT_RC_SUCCESS; - std::string l_ringName; - - switch (i_chipId) - { - case CID_P9N: - case CID_P9C: - case CID_P9A: - if (i_ringId >= P9_RID::NUM_RING_IDS) - { - MY_ERR("ringidGetRingName(): ringId(=0x%x) >= NUM_RING_IDS(=0x%x) not allowed\n", - i_ringId, P9_RID::NUM_RING_IDS); - rc = TOR_INVALID_RING_ID; - break; - } - - l_ringName = (std::string)P9_RID::RING_PROPERTIES[i_ringId].ringName; - break; - - case CID_CEN: - if (i_ringId >= CEN_RID::NUM_RING_IDS) - { - MY_ERR("ringidGetRingName(): ringId(=0x%x) >= NUM_RING_IDS(=0x%x) not allowed\n", - i_ringId, CEN_RID::NUM_RING_IDS); - rc = TOR_INVALID_RING_ID; - break; - } - - l_ringName = (std::string)CEN_RID::RING_PROPERTIES[i_ringId].ringName; - break; - - default: - MY_ERR("ringidGetRingName(): Unsupported chipId (=%d) supplied\n", i_chipId); - rc = TOR_INVALID_CHIP_ID; - break; - } - - o_ringName = l_ringName; - - return rc; -} - -int ringidGetRingClass( ChipId_t i_chipId, - RingId_t i_ringId, - RingClass_t& o_ringClass ) -{ - return (ringid_get_ringClass(i_chipId, i_ringId, &o_ringClass)); + return TOR_SUCCESS; } - -#endif // __PPE__ && NO_STD_LIB_IN_PPE diff --git a/src/import/chips/common/utils/imageProcs/common_ringId.H b/src/import/chips/common/utils/imageProcs/common_ringId.H index de23bea0a..bef223357 100644 --- a/src/import/chips/common/utils/imageProcs/common_ringId.H +++ b/src/import/chips/common/utils/imageProcs/common_ringId.H @@ -42,24 +42,21 @@ // INFRASTRUCT TEAM. (These defs affect packing assumptions // of ring structures that go into the image ringSections.) typedef uint16_t RingId_t; // Type for RingID enum -typedef uint16_t RingClass_t; // Type for RingClass enum vectors used in non-SBE -typedef uint8_t ChipletType_t; // Type for Chiplets enum -typedef uint8_t PpeType_t; // Type for PpeType enum -typedef uint8_t ChipId_t; // Type for ChipId enum +typedef uint8_t ChipletType_t; // Type for CHIPLET_TYPE enum +typedef uint8_t PpeType_t; // Type for PpeType +typedef uint8_t ChipType_t; // Type for ChipType enum typedef uint8_t RingType_t; // Type for RingType enum typedef uint8_t RingVariant_t; // Type for RingVariant enum typedef uint8_t RingBlockType_t; // Type for RingBlockType enum, e.g. GET_SINGLE_RING typedef uint32_t TorCpltOffset_t; // Type for offset value to chiplet's CMN or INST section typedef uint8_t MyBool_t; // false:0, true:1, undefined:UNDEFINED_BOOLEAN -#define UNDEFINED_RING_ID (RingId_t)0xffff -#define UNDEFINED_SCOM_ADDR (uint32_t)0xffffffff -#define UNDEFINED_RING_CLASS (RingClass_t)0xffff -#define UNDEFINED_CHIPLET_TYPE (ChipletType_t)0xff -#define UNDEFINED_PPE_TYPE (PpeType_t)0xff -#define UNDEFINED_CHIP_ID (ChipId_t)0xff -#define INVALID_RING_TYPE (RingType_t)0xff -#define UNDEFINED_RING_VARIANT (RingVariant_t)0xff +#define UNDEFINED_RING_ID (RingId_t)0xffff +#define UNDEFINED_CHIPLET_TYPE (ChipletType_t)0xff +#define UNDEFINED_PPE_TYPE (PpeType_t)0xff +#define UNDEFINED_CHIP_TYPE (ChipType_t)0xff +#define INVALID_RING_TYPE (RingType_t)0xff +#define UNDEFINED_RING_VARIANT (RingVariant_t)0xff #define UNDEFINED_RING_BLOCK_TYPE (RingBlockType_t)0xff; #define UNDEFINED_DD_LEVEL (uint8_t)0xff @@ -85,12 +82,12 @@ typedef uint8_t MyBool_t; // false:0, true:1, undefined:UNDEFINED_BOOL // typedef struct { - uint32_t magic; // =TOR_MAGIC_xyz - uint8_t version; // =TOR_VERSION - ChipId_t chipId; // Value from ChipId enum - uint8_t ddLevel; // Actual DD level of ringSection - uint8_t undefined; - uint32_t size; // Size of ringSection. + uint32_t magic; // =TOR_MAGIC_xyz + uint8_t version; // =TOR version + ChipType_t chipType; // Value from ChipType enum + uint8_t ddLevel; // Actual DD level of ringSection + uint8_t undefined; + uint32_t size; // Size of ringSection. } TorHeader_t; // @@ -148,39 +145,57 @@ enum TorMagicNum // // Chip types and List to represent p9n, p9c, p9a, cen (centaur) // -enum ChipId +enum ChipType { - CID_P9N, - CID_P9C, - CID_P9A, - CID_CEN, - NUM_CHIP_IDS = 4 + CT_P9N, + CT_P9C, + CT_P9A, + CT_CEN, + NUM_CHIP_TYPES }; +typedef struct +{ + const char* name; + ChipType_t type; +} ChipTypeList_t; + +static const ChipTypeList_t CHIP_TYPE_LIST[] = +{ + {"p9n", CT_P9N}, + {"p9c", CT_P9C}, + {"p9a", CT_P9A}, + {"cen", CT_CEN}, +}; + + // -// Ring classes -// - Specified whether root ring: ROOT (only applied in RING_PROPERTIES list) -// - Specifies origination repo: EKB or MVPD -// - Specifies chip ID: P9 or Centaur -// - Specifies MVPD subclass: #G or #R -// - Specifies flush status assumption: Flushed or non-flushed (prev scanned) -// - Specifies various special ring classes: FSM, OVLY, STUMPED, CMSK +// Ring related data structs and types // -enum RingClass +typedef enum RingClass { - RCLS_ROOT_RING = 0b0000000000000001, // ENGD root ring marker bit - RCLS_FLUSH_RING = 0b0000000000000010, // Flush-scan marker bit - RCLS_NONFLUSH_RING = 0b0000000000000100, // Nonflush-scan marker bit - RCLS_EKB_FLUSH_RING = 0b0000000000001010, // EKB P9 ring. Flush-scanned - RCLS_EKB_NONFLUSH_RING = 0b0000000000001100, // EKB P9 ring. Nonflush-scanned - RCLS_MVPD_PDG_RING = 0b0000000000010010, // MVPD #G P9 ring. Flush-scanned - RCLS_MVPD_PDR_RING = 0b0000000000100010, // MVPD #R P9 ring. Flush-scanned - RCLS_EKB_CEN_RING = 0b0000000001000010, // EKB Cen ring. Flush-scanned - RCLS_EKB_FSM_RING = 0b0000000010000110, // EKB P9 ring for eq_ana_bndy. Mixed-scanned - RCLS_EKB_OVLY_RING = 0b0000000100010010, // EKB P9 ovly for MVPD GPTR ring. Flush-scanned - RCLS_EKB_STUMPED_RING = 0b0000001000000010, // EKB P9 CMSK stump ring. Flush-scanned - RCLS_EKB_CMSK_RING = 0b0000010000000010, // EKB P9 CMSK ring. Flush-scanned -}; + EKB_RING, + EKB_FSM_RING, + EKB_STUMPED_RING, + EKB_CMSK_RING, + EKB_NONFLUSH_RING, + VPD_RING, + CEN_RING, + NUM_RING_CLASSES +} RingClass_t; + +// +// General Ring ID list structure +// +typedef struct +{ + const char* ringName; + RingId_t ringId; + uint8_t instanceIdMin; + uint8_t instanceIdMax; + RingClass_t ringClass; + uint32_t scanScomAddress; +} GenRingIdList; // PPE types supported. // - This enum also reflects the order with which they appear in the HW image's .rings section. @@ -208,6 +223,16 @@ enum RingVariant NUM_RING_VARIANTS = 0x07, }; +extern const char* ppeTypeName[]; +extern const char* ringVariantName[]; + +// Variant order for Common rings +typedef struct +{ + RingVariant_t variant[NUM_RING_VARIANTS]; +} RingVariantOrder; + + // Ring types supported. // - This enum also reflects the order with which they appear in various images' .rings section. // - Do NOT make changes to the values or order of this enum. @@ -225,53 +250,44 @@ enum RingBlockType PUT_SINGLE_RING = 0x02 }; -extern const char* ppeTypeName[]; -extern const char* ringVariantName[]; - - -// -// Main ring properties structure -// - This structure is the basis for the RING_PROPERTIES list (further below) which, through the -// enumerated ringId index, associates (ringId, ringName, scanScomAddr, torOffset, chipletType) -// - For PPE we omit the ringName and scanScomAddr to save space in the SBE h-code. -// typedef struct { -#ifndef __PPE__ - char ringName[MAX_RING_NAME_LENGTH]; - uint32_t scanScomAddr; -#endif - uint8_t idxRing; - ChipletType_t chipletType; -#ifndef __PPE__ - RingClass_t ringClass; -#endif -} RingProperties_t; + // Chiplet ID of the first instance of the Chiplet + uint8_t iv_base_chiplet_number; -// -// Main chiplet properties structure -// -typedef struct -{ - // This is the instance ID range of the chiplet. - uint8_t chipletBaseId; // This is also the chiplet base ID for the COMMON rings in the chiplet - uint8_t numChipletInstances; // Num of chiplet instances - uint8_t numCommonRings; // Num of common rings - uint8_t numInstanceRings; // Num of instance rings (w/different ringId values) - uint8_t numInstanceRingsScanAddr; // Num of instance rings for (w/diff ringId && diff scanAddrs) - uint8_t numCommonRingVariants; // Num of Common rings variants. Only one for Instance rings - RingVariant_t ringVariantOrder[NUM_RING_VARIANTS]; // Order of ring variants in ring section + // Number of common rings for the Chiplet + uint8_t iv_num_common_rings; + + // Number of instance rings for the Chiplet (w/different ringId values) + uint8_t iv_num_instance_rings; + + // Number of instance rings for the Chiplet (w/different ringId values + // AND different scanAddress values) + uint8_t iv_num_instance_rings_scan_addrs; + + // Number of variants for common rings (instance rings only have BASE variant) + uint8_t iv_num_common_ring_variants; } ChipletData_t; // This is used to Set (Mark) the left-most bit #define INSTANCE_RING_MARK (uint8_t)0x80 // -// This is used to Clear the left-most bit +// This is used to Set (Mark) the left-most bit #define INSTANCE_RING_MASK (uint8_t)0x7F // This is used to mark an invalid ring in the ring properties list #define INVALID_RING_OFFSET (uint8_t)0xFF +// This structure is needed for mapping a RingID to it's corresponding name. +// The names will be used by the build scripts when generating the TOR. +typedef struct +{ + uint8_t iv_torOffSet; +#ifndef __PPE__ + char iv_name[MAX_RING_NAME_LENGTH]; +#endif + ChipletType_t iv_type; +} RingProperties_t; // @@ -291,32 +307,28 @@ typedef struct #define TOR_CODE_BUG INFRASTRUCT_RC_CODE_BUG #define TOR_USER_ERROR INFRASTRUCT_RC_USER_ERROR #define TOR_INVALID_MAGIC_NUMBER INFRASTRUCT_RC_NOOF_CODES + 1 -#define TOR_INVALID_CHIP_ID INFRASTRUCT_RC_NOOF_CODES + 3 -#define TOR_INVALID_CHIPLET_TYPE INFRASTRUCT_RC_NOOF_CODES + 4 +#define TOR_INVALID_CHIPTYPE INFRASTRUCT_RC_NOOF_CODES + 3 +#define TOR_INVALID_CHIPLET INFRASTRUCT_RC_NOOF_CODES + 4 #define TOR_INVALID_VARIANT INFRASTRUCT_RC_NOOF_CODES + 5 #define TOR_INVALID_RING_ID INFRASTRUCT_RC_NOOF_CODES + 6 #define TOR_INVALID_INSTANCE_ID INFRASTRUCT_RC_NOOF_CODES + 7 #define TOR_INVALID_RING_BLOCK_TYPE INFRASTRUCT_RC_NOOF_CODES + 8 #define TOR_UNSUPPORTED_RING_SECTION INFRASTRUCT_RC_NOOF_CODES + 9 -#define TOR_RING_NOT_FOUND INFRASTRUCT_RC_NOOF_CODES + 10 // to be phased out -#define TOR_RING_IS_EMPTY INFRASTRUCT_RC_NOOF_CODES + 10 // non-fatal replace -#define TOR_RING_IS_POPULATED INFRASTRUCT_RC_NOOF_CODES + 11 -#define TOR_RING_HAS_NO_TOR_SLOT INFRASTRUCT_RC_NOOF_CODES + 12 // fatal replace -#define TOR_AMBIGUOUS_API_PARMS INFRASTRUCT_RC_NOOF_CODES + 13 -#define TOR_SECTION_NOT_FOUND INFRASTRUCT_RC_NOOF_CODES + 14 -#define TOR_DD_LEVEL_NOT_FOUND INFRASTRUCT_RC_NOOF_CODES + 15 -#define TOR_OP_BUFFER_INVALID INFRASTRUCT_RC_NOOF_CODES + 16 -#define TOR_OP_BUFFER_SIZE_EXCEEDED INFRASTRUCT_RC_NOOF_CODES + 17 -#define TOR_IMAGE_DOES_NOT_SUPPORT_CME INFRASTRUCT_RC_NOOF_CODES + 18 -#define TOR_IMAGE_DOES_NOT_SUPPORT_SGPE INFRASTRUCT_RC_NOOF_CODES + 19 -#define TOR_IMAGE_DOES_NOT_SUPPORT_DD_LEVEL INFRASTRUCT_RC_NOOF_CODES + 20 -#define TOR_IMAGE_DOES_NOT_SUPPORT_PPE_LEVEL INFRASTRUCT_RC_NOOF_CODES + 21 -#define TOR_BUFFER_TOO_SMALL INFRASTRUCT_RC_NOOF_CODES + 22 -#define TOR_TOO_MANY_DD_LEVELS INFRASTRUCT_RC_NOOF_CODES + 23 -#define TOR_OFFSET_TOO_BIG INFRASTRUCT_RC_NOOF_CODES + 24 -#define TOR_NO_RINGS_FOR_VARIANT INFRASTRUCT_RC_NOOF_CODES + 25 -#define TOR_SCOM_ADDR_NOT_FOUND INFRASTRUCT_RC_NOOF_CODES + 26 -#define TOR_RING_NAME_NOT_FOUND INFRASTRUCT_RC_NOOF_CODES + 27 +#define TOR_RING_NOT_FOUND INFRASTRUCT_RC_NOOF_CODES + 10 +#define TOR_AMBIGUOUS_API_PARMS INFRASTRUCT_RC_NOOF_CODES + 11 +#define TOR_SECTION_NOT_FOUND INFRASTRUCT_RC_NOOF_CODES + 12 +#define TOR_DD_LEVEL_NOT_FOUND INFRASTRUCT_RC_NOOF_CODES + 13 +#define TOR_OP_BUFFER_INVALID INFRASTRUCT_RC_NOOF_CODES + 14 +#define TOR_OP_BUFFER_SIZE_EXCEEDED INFRASTRUCT_RC_NOOF_CODES + 15 +#define TOR_IMAGE_DOES_NOT_SUPPORT_CME INFRASTRUCT_RC_NOOF_CODES + 16 +#define TOR_IMAGE_DOES_NOT_SUPPORT_SGPE INFRASTRUCT_RC_NOOF_CODES + 17 +#define TOR_IMAGE_DOES_NOT_SUPPORT_DD_LEVEL INFRASTRUCT_RC_NOOF_CODES + 18 +#define TOR_IMAGE_DOES_NOT_SUPPORT_PPE_LEVEL INFRASTRUCT_RC_NOOF_CODES + 19 +#define TOR_RING_AVAILABLE_IN_RINGSECTION INFRASTRUCT_RC_NOOF_CODES + 20 +#define TOR_BUFFER_TOO_SMALL INFRASTRUCT_RC_NOOF_CODES + 21 +#define TOR_TOO_MANY_DD_LEVELS INFRASTRUCT_RC_NOOF_CODES + 22 +#define TOR_OFFSET_TOO_BIG INFRASTRUCT_RC_NOOF_CODES + 23 +#define TOR_NO_RINGS_FOR_VARIANT INFRASTRUCT_RC_NOOF_CODES + 24 #ifndef __HOSTBOOT_MODULE // Only needed by ring_apply in EKB int ringid_get_raw_ring_file_path( uint32_t i_magic, @@ -324,100 +336,27 @@ int ringid_get_raw_ring_file_path( uint32_t i_magic, char* io_directory ); #endif -// This function returns the main ring properties list associated w/the chip ID. -int ringid_get_ringProps( ChipId_t i_chipId, - RingProperties_t** o_ringProps ); - -int ringid_get_chipletProps( ChipId_t i_chipId, - uint32_t i_torMagic, - uint8_t i_torVersion, - ChipletType_t i_chipletType, // Ignored if one chiplet in torMagic - ChipletData_t** o_chipletData, - uint8_t* o_numVariants); - -int ringid_get_num_ring_ids( ChipId_t i_chipId, - RingId_t* o_numRingIds); - -int ringid_get_num_chiplets( ChipId_t i_chipId, - uint32_t i_torMagic, - uint8_t* o_numChiplets ); - -// This function returns the scanScomAddr associated with the ringId. -int ringid_get_scanScomAddr( ChipId_t i_chipId, - RingId_t i_ringId, - uint32_t* o_scanScomAddr ); - -// This fumction returns the ringClass associated with the ringId. -int ringid_get_ringClass( ChipId_t i_chipId, - RingId_t i_ringId, - RingClass_t* o_ringClass ); - -// Check for valid chip ID and ring ID. -int ringid_check_ringId( ChipId_t i_chipId, - RingId_t i_ringId ); - -// Check and resolve the effective chipletType's index in a given TOR magic ring section -int ringid_get_chipletIndex( ChipId_t i_chipId, - uint32_t i_torMagic, - ChipletType_t i_chipletType, - ChipletType_t* o_chipletIndex ); - -#if !defined(__PPE__) && !defined(NO_STD_LIB_IN_PPE) && !defined(__HOSTBOOT_MODULE) && !defined(FIPSODE) - -// The following prototypes are needed by the initCompiler and so it's practical to use C++ -// features. - -#include -#include - -extern std::map chipIdIsMap; -extern std::map chipTypeIsMap; -extern std::map chipIdIcToIsMap; - -// This function returns the root ringId of a given scanScomAddr. -// Notes: -// - The "root" ringId is the ringId which has a ringName identical to that associated with the -// scanScomAddr in the engineering data (engd). -// - In IS's ring list, we can have multiple ringId for the same scanScomAddr since a ring may have -// multiple variations of itself, e.g. due to different frequency, filter or FSM settings, and -// which are identified through an "_bucket" extension on their ringName. All those rings, -// however, are non-ROOT_RINGs. -// - If the fully "qualified" unique ringId is required, then use ringidGetRingId1() and supply -// the ringName instead of the scanScomAddr. -// -int ringidGetRootRingId( ChipId_t i_chipId, - uint32_t i_scanScomAddr, - RingId_t& o_ringId, - bool i_bTest = false ); - -// This function returns the ringId associated with the ringName. -int ringidGetRingId1( ChipId_t i_chipId, - std::string i_ringName, - RingId_t& o_ringId, - bool i_bTest = false ); - -// This function returns the ringId associated with the effective ring index within a chiplet. -// (Note that "effective" means the index is void of the instance marker bit.) -int ringidGetRingId2( ChipId_t i_chipId, - uint32_t i_torMagic, - ChipletType_t i_chipletType, // Ignored if only one chiplet in torMagic - uint8_t i_idxRing, // The eEffective ring index within chiplet's - // common or instance ring section - MyBool_t i_bInstCase, // =0 common ring, =1 instance ring - RingId_t& o_ringId, - bool i_bTest = false ); - -// This function returns the ringName associated with the ringId. -int ringidGetRingName( ChipId_t i_chipId, - RingId_t i_ringId, - std::string& o_ringName ); - -// This fumction returns the ringClass associated with the ringId. -int ringidGetRingClass( ChipId_t i_chipId, - RingId_t i_ringId, - RingClass_t& o_ringClass ); - -#endif // __PPE__ && NO_STD_LIB_IN_PPE +int ringid_get_noof_ring_ids( ChipType_t i_chipType, + RingId_t* o_numRingIds); + +int ringid_get_noof_chiplets( ChipType_t i_chipType, + uint32_t i_torMagic, + uint8_t* o_numChiplets ); + +int ringid_get_ring_list( ChipType_t i_chipType, + RingId_t i_ringId, + GenRingIdList** o_ringIdList); + +int ringid_get_properties( ChipType_t i_chipType, + uint32_t i_torMagic, + uint8_t i_torVersion, + ChipletType_t i_chipletType, + ChipletData_t** o_chipletData, + GenRingIdList** o_ringIdListCommon, + GenRingIdList** o_ringIdListInstance, + RingVariantOrder** o_ringVariantOrder, + RingProperties_t** o_ringProps, + uint8_t* o_numVariants); #endif // _COMMON_RINGID_H_ -- cgit v1.2.1