diff options
Diffstat (limited to 'src/usr/hdat')
| -rw-r--r-- | src/usr/hdat/hdatiohub.C | 41 | ||||
| -rwxr-xr-x | src/usr/hdat/hdatiohub.H | 3 | ||||
| -rwxr-xr-x | src/usr/hdat/hdatmsarea.H | 4 | ||||
| -rwxr-xr-x | src/usr/hdat/hdatmsvpd.C | 1738 | ||||
| -rwxr-xr-x | src/usr/hdat/hdatmsvpd.H | 45 | ||||
| -rw-r--r-- | src/usr/hdat/hdatpcrd.C | 6 | ||||
| -rw-r--r-- | src/usr/hdat/hdatutil.C | 84 | ||||
| -rwxr-xr-x | src/usr/hdat/hdatutil.H | 11 | ||||
| -rwxr-xr-x | src/usr/hdat/hdatvpd.C | 5 |
9 files changed, 1461 insertions, 476 deletions
diff --git a/src/usr/hdat/hdatiohub.C b/src/usr/hdat/hdatiohub.C index ea0a3ff54..c9be567ff 100644 --- a/src/usr/hdat/hdatiohub.C +++ b/src/usr/hdat/hdatiohub.C @@ -75,6 +75,18 @@ const HdatKeywordInfo l_pvpdKeywords[] = { PVPD::PF, "PF" }, }; +vpdData pvpdDataAxone[] = +{ + { PVPD::OPFR, PVPD::VP }, + { PVPD::OPFR, PVPD::VS }, +}; + +const HdatKeywordInfo l_pvpdKeywordsAxone[] = +{ + { PVPD::VP, "VP" }, + { PVPD::VS, "VS" }, +}; + extern trace_desc_t *g_trac_hdat; const uint32_t HDAT_MULTIPLE = 16; @@ -651,13 +663,28 @@ errlHndl_t HdatIoHubFru::addDaughterCard(uint32_t i_resourceId, // told to allow for on the constructor if (iv_actDaughterCnt < iv_maxDaughters) { + //Get the processor model + auto l_model = TARGETING::targetService().getProcessorModel(); + if ( l_vpdType == FRU_BP ) { - - uint32_t i_num = sizeof(mvpdData)/sizeof(mvpdData[0]); - l_vpdObj = new HdatVpd(l_errlHndl, i_resourceId,i_target, - HDAT_KID_STRUCT_NAME,i_index,BP, - mvpdData,i_num,l_pvpdKeywords); + //@TODO:RTC 213229(Remove HDAT hack or Axone) + //Check whether the code can be more fault tolerant by avoiding + //model check + if(l_model == TARGETING::MODEL_NIMBUS) + { + uint32_t i_num = sizeof(mvpdData)/sizeof(mvpdData[0]); + l_vpdObj = new HdatVpd(l_errlHndl, i_resourceId,i_target, + HDAT_KID_STRUCT_NAME,i_index,BP, + mvpdData,i_num,l_pvpdKeywords); + } + else if(l_model == TARGETING::MODEL_AXONE) + { + uint32_t i_num = sizeof(pvpdDataAxone)/sizeof(pvpdDataAxone[0]); + l_vpdObj = new HdatVpd(l_errlHndl, i_resourceId,i_target, + HDAT_KID_STRUCT_NAME,i_index,BP, + pvpdDataAxone,i_num,l_pvpdKeywordsAxone); + } } //@TODO: RTC 148660 pci slots and cards @@ -898,6 +925,10 @@ errlHndl_t hdatLoadIoData(const hdatMsAddr_t &i_msAddr, { l_hub->hdatModuleId = HDAT_MODULE_TYPE_ID_NIMBUS_LAGRANGE; } + else if(l_model == TARGETING::MODEL_AXONE) + { + l_hub->hdatModuleId = HDAT_MODULE_TYPE_ID_AXONE_HOPPER; + } else if(l_model == TARGETING::MODEL_CUMULUS) { l_hub->hdatModuleId = HDAT_MODULE_TYPE_ID_CUMULUS_DUOMO; diff --git a/src/usr/hdat/hdatiohub.H b/src/usr/hdat/hdatiohub.H index 14c3a8524..9823c9146 100755 --- a/src/usr/hdat/hdatiohub.H +++ b/src/usr/hdat/hdatiohub.H @@ -5,7 +5,7 @@ /* */ /* OpenPOWER HostBoot Project */ /* */ -/* Contributors Listed Below - COPYRIGHT 2016,2017 */ +/* Contributors Listed Below - COPYRIGHT 2016,2019 */ /* [+] International Business Machines Corp. */ /* */ /* */ @@ -273,6 +273,7 @@ enum hdatHubStatus //@TODO:RTC 166789: Need to access the module type from HB targeting model #define HDAT_MODULE_TYPE_ID_NIMBUS_LAGRANGE 0x0022 #define HDAT_MODULE_TYPE_ID_CUMULUS_DUOMO 0x0030 +#define HDAT_MODULE_TYPE_ID_AXONE_HOPPER 0x0040 diff --git a/src/usr/hdat/hdatmsarea.H b/src/usr/hdat/hdatmsarea.H index f39ad3737..82d454d54 100755 --- a/src/usr/hdat/hdatmsarea.H +++ b/src/usr/hdat/hdatmsarea.H @@ -5,7 +5,7 @@ /* */ /* OpenPOWER HostBoot Project */ /* */ -/* Contributors Listed Below - COPYRIGHT 2016,2017 */ +/* Contributors Listed Below - COPYRIGHT 2016,2019 */ /* [+] International Business Machines Corp. */ /* */ /* */ @@ -51,7 +51,7 @@ namespace HDAT /* Constants */ /*----------------------------------------------------------------------------*/ -const uint16_t HDAT_MS_AREA_VERSION = 0x30; +const uint16_t HDAT_MS_AREA_VERSION = 0x50; const char HDAT_MSAREA_STRUCT_NAME[] = "MSAREA"; /** @brief Since the size of each MS Area must the same as all others, the diff --git a/src/usr/hdat/hdatmsvpd.C b/src/usr/hdat/hdatmsvpd.C index e5593db3d..711900766 100755 --- a/src/usr/hdat/hdatmsvpd.C +++ b/src/usr/hdat/hdatmsvpd.C @@ -5,7 +5,7 @@ /* */ /* OpenPOWER HostBoot Project */ /* */ -/* Contributors Listed Below - COPYRIGHT 2016,2018 */ +/* Contributors Listed Below - COPYRIGHT 2016,2019 */ /* [+] International Business Machines Corp. */ /* */ /* */ @@ -1013,8 +1013,13 @@ errlHndl_t HdatMsVpd::hdatLoadMsData(uint32_t &o_size, uint32_t &o_count) l_addr_range.lo = 0x0; l_end = l_addr_range; + //Get the processor model + auto l_model = TARGETING::targetService().getProcessorModel(); + uint32_t l_sizeConfigured = 0; - uint64_t l_maxMsAddr = hdatGetMaxMemConfiguredAddress(); + + uint64_t l_maxMsAddr = + hdatGetMaxMemConfiguredAddress(l_model); hdatMsAddr_t l_tmpMaxMsAddr; l_tmpMaxMsAddr.hi = (l_maxMsAddr & 0xFFFFFFFF00000000ull) >> 32; @@ -1037,10 +1042,19 @@ errlHndl_t HdatMsVpd::hdatLoadMsData(uint32_t &o_size, uint32_t &o_count) TARGETING::ATTR_MAX_MCS_PER_SYSTEM_type l_maxMsAreas = l_pSysTarget->getAttr<TARGETING::ATTR_MAX_MCS_PER_SYSTEM>(); + if (l_model == TARGETING::MODEL_NIMBUS) + { + l_maxMsAreas *= 2; + } + else + { + l_maxMsAreas = HDAT_MAX_MSAREA_AXONE; + } + // Initialize the MS vpd class // TODO : RTC Story 166994 to set the maximum number of Ms Area entries // from new attribute - hdatInit(l_tmpMaxMsAddr,l_tmpMaxMsAddr,l_sizeConfigured,l_maxMsAreas*2, + hdatInit(l_tmpMaxMsAddr,l_tmpMaxMsAddr,l_sizeConfigured,l_maxMsAreas, l_mostSigAffinityDomain_x,l_ueCount,l_mirroringBaseAddress_x); TARGETING::ATTR_XSCOM_BASE_ADDRESS_type l_xscomAddr = @@ -1056,7 +1070,9 @@ errlHndl_t HdatMsVpd::hdatLoadMsData(uint32_t &o_size, uint32_t &o_count) setXSCOM(l_hdatXscomAddr); } + // This contains the MS Area Index uint32_t l_index = 0; + //for each proc/ memory controller in the system TARGETING::PredicateCTM l_procPred(TARGETING::CLASS_CHIP, TARGETING::TYPE_PROC); @@ -1080,73 +1096,6 @@ errlHndl_t HdatMsVpd::hdatLoadMsData(uint32_t &o_size, uint32_t &o_count) TARGETING::ATTR_ORDINAL_ID_type l_procChipId = l_pProcTarget->getAttr<TARGETING::ATTR_ORDINAL_ID>(); - - //For each MCA - TARGETING::PredicateCTM l_allMca(TARGETING::CLASS_UNIT, - TARGETING::TYPE_MCA); - TARGETING::PredicateHwas l_funcMca; - l_funcMca.functional(true); - TARGETING::PredicatePostfixExpr l_allFuncMca; - l_allFuncMca.push(&l_allMca).push(&l_funcMca).And(); - - TARGETING::TargetHandleList l_mcaList; - - TARGETING::targetService(). - getAssociated(l_mcaList, l_pProcTarget, - TARGETING::TargetService::CHILD, - TARGETING::TargetService::ALL, &l_allFuncMca); - - TARGETING::ATTR_PROC_MEM_BASES_type l_procMemBases = {0}; - assert(l_pProcTarget-> - tryGetAttr<TARGETING::ATTR_PROC_MEM_BASES>(l_procMemBases)); - - //Sharing count for each group - TARGETING::ATTR_MSS_MEM_MC_IN_GROUP_type l_mcaSharingCount = {0}; - - //Group ID for each group, group id will be assigned only - //if the group is shared - TARGETING::ATTR_MSS_MEM_MC_IN_GROUP_type l_mcsSharingGrpIds = {0}; - - //Size configured under each group - TARGETING::ATTR_PROC_MEM_SIZES_type l_procMemSizesBytes = {0}; - - assert(l_pProcTarget->tryGetAttr<TARGETING::ATTR_PROC_MEM_SIZES> - (l_procMemSizesBytes)); - - - - for(uint32_t l_mcaIdx = 0; l_mcaIdx<l_mcaList.size(); - ++l_mcaIdx) - { - uint32_t l_mcaInGrp = 0; - TARGETING::Target *l_pMcaTarget = - l_mcaList[l_mcaIdx]; - if(!hdatFindGroupForMc(l_pProcTarget, - l_pMcaTarget, - l_mcaInGrp)) - { - //Skip this MCA is not in any group - continue; - } - - //Increment sharing count if mem configured under group. - if(l_procMemSizesBytes[l_mcaInGrp] > 0) - { - l_mcaSharingCount[l_mcaInGrp]++; - - //Assign sharing group id only if shared - //And only when first instance of sharing is found - if(l_mcaSharingCount[l_mcaInGrp] == - HDAT_MIN_NUM_FOR_SHARING) - { - l_mcsSharingGrpIds[l_mcaInGrp] = - l_nxtSharingGroupId; - l_nxtSharingGroupId++; - } - } - } - - // TODO : RTC Story 159682 // Further CHTM support needs to be added which contains the trace // array for 24 cores @@ -1154,14 +1103,14 @@ errlHndl_t HdatMsVpd::hdatLoadMsData(uint32_t &o_size, uint32_t &o_count) hdatMsAddr_t l_hdatNhtmEndAddr; TARGETING::ATTR_PROC_NHTM_BAR_BASE_ADDR_type l_nhtmStartAddr = - l_pProcTarget->getAttr<TARGETING::ATTR_PROC_NHTM_BAR_BASE_ADDR>(); + l_pProcTarget->getAttr<TARGETING::ATTR_PROC_NHTM_BAR_BASE_ADDR>(); TARGETING::ATTR_PROC_NHTM_BAR_SIZE_type l_nhtmSize = l_pProcTarget->getAttr<TARGETING::ATTR_PROC_NHTM_BAR_SIZE>(); if( 0 != l_nhtmSize ) { l_hdatNhtmStartAddr.hi = - (l_nhtmStartAddr & 0xFFFFFFFF00000000ull) >> 32; + (l_nhtmStartAddr & 0xFFFFFFFF00000000ull) >> 32; l_hdatNhtmStartAddr.lo = l_nhtmStartAddr & 0x00000000FFFFFFFFull; l_hdatNhtmStartAddr.hi |= HDAT_REAL_ADDRESS_MASK; @@ -1185,433 +1134,1108 @@ errlHndl_t HdatMsVpd::hdatLoadMsData(uint32_t &o_size, uint32_t &o_count) l_nhtmSize); } + TARGETING::ATTR_PROC_MEM_BASES_type l_procMemBases = {0}; + assert(l_pProcTarget-> + tryGetAttr<TARGETING::ATTR_PROC_MEM_BASES>(l_procMemBases)); + + TARGETING::ATTR_PROC_MIRROR_BASES_type l_MirrorAddr = {0}; + assert(l_pProcTarget->tryGetAttr< + TARGETING::ATTR_PROC_MIRROR_BASES>(l_MirrorAddr)); + + TARGETING::ATTR_PROC_MIRROR_SIZES_type l_MirrorSize = {0}; + assert(l_pProcTarget->tryGetAttr< + TARGETING::ATTR_PROC_MIRROR_SIZES>(l_MirrorSize)); + + TARGETING::ATTR_PAYLOAD_IN_MIRROR_MEM_type l_payLoadMirrorMem = + l_pSysTarget->getAttr<TARGETING::ATTR_PAYLOAD_IN_MIRROR_MEM>(); + + if(l_model == TARGETING::MODEL_NIMBUS) + { + //Sharing count for each group + TARGETING::ATTR_MSS_MEM_MC_IN_GROUP_type l_mcaSharingCount + = {0}; + + //Group ID for each group, group id will be assigned only + //if the group is shared + TARGETING::ATTR_MSS_MEM_MC_IN_GROUP_type l_mcsSharingGrpIds + = {0}; + + //Size configured under each group + TARGETING::ATTR_PROC_MEM_SIZES_type l_procMemSizesBytes = {0}; + + assert(l_pProcTarget->tryGetAttr<TARGETING::ATTR_PROC_MEM_SIZES> + (l_procMemSizesBytes)); + + //For each MCA + TARGETING::PredicateCTM l_allMca(TARGETING::CLASS_UNIT, + TARGETING::TYPE_MCA); + TARGETING::PredicateHwas l_funcMca; + l_funcMca.functional(true); + TARGETING::PredicatePostfixExpr l_allFuncMca; + l_allFuncMca.push(&l_allMca).push(&l_funcMca).And(); - TARGETING::PredicateCTM l_mcbistPredicate(TARGETING::CLASS_UNIT, + TARGETING::TargetHandleList l_mcaList; + + TARGETING::targetService(). + getAssociated(l_mcaList, l_pProcTarget, + TARGETING::TargetService::CHILD, + TARGETING::TargetService::ALL, &l_allFuncMca); + + for(uint32_t l_mcaIdx = 0; l_mcaIdx<l_mcaList.size(); + ++l_mcaIdx) + { + uint32_t l_mcaInGrp = 0; + TARGETING::Target *l_pMcaTarget = + l_mcaList[l_mcaIdx]; + if(!hdatFindGroupForMc(l_pProcTarget, + l_pMcaTarget, + l_mcaInGrp)) + { + //Skip this MCA is not in any group + continue; + } + + //Increment sharing count if mem configured under group. + if(l_procMemSizesBytes[l_mcaInGrp] > 0) + { + l_mcaSharingCount[l_mcaInGrp]++; + + //Assign sharing group id only if shared + //And only when first instance of sharing is found + if(l_mcaSharingCount[l_mcaInGrp] == + HDAT_MIN_NUM_FOR_SHARING) + { + l_mcsSharingGrpIds[l_mcaInGrp] = + l_nxtSharingGroupId; + l_nxtSharingGroupId++; + } + } + } + + TARGETING::PredicateCTM l_mcbistPredicate(TARGETING::CLASS_UNIT, TARGETING::TYPE_MCBIST); - TARGETING::PredicatePostfixExpr l_presentMcbist; + TARGETING::PredicatePostfixExpr l_presentMcbist; l_presentMcbist.push(&l_mcbistPredicate). push(&l_predHwasFunc).And(); - TARGETING::TargetHandleList l_mcbistList; + TARGETING::TargetHandleList l_mcbistList; - // Find Associated MCBIST list - TARGETING::targetService().getAssociated(l_mcbistList, + // Find Associated MCBIST list + TARGETING::targetService().getAssociated(l_mcbistList, l_pProcTarget, TARGETING::TargetService::CHILD_BY_AFFINITY, TARGETING::TargetService::ALL, &l_presentMcbist); - //scan all mcbist in this proc - for(uint32_t l_mcbistIdx =0; - l_mcbistIdx < l_mcbistList.size(); - ++l_mcbistIdx) - { - TARGETING::Target *l_pMcbistTarget = l_mcbistList[l_mcbistIdx]; - - TARGETING::PredicateCTM l_mcsPredicate(TARGETING::CLASS_UNIT, - TARGETING::TYPE_MCS); + //scan all mcbist in this proc + for(uint32_t l_mcbistIdx =0; + l_mcbistIdx < l_mcbistList.size(); + ++l_mcbistIdx) + { + TARGETING::Target *l_pMcbistTarget = + l_mcbistList[l_mcbistIdx]; - TARGETING::PredicatePostfixExpr l_funcMcs; + TARGETING::PredicateCTM l_mcsPredicate( + TARGETING::CLASS_UNIT, + TARGETING::TYPE_MCS); + + TARGETING::PredicatePostfixExpr l_funcMcs; l_funcMcs.push(&l_mcsPredicate).push(&l_predHwasFunc).And(); - TARGETING::TargetHandleList l_mcsList; + TARGETING::TargetHandleList l_mcsList; - // Find Associated memory controllers - TARGETING::targetService().getAssociated(l_mcsList, + // Find Associated memory controllers + TARGETING::targetService().getAssociated(l_mcsList, l_pMcbistTarget, TARGETING::TargetService::CHILD, TARGETING::TargetService::ALL, &l_funcMcs); - uint32_t l_memBusFreq = getMemBusFreq(l_pMcbistTarget); + uint32_t l_memBusFreq = getMemBusFreq(l_pMcbistTarget); - //scan all mcs in this proc to get sharing counit - for(uint32_t l_mcsIdx = 0;l_mcsIdx<l_mcsList.size(); ++l_mcsIdx) - { - TARGETING::Target *l_pMcsTarget = l_mcsList[l_mcsIdx]; + //scan all mcs in this proc to get sharing counit + for(uint32_t l_mcsIdx = 0;l_mcsIdx<l_mcsList.size(); + ++l_mcsIdx) + { + TARGETING::Target *l_pMcsTarget = l_mcsList[l_mcsIdx]; - //for each MCA connected to this this MCS - TARGETING::PredicateCTM l_mcaPredicate( - TARGETING::CLASS_UNIT, TARGETING::TYPE_MCA); + //for each MCA connected to this this MCS + TARGETING::PredicateCTM l_mcaPredicate( + TARGETING::CLASS_UNIT, TARGETING::TYPE_MCA); - TARGETING::PredicateHwas l_predMca; - l_predMca.present(true); - TARGETING::PredicatePostfixExpr l_presentMca; - l_presentMca.push(&l_mcaPredicate).push(&l_predMca).And(); - TARGETING::TargetHandleList l_mcaList; + TARGETING::PredicateHwas l_predMca; + l_predMca.present(true); + TARGETING::PredicatePostfixExpr l_presentMca; + l_presentMca.push(&l_mcaPredicate). + push(&l_predMca).And(); + TARGETING::TargetHandleList l_mcaList; - // Get associated MCAs - TARGETING::targetService(). - getAssociated(l_mcaList, l_pMcsTarget, - TARGETING::TargetService::CHILD_BY_AFFINITY, - TARGETING::TargetService::ALL, &l_presentMca); + // Get associated MCAs + TARGETING::targetService(). + getAssociated(l_mcaList, l_pMcsTarget, + TARGETING::TargetService::CHILD_BY_AFFINITY, + TARGETING::TargetService::ALL, &l_presentMca); - for(uint32_t l_mcaIdx = 0; l_mcaIdx<l_mcaList.size(); - ++l_mcaIdx) - { - TARGETING::Target *l_pMcaTarget = - l_mcaList[l_mcaIdx]; + for(uint32_t l_mcaIdx = 0; l_mcaIdx<l_mcaList.size(); + ++l_mcaIdx) + { + TARGETING::Target *l_pMcaTarget = + l_mcaList[l_mcaIdx]; - //Group which this MCA is belonging - uint32_t l_mcaInGrp = 0; + //Group which this MCA is belonging + uint32_t l_mcaInGrp = 0; - if(!hdatFindGroupForMc(l_pProcTarget, - l_pMcaTarget, - l_mcaInGrp)) - { - HDAT_INF("No group found for MCA"); - //Skip this MCS is not under any group - continue; - } - uint32_t l_mcaFruId = 0; - hdatMemParentType l_parentType= HDAT_MEM_PARENT_CEC_FRU; - - std::list<hdatRamArea> l_areas; - l_areas.clear(); - uint32_t l_areaSizeInMB = 0; - bool l_areaFunctional = false; - uint32_t l_numDimms =0; - - l_err = hdatScanDimms(l_pMcaTarget, - l_pMcsTarget, - l_mcaFruId, - l_areas, - l_areaSizeInMB, - l_numDimms, - l_areaFunctional, - l_parentType); - - if(NULL != l_err) - { - HDAT_ERR("Error in calling Scan Dimms"); - break; - } + if(!hdatFindGroupForMc(l_pProcTarget, + l_pMcaTarget, + l_mcaInGrp)) + { + HDAT_INF("No group found for MCA"); + //Skip this MCS is not under any group + continue; + } + uint32_t l_mcaFruId = 0; + hdatMemParentType l_parentType = + HDAT_MEM_PARENT_CEC_FRU; + + std::list<hdatRamArea> l_areas; + l_areas.clear(); + uint32_t l_areaSizeInMB = 0; + bool l_areaFunctional = false; + uint32_t l_numDimms =0; + + l_err = hdatScanDimms(l_pMcaTarget, + l_pMcsTarget, + l_mcaFruId, + l_areas, + l_areaSizeInMB, + l_numDimms, + l_areaFunctional, + l_parentType); - HDAT_INF("l_areaSizeInMB:0x%.8X l_numDimms:0x%.8X " - "l_areas.size():0x%.8X", l_areaSizeInMB, l_numDimms, - l_areas.size()); + if(NULL != l_err) + { + HDAT_ERR("Error in calling Scan Dimms"); + break; + } - //Skip if no memory configured under this MCS - if(l_areaSizeInMB == 0) - { - continue; - } + HDAT_INF("l_areaSizeInMB:0x%.8X l_numDimms:0x%.8X " + "l_areas.size():0x%.8X", l_areaSizeInMB, + l_numDimms, l_areas.size()); + + //Skip if no memory configured under this MCS + if(l_areaSizeInMB == 0) + { + continue; + } - uint32_t l_maxMemBlocks = 0; - l_err = + uint32_t l_maxMemBlocks = 0; + l_err = hdatGetMaxMemoryBlocks(l_pMcsTarget,l_maxMemBlocks); - if(NULL != l_err) - { - HDAT_ERR("Error error in get max blocks"); - break; - } + if(NULL != l_err) + { + HDAT_ERR("Error error in get max blocks"); + break; + } - TARGETING::ATTR_SLCA_RID_type l_procRid = + TARGETING::ATTR_SLCA_RID_type l_procRid = l_pProcTarget->getAttr<TARGETING::ATTR_SLCA_RID>(); - TARGETING::ATTR_SLCA_INDEX_type l_procSlcaIndex = - l_pProcTarget->getAttr<TARGETING::ATTR_SLCA_INDEX>(); - + TARGETING::ATTR_SLCA_INDEX_type l_procSlcaIndex = + l_pProcTarget->getAttr + <TARGETING::ATTR_SLCA_INDEX>(); - l_err = addMsAreaFru(l_procRid, - l_procSlcaIndex, - l_pProcTarget, - l_index, - l_numDimms, - MAX_CHIP_EC_CNT_PER_MSAREA, - l_maxMemBlocks); + l_err = addMsAreaFru(l_procRid, + l_procSlcaIndex, + l_pProcTarget, + l_index, + l_numDimms, + MAX_CHIP_EC_CNT_PER_MSAREA, + l_maxMemBlocks); - if(NULL != l_err) - { - HDAT_ERR("Error adding MSArea %d" - "Number of Dimms: %d Max Blocks: %d", - l_index, - l_numDimms,l_maxMemBlocks); - break; - } + if(NULL != l_err) + { + HDAT_ERR("Error adding MSArea %d" + "Number of Dimms: %d Max Blocks: %d", + l_index, + l_numDimms,l_maxMemBlocks); + break; + } - uint32_t l_memStatus = 0; - //If group is shared with more than one area - if(l_mcaSharingCount[l_mcaInGrp] >= - HDAT_MIN_NUM_FOR_SHARING) - { - l_memStatus = HDAT_MEM_SHARED; - setMsAreaInterleavedId(l_index, - l_mcsSharingGrpIds[l_mcaInGrp]); - } + uint32_t l_memStatus = 0; + //If group is shared with more than one area + if(l_mcaSharingCount[l_mcaInGrp] >= + HDAT_MIN_NUM_FOR_SHARING) + { + l_memStatus = HDAT_MEM_SHARED; + setMsAreaInterleavedId(l_index, + l_mcsSharingGrpIds[l_mcaInGrp]); + } - setMsAreaType(l_index,l_parentType); - setMsAreaSize(l_index,l_areaSizeInMB); + setMsAreaType(l_index,l_parentType); + setMsAreaSize(l_index,l_areaSizeInMB); - iv_maxSize.hdatTotSize += l_areaSizeInMB; + iv_maxSize.hdatTotSize += l_areaSizeInMB; - l_memStatus |= l_areaFunctional ? - (HDAT_MEM_INSTALLED | HDAT_MEM_FUNCTIONAL) : - HDAT_MEM_INSTALLED; + l_memStatus |= l_areaFunctional ? + (HDAT_MEM_INSTALLED | HDAT_MEM_FUNCTIONAL) : + HDAT_MEM_INSTALLED; - setMsAreaStat(l_index, l_memStatus); + setMsAreaStat(l_index, l_memStatus); - //Add MCS ec level - uint32_t l_mcsEcLevel = 0; - uint32_t l_mcsChipId = 0; - l_err = hdatGetIdEc(l_pMcsTarget, - l_mcsEcLevel, - l_mcsChipId); - if(NULL != l_err) - { - HDAT_ERR("Error in getting MCS ID " + //Add MCS ec level + uint32_t l_mcsEcLevel = 0; + uint32_t l_mcsChipId = 0; + l_err = hdatGetIdEc(l_pMcsTarget, + l_mcsEcLevel, + l_mcsChipId); + if(NULL != l_err) + { + HDAT_ERR("Error in getting MCS ID " "and EC HUID:[0x%08X]", l_pMcsTarget->getAttr<TARGETING::ATTR_HUID>()); - break; - } + break; + } - l_err = addEcEntry(l_index, - l_mcsChipId, - l_mcsEcLevel); - if(NULL != l_err) - { - HDAT_ERR("Error in adding" + l_err = addEcEntry(l_index, + l_mcsChipId, + l_mcsEcLevel); + if(NULL != l_err) + { + HDAT_ERR("Error in adding" " ID[0x%08X] and EC[0x%08X] to ms area" " HUID:[0x%08X]",l_mcsChipId, l_mcsEcLevel, l_pMcsTarget->getAttr<TARGETING::ATTR_HUID>()); - break; - } + break; + } - // Need to get i2c Master data correctly - std::vector<hdatI2cData_t> l_i2cDevEntries; + // Need to get i2c Master data correctly + std::vector<hdatI2cData_t> l_i2cDevEntries; - TARGETING::PredicateCTM l_membufPredicate( - TARGETING::CLASS_CHIP, TARGETING::TYPE_MEMBUF); + TARGETING::PredicateCTM l_membufPredicate( + TARGETING::CLASS_CHIP, TARGETING::TYPE_MEMBUF); - TARGETING::PredicatePostfixExpr l_presentMemBuf; - l_presentMemBuf.push(&l_membufPredicate). + TARGETING::PredicatePostfixExpr l_presentMemBuf; + l_presentMemBuf.push(&l_membufPredicate). push(&l_predHwasPresent).And(); - TARGETING::TargetHandleList l_membufList; + TARGETING::TargetHandleList l_membufList; - // Find Associated membuf - TARGETING::targetService().getAssociated(l_membufList, - l_pMcsTarget, - TARGETING::TargetService::CHILD_BY_AFFINITY, - TARGETING::TargetService::ALL, - &l_presentMemBuf); - //Skip is there is no Membuf attached to this MCS - if(l_membufList.size() > 0) - { - TARGETING::Target *l_pMembufTarget = - l_membufList[0]; - if (l_pMembufTarget != NULL) + // Find Associated membuf + TARGETING::targetService().getAssociated( + l_membufList, + l_pMcsTarget, + TARGETING::TargetService::CHILD_BY_AFFINITY, + TARGETING::TargetService::ALL, + &l_presentMemBuf); + //Skip is there is no Membuf attached to this MCS + if(l_membufList.size() > 0) { - hdatGetI2cDeviceInfo(l_pMembufTarget, - l_i2cDevEntries); + TARGETING::Target *l_pMembufTarget = + l_membufList[0]; + if (l_pMembufTarget != NULL) + { + hdatGetI2cDeviceInfo(l_pMembufTarget, + l_model, + l_i2cDevEntries); + } } - } - setMsaI2cInfo(l_index, l_i2cDevEntries); + setMsaI2cInfo(l_index, l_i2cDevEntries); - std::list<hdatRamArea>::iterator l_area = - l_areas.begin(); + std::list<hdatRamArea>::iterator l_area = + l_areas.begin(); - for (uint32_t l_ramId = 0; - l_area != l_areas.end(); - ++l_ramId, ++l_area) - { - uint32_t l_status = (l_area)->ivFunctional ? + for (uint32_t l_ramId = 0; + l_area != l_areas.end(); + ++l_ramId, ++l_area) + { + uint32_t l_status = (l_area)->ivFunctional ? (HDAT_RAM_INSTALLED | HDAT_RAM_FUNCTIONAL) : HDAT_RAM_INSTALLED; - TARGETING::Target *l_pDimmTarget = - TARGETING::Target::getTargetFromHuid(l_area->ivHuid); - - TARGETING::ATTR_SLCA_RID_type l_dimmRid = - l_pDimmTarget->getAttr<TARGETING::ATTR_SLCA_RID>(); - - TARGETING::ATTR_SLCA_INDEX_type l_dimmSlcaIndex = - l_pDimmTarget->getAttr<TARGETING::ATTR_SLCA_INDEX>(); - - uint32_t l_dimmId = - 1 << (31 - (l_pDimmTarget->getAttr<TARGETING::ATTR_FAPI_POS>() % MAX_DIMMS_PER_MCBIST)); - l_err = addRamFru(l_index, - l_pDimmTarget, - l_dimmRid, - l_dimmSlcaIndex, - l_ramId, - l_status, - (l_area)->ivSize, - l_dimmId, - l_memBusFreq); - - if (l_err) // Failed to add ram fru information - { - HDAT_ERR("Error in adding RAM FRU" - "Index:%d Rid:[0x%08X] status:[0x%08X]" - "Size:[0x%08X] RamID:[0x%08X]", - l_index,(l_area)->ivHuid, - l_status,(l_area)->ivSize,l_ramId); - ERRORLOG::errlCommit(l_err,HDAT_COMP_ID); - - delete l_err; - l_err = NULL; - continue; - } - }//end of RAM list + TARGETING::Target *l_pDimmTarget = + TARGETING::Target::getTargetFromHuid( + l_area->ivHuid); + + TARGETING::ATTR_SLCA_RID_type l_dimmRid = + l_pDimmTarget->getAttr + <TARGETING::ATTR_SLCA_RID>(); + + TARGETING::ATTR_SLCA_INDEX_type l_dimmSlcaIndex= + l_pDimmTarget->getAttr + <TARGETING::ATTR_SLCA_INDEX>(); + + uint32_t l_dimmId = + 1 << (31 - (l_pDimmTarget->getAttr + <TARGETING::ATTR_FAPI_POS>() % + MAX_DIMMS_PER_MCBIST)); + l_err = addRamFru(l_index, + l_pDimmTarget, + l_dimmRid, + l_dimmSlcaIndex, + l_ramId, + l_status, + (l_area)->ivSize, + l_dimmId, + l_memBusFreq); + + if (l_err) // Failed to add ram fru information + { + HDAT_ERR("Error in adding RAM FRU" + "Index:%d Rid:[0x%08X] status:[0x%08X]" + "Size:[0x%08X] RamID:[0x%08X]", + l_index,(l_area)->ivHuid, + l_status,(l_area)->ivSize,l_ramId); + ERRORLOG::errlCommit(l_err,HDAT_COMP_ID); + + delete l_err; + l_err = NULL; + continue; + } + }//end of RAM list - l_addr_range.hi = (l_procMemBases[l_mcaInGrp] & + l_addr_range.hi = (l_procMemBases[l_mcaInGrp] & 0xFFFFFFFF00000000ull) >> 32; - l_addr_range.lo = l_procMemBases[l_mcaInGrp] & + l_addr_range.lo = l_procMemBases[l_mcaInGrp] & 0x00000000FFFFFFFFull; - l_end = l_addr_range; + l_end = l_addr_range; - //Update the range - l_end.hi += (l_procMemSizesBytes[l_mcaInGrp] & + //Update the range + l_end.hi += (l_procMemSizesBytes[l_mcaInGrp] & 0xFFFFFFFF00000000ull) >> 32; - l_end.lo += l_procMemSizesBytes[l_mcaInGrp] & + l_end.lo += l_procMemSizesBytes[l_mcaInGrp] & 0x00000000FFFFFFFFull; - HDAT_INF("MCS:0x%08X l_addr_range:0x%08X 0x%08X" - " l_end:0x%08X 0x%08X", - l_pMcsTarget->getAttr<TARGETING::ATTR_HUID>(), - l_addr_range.hi, l_addr_range.lo, - l_end.hi,l_end.lo); - - uint64_t l_hdatMirrorAddr_x = 0x0ull; - uint64_t l_hdatMirrorAddr = 0x0ull; - uint32_t l_hdatMemcntrlID = 0x0 ; - uint8_t l_hdatMirrorAlogrithm = 0xFF; - bool l_rangeIsMirrorable = false; - - TARGETING::ATTR_PROC_MIRROR_BASES_type - l_MirrorAddr = {0}; - assert(l_pProcTarget->tryGetAttr< - TARGETING::ATTR_PROC_MIRROR_BASES>(l_MirrorAddr)); - - TARGETING::ATTR_PROC_MIRROR_SIZES_type - l_MirrorSize = {0}; - assert(l_pProcTarget->tryGetAttr< - TARGETING::ATTR_PROC_MIRROR_SIZES>(l_MirrorSize)); - - uint64_t l_startAddr = + HDAT_INF("MCS:0x%08X l_addr_range:0x%08X 0x%08X" + " l_end:0x%08X 0x%08X", + l_pMcsTarget->getAttr<TARGETING::ATTR_HUID>(), + l_addr_range.hi, l_addr_range.lo, + l_end.hi,l_end.lo); + + uint64_t l_hdatMirrorAddr_x = 0x0ull; + uint64_t l_hdatMirrorAddr = 0x0ull; + uint32_t l_hdatMemcntrlID = 0x0 ; + uint8_t l_hdatMirrorAlogrithm = 0xFF; + bool l_rangeIsMirrorable = false; + + //Calculate the mirror address and related data + uint64_t l_startAddr = (((uint64_t)(l_addr_range.hi) << 32 ) | (uint64_t)(l_addr_range.lo)); - l_hdatMirrorAddr_x = - (l_startAddr / 2) + l_mirrorBaseAddress_x; + l_hdatMirrorAddr_x = + (l_startAddr / 2) + l_mirrorBaseAddress_x; - TARGETING::ATTR_PAYLOAD_IN_MIRROR_MEM_type - l_payLoadMirrorMem = - l_pSysTarget->getAttr< - TARGETING::ATTR_PAYLOAD_IN_MIRROR_MEM>(); + HDAT_INF( + "Start add : 0x%016llX MirrorBase : 0x%016llX" + " MirrorAddr : 0x%016llX PayLoadMirrorMem : 0x%X", + l_startAddr, l_mirrorBaseAddress_x, + l_hdatMirrorAddr_x, l_payLoadMirrorMem); - HDAT_INF( - "Start add : 0x%016llX MirrorBase : 0x%016llX" - " MirrorAddr : 0x%016llX PayLoadMirrorMem : 0x%X", - l_startAddr, l_mirrorBaseAddress_x, - l_hdatMirrorAddr_x, l_payLoadMirrorMem); - - if ( 0 != l_payLoadMirrorMem ) - { - for ( int idx=0 ; idx < - (int)(sizeof(TARGETING::ATTR_PROC_MIRROR_SIZES_type) - / sizeof(uint64_t)) ; idx++ ) + if ( 0 != l_payLoadMirrorMem ) { - HDAT_INF("Mirror size : 0x%016llX" - " MirrorAddr[idx] : 0x%016llX" - " hdatMirrorAddr_x : 0x%016llX", - l_MirrorSize[idx], l_MirrorAddr[idx], - l_hdatMirrorAddr_x); + for ( int idx=0 ; idx < + (int) + (sizeof(TARGETING::ATTR_PROC_MIRROR_SIZES_type) + / sizeof(uint64_t)) ; idx++ ) + { + HDAT_INF("Mirror size : 0x%016llX" + " MirrorAddr : 0x%016llX" + " hdatMirrorAddr_x : 0x%016llX", + l_MirrorSize[idx], l_MirrorAddr[idx], + l_hdatMirrorAddr_x); - if( (0 != l_MirrorSize[idx]) && + if( (0 != l_MirrorSize[idx]) && (l_MirrorAddr[idx] == l_hdatMirrorAddr_x) ) - { - l_rangeIsMirrorable = true; - l_hdatMirrorAddr = l_MirrorAddr[idx] + { + l_rangeIsMirrorable = true; + l_hdatMirrorAddr = l_MirrorAddr[idx] | HDAT_REAL_ADDRESS_MASK64; - break; + break; + } } } - } - if(l_pProcTarget->getAttr<TARGETING::ATTR_MODEL>() == TARGETING::MODEL_NIMBUS) - { + // Set the memory controller ID - l_hdatMemcntrlID |= 1 << (31 - l_pMcbistTarget->getAttr<TARGETING::ATTR_CHIP_UNIT>()); - l_hdatMemcntrlID |= 1 << (31 - (l_pMcsTarget->getAttr<TARGETING::ATTR_CHIP_UNIT>() + 4)); - l_hdatMemcntrlID |= 1 << (31 - (l_pMcaTarget->getAttr<TARGETING::ATTR_CHIP_UNIT>() + 8)); - } - else if(l_pProcTarget->getAttr<TARGETING::ATTR_MODEL>() == TARGETING::MODEL_CUMULUS) - { - //TODO : MEmory controller ID for cumulus need to be defined. - HDAT_INF("Memory controller ID : 0 since this is Cumulus proc"); - } - l_err = addMsAreaAddr(l_index, - l_addr_range, - l_end, - l_procChipId, - l_rangeIsMirrorable, - l_hdatMirrorAlogrithm, - l_hdatMirrorAddr, - l_hdatMemcntrlID); - if(NULL != l_err) + l_hdatMemcntrlID |= + 1 << (31 - l_pMcbistTarget->getAttr + <TARGETING::ATTR_CHIP_UNIT>()); + l_hdatMemcntrlID |= + 1 << (31 - (l_pMcsTarget->getAttr + <TARGETING::ATTR_CHIP_UNIT>() + 4)); + l_hdatMemcntrlID |= + 1 << (31 - (l_pMcaTarget->getAttr + <TARGETING::ATTR_CHIP_UNIT>() + 8)); + + l_err = addMsAreaAddr(l_index, + l_addr_range, + l_end, + l_procChipId, + l_rangeIsMirrorable, + l_hdatMirrorAlogrithm, + l_hdatMirrorAddr, + l_hdatMemcntrlID); + if(NULL != l_err) + { + HDAT_ERR("Error in adding addMsAreaAddr" + " to ms area index[%d]", + l_index); + break; + } + + // TODO : RTC Story 159682 + // Further CHTM support needs to be added which + // contains the trace array for 24 cores + // Reinitializing the NHTM size + + // Don't re-init NHTM size -- only one HTM region + // per proc + uint64_t l_end_hi = l_end.hi; + uint64_t l_end_lo = l_end.lo; + uint64_t l_end_addr = + ((l_end_hi << 32 ) | l_end_lo); + + + uint64_t l_addr_range_hi = l_addr_range.hi; + uint64_t l_addr_range_lo = l_addr_range.lo; + uint64_t l_start_addr = + ((l_addr_range_hi << 32 )| l_addr_range_lo); + + uint64_t l_size_bytes = ((uint64_t)l_areaSizeInMB) * + l_mcaSharingCount[l_mcaInGrp] * 1024 * 1024; + + if((0 != l_nhtmSize) && + (l_size_bytes != (l_end_addr - l_start_addr))) + { + HDAT_INF("NHTM Bar size = 0x%016llX " + " MS area size = 0x%016llX" + " l_end_addr = 0x%016llX" + " l_start_addr = 0x%016llX", + l_nhtmSize,l_size_bytes, l_end_addr, + l_start_addr); + + l_addr_range.lo = l_hdatNhtmStartAddr.lo; + l_addr_range.hi = l_hdatNhtmStartAddr.hi; + + l_end.lo = l_hdatNhtmEndAddr.lo; + l_end.hi = l_hdatNhtmEndAddr.hi; + + l_err = addMsAreaAddr(l_index, + l_addr_range, + l_end, + l_procChipId, + false, 0, 0); + if(NULL != l_err) + { + HDAT_ERR("Error in adding " + " addMsAreaAddr to ms area index[%d]", + l_index); + break; + } + l_nhtmSize=0; //only add 1 entry + } + l_addr_range = l_end; + l_index++; + } //end of mca list + } //end of MCS list + } //end of MCBIST list + } + else //if model is Axone + { + //Sharing count for each group + TARGETING::ATTR_MSS_MEM_MC_IN_GROUP_type l_mccSharingCount + = {0}; + + //Group ID for each group, group id will be assigned only + //if the group is shared + TARGETING::ATTR_MSS_MEM_MC_IN_GROUP_type l_mccSharingGrpIds + = {0}; + + //Size configured under each group + TARGETING::ATTR_PROC_MEM_SIZES_type l_procMemSizesBytes = {0}; + + assert(l_pProcTarget->tryGetAttr<TARGETING::ATTR_PROC_MEM_SIZES> + (l_procMemSizesBytes)); + + //For each MCC + TARGETING::PredicateCTM l_allMcc(TARGETING::CLASS_UNIT, + TARGETING::TYPE_MCC); + TARGETING::PredicateHwas l_funcMcc; + l_funcMcc.functional(true); + TARGETING::PredicatePostfixExpr l_allFuncMcc; + l_allFuncMcc.push(&l_allMcc).push(&l_funcMcc).And(); + + TARGETING::TargetHandleList l_mccList; + + TARGETING::targetService(). + getAssociated(l_mccList, l_pProcTarget, + TARGETING::TargetService::CHILD, + TARGETING::TargetService::ALL, &l_allFuncMcc); + + for(uint32_t l_mccIdx = 0; l_mccIdx<l_mccList.size(); + ++l_mccIdx) + { + uint32_t l_mccInGrp = 0; + + TARGETING::Target *l_pMccTarget = + l_mccList[l_mccIdx]; + if(!hdatFindGroupForMcc(l_pProcTarget, + l_pMccTarget, + l_mccInGrp)) + { + //Skip this MCC is not in any group + continue; + } + + //Increment sharing count if mem configured under group. + if(l_procMemSizesBytes[l_mccInGrp] > 0) + { + l_mccSharingCount[l_mccInGrp]++; + + //Assign sharing group id only if shared + //And only when first instance of sharing is found + if(l_mccSharingCount[l_mccInGrp] == + HDAT_MIN_NUM_FOR_SHARING) { - HDAT_ERR("Error in adding addMsAreaAddr" - " to ms area index[%d]", - l_index); - break; + l_mccSharingGrpIds[l_mccInGrp] = + l_nxtSharingGroupId; + l_nxtSharingGroupId++; } + } + } - // TODO : RTC Story 159682 - // Further CHTM support needs to be added which contains - // the trace array for 24 cores - // Reinitializing the NHTM size + TARGETING::PredicateCTM l_mcPredicate(TARGETING::CLASS_UNIT, + TARGETING::TYPE_MC); - //Don't re-init NHTM size -- only one HTM region per proc - uint64_t l_end_hi = l_end.hi; - uint64_t l_end_lo = l_end.lo; - uint64_t l_end_addr = ((l_end_hi << 32 ) | l_end_lo); + TARGETING::PredicatePostfixExpr l_presentMc; + l_presentMc.push(&l_mcPredicate). + push(&l_predHwasFunc).And(); + TARGETING::TargetHandleList l_mcList; - uint64_t l_addr_range_hi = l_addr_range.hi; - uint64_t l_addr_range_lo = l_addr_range.lo; - uint64_t l_start_addr =((l_addr_range_hi << 32 )| l_addr_range_lo); + // Find Associated MC list + TARGETING::targetService().getAssociated(l_mcList, + l_pProcTarget, + TARGETING::TargetService::CHILD_BY_AFFINITY, + TARGETING::TargetService::ALL, + &l_presentMc); - uint64_t l_size_bytes = ((uint64_t)l_areaSizeInMB) * l_mcaSharingCount[l_mcaInGrp] * 1024 * 1024; + //scan all mc in this proc + for(uint32_t l_mcIdx =0; + l_mcIdx < l_mcList.size(); + ++l_mcIdx) + { + TARGETING::Target *l_pMcTarget = l_mcList[l_mcIdx]; - if((0 != l_nhtmSize) && - (l_size_bytes != (l_end_addr - l_start_addr))) - { - HDAT_INF("NHTM Bar size = 0x%016llX " - " MS area size = 0x%016llX" - " l_end_addr = 0x%016llX" - " l_start_addr = 0x%016llX", - l_nhtmSize,l_size_bytes, l_end_addr, - l_start_addr); + TARGETING::PredicateCTM l_miPredicate( + TARGETING::CLASS_UNIT, + TARGETING::TYPE_MI); - l_addr_range.lo = l_hdatNhtmStartAddr.lo; - l_addr_range.hi = l_hdatNhtmStartAddr.hi; + TARGETING::PredicatePostfixExpr l_funcMi; + l_funcMi.push(&l_miPredicate).push(&l_predHwasFunc).And(); - l_end.lo = l_hdatNhtmEndAddr.lo; - l_end.hi = l_hdatNhtmEndAddr.hi; + TARGETING::TargetHandleList l_miList; - l_err = addMsAreaAddr(l_index, - l_addr_range, - l_end, - l_procChipId, - false, 0, 0); - if(NULL != l_err) + // Find Associated mi list + TARGETING::targetService().getAssociated(l_miList, + l_pMcTarget, + TARGETING::TargetService::CHILD, + TARGETING::TargetService::ALL, + &l_funcMi); + + //for each MI connected to this this MC + for(uint32_t l_miIdx = 0;l_miIdx<l_miList.size(); + ++l_miIdx) + { + TARGETING::Target *l_pMiTarget = l_miList[l_miIdx]; + + //for each MCC connected to this this MI + TARGETING::PredicateCTM l_mccPredicate( + TARGETING::CLASS_UNIT, TARGETING::TYPE_MCC); + + TARGETING::PredicateHwas l_predMcc; + l_predMcc.present(true); + TARGETING::PredicatePostfixExpr l_presentMcc; + l_presentMcc.push(&l_mccPredicate). + push(&l_predMcc).And(); + TARGETING::TargetHandleList l_mccList; + + // Get associated MCCs + TARGETING::targetService(). + getAssociated(l_mccList, l_pMiTarget, + TARGETING::TargetService::CHILD_BY_AFFINITY, + TARGETING::TargetService::ALL, &l_presentMcc); + + for(uint32_t l_mccIdx = 0; l_mccIdx<l_mccList.size(); + ++l_mccIdx) + { + TARGETING::Target *l_pMccTarget = + l_mccList[l_mccIdx]; + + //Group which this MCC is belonging + uint32_t l_mccInGrp = 0; + + if(!hdatFindGroupForMcc(l_pProcTarget, + l_pMccTarget, + l_mccInGrp)) { - HDAT_ERR("Error in adding " - " addMsAreaAddr to ms area index[%d]", - l_index); - break; + HDAT_INF("No group found for MCC"); + //Skip this MCC as it is not under any group + continue; } - l_nhtmSize=0; //only add 1 entry - } - l_addr_range = l_end; - l_index++; - } //end of mca list - } //end of MCS list - } //end of MCBIST list + + //for each OMI connected to this this MCC + TARGETING::PredicateCTM l_omiPredicate( + TARGETING::CLASS_UNIT, TARGETING::TYPE_OMI); + + TARGETING::PredicateHwas l_predOmi; + l_predOmi.present(true); + TARGETING::PredicatePostfixExpr l_presentOmi; + l_presentOmi.push(&l_omiPredicate). + push(&l_predOmi).And(); + TARGETING::TargetHandleList l_omiList; + + // Get associated OMIs + TARGETING::targetService(). + getAssociated(l_omiList, l_pMccTarget, + TARGETING::TargetService::CHILD_BY_AFFINITY, + TARGETING::TargetService::ALL, &l_presentOmi); + + for(uint32_t l_omiIdx = 0; + l_omiIdx<l_omiList.size(); + ++l_omiIdx) + { + TARGETING::Target *l_pOmiTarget = + l_omiList[l_omiIdx]; + + //for each OCMB CHIP connected to this this OMI + TARGETING::PredicateCTM l_ocmbPredicate( + TARGETING::CLASS_CHIP, + TARGETING::TYPE_OCMB_CHIP); + + TARGETING::PredicateHwas l_predOcmb; + l_predOcmb.present(true); + TARGETING::PredicatePostfixExpr l_presentOcmb; + l_presentOcmb.push(&l_ocmbPredicate). + push(&l_predOcmb).And(); + TARGETING::TargetHandleList l_ocmbList; + + // Get associated OCMB CHIP's + TARGETING::targetService(). + getAssociated(l_ocmbList, l_pOmiTarget, + TARGETING::TargetService::CHILD_BY_AFFINITY, + TARGETING::TargetService::ALL, &l_presentOcmb); + + for(uint32_t l_ocmbIdx = 0; + l_ocmbIdx<l_ocmbList.size(); + ++l_ocmbIdx) + { + TARGETING::Target *l_pOcmbTarget = + l_ocmbList[l_ocmbIdx]; + + // Swift uses a DDIMM. It is a single FRU + // that includes 1 OCMB chip and some dram + hdatMemParentType l_parentType = + HDAT_MEM_PARENT_RISER; + + std::list<hdatRamArea> l_areas; + l_areas.clear(); + uint32_t l_areaSizeInMB = 0; + bool l_areaFunctional = false; + uint32_t l_numDimms =0; + + l_err = hdatScanDimmsAxone(l_pOcmbTarget, + l_areas, + l_areaSizeInMB, + l_numDimms, + l_areaFunctional, + l_parentType); + if(NULL != l_err) + { + HDAT_ERR("Error in calling Scan Dimms"); + break; + } + + HDAT_INF("l_areaSizeInMB:0x%.8X " + "l_numDimms:0x%.8X " + "l_areas.size():0x%.8X", l_areaSizeInMB, + l_numDimms, l_areas.size()); + + // Skip if no memory configured under + // OCMB_CHIP + if(l_areaSizeInMB == 0) + { + continue; + } + + uint32_t l_maxMemBlocks = 0; + l_err = hdatGetMaxMemoryBlocks + (l_pOcmbTarget,l_maxMemBlocks); + if(NULL != l_err) + { + HDAT_ERR("Error to get max blocks"); + break; + } + + TARGETING::ATTR_SLCA_RID_type l_procRid = + l_pProcTarget->getAttr + <TARGETING::ATTR_SLCA_RID>(); + + TARGETING::ATTR_SLCA_INDEX_type + l_procSlcaIndex = l_pProcTarget->getAttr + <TARGETING::ATTR_SLCA_INDEX>(); + + l_err = addMsAreaFru(l_procRid, + l_procSlcaIndex, + l_pProcTarget, + l_index, + l_numDimms, + MAX_CHIP_EC_CNT_PER_MSAREA, + l_maxMemBlocks); + + if(NULL != l_err) + { + HDAT_ERR("Error adding MSArea %d" + "Number of Dimms: %d " + "Max Blocks: %d", + l_index, + l_numDimms,l_maxMemBlocks); + break; + } + + uint32_t l_memStatus = 0; + + //If group is shared with more than one area + if(l_mccSharingCount[l_mccInGrp] >= + HDAT_MIN_NUM_FOR_SHARING) + { + l_memStatus = HDAT_MEM_SHARED; + setMsAreaInterleavedId(l_index, + l_mccSharingGrpIds[l_mccInGrp]); + } + + setMsAreaType(l_index,l_parentType); + setMsAreaSize(l_index,l_areaSizeInMB); + + iv_maxSize.hdatTotSize += l_areaSizeInMB; + + l_memStatus |= l_areaFunctional ? + (HDAT_MEM_INSTALLED | + HDAT_MEM_FUNCTIONAL) : + HDAT_MEM_INSTALLED; + + setMsAreaStat(l_index, l_memStatus); + + //Add OMI ec level + uint32_t l_omiEcLevel = 0; + uint32_t l_omiChipId = 0; + l_err = hdatGetIdEc(l_pOmiTarget, + l_omiEcLevel, + l_omiChipId); + if(NULL != l_err) + { + HDAT_ERR("Error in getting OMI ID " + "and EC HUID:[0x%08X]", + l_pOmiTarget->getAttr + <TARGETING::ATTR_HUID>()); + break; + } + + l_err = addEcEntry(l_index, + l_omiChipId, + l_omiEcLevel); + if(NULL != l_err) + { + HDAT_ERR("Error in adding" + " ID[0x%08X] and " + "EC[0x%08X] to ms area" + " HUID:[0x%08X]",l_omiChipId, + l_omiEcLevel, + l_pOmiTarget->getAttr + <TARGETING::ATTR_HUID>()); + break; + } + + // Get the i2c Master data + std::vector<hdatI2cData_t> l_i2cDevEntries; + + if (l_pOcmbTarget != NULL) + { + hdatGetI2cDeviceInfo(l_pOcmbTarget, + l_model, + l_i2cDevEntries); + } + + setMsaI2cInfo(l_index, l_i2cDevEntries); + + //for each mem-port connected to this this + //ocmb_chip + TARGETING::PredicateCTM l_allMemPort( + TARGETING::CLASS_UNIT, + TARGETING::TYPE_MEM_PORT); + TARGETING::PredicateHwas l_funcMemPort; + l_funcMemPort.functional(true); + TARGETING::PredicatePostfixExpr + l_allFuncMemPort; + l_allFuncMemPort.push(&l_allMemPort). + push(&l_funcMemPort).And(); + + TARGETING::TargetHandleList l_memPortList; + + TARGETING::targetService(). + getAssociated(l_memPortList, + l_pOcmbTarget, + TARGETING::TargetService::CHILD, + TARGETING::TargetService::ALL, + &l_allFuncMemPort); + + TARGETING::Target *l_pmemPortTarget; + + l_pmemPortTarget = l_memPortList[0]; + + uint32_t l_memBusFreq = 0; + l_memBusFreq = + getMemBusFreqAxone(l_pmemPortTarget); + + std::list<hdatRamArea>::iterator l_area = + l_areas.begin(); + + for (uint32_t l_ramId = 0; + l_area != l_areas.end(); + ++l_ramId, ++l_area) + { + uint32_t l_status = + (l_area)->ivFunctional ? + (HDAT_RAM_INSTALLED | + HDAT_RAM_FUNCTIONAL) + : HDAT_RAM_INSTALLED; + + TARGETING::Target *l_pDimmTarget = + TARGETING::Target::getTargetFromHuid( + l_area->ivHuid); + + TARGETING::ATTR_SLCA_RID_type l_dimmRid + = 0; + TARGETING::ATTR_SLCA_INDEX_type + l_dimmSlcaIndex = 0; + l_dimmRid + = l_pDimmTarget->getAttr + <TARGETING::ATTR_SLCA_RID>(); + + l_dimmSlcaIndex = + l_pDimmTarget->getAttr + <TARGETING::ATTR_SLCA_INDEX>(); + + uint32_t l_dimmId = 0; + l_dimmId |= + 1 << (31 - l_pOcmbTarget->getAttr + <TARGETING::ATTR_REL_POS>()); + l_dimmId |= + 1 << (31 - (l_pmemPortTarget->getAttr + <TARGETING::ATTR_REL_POS>()+16)); + l_dimmId |= + 1 << (31 - (l_pDimmTarget->getAttr + <TARGETING::ATTR_REL_POS>()+20)); + + l_err = addRamFru(l_index, + l_pDimmTarget, + l_dimmRid, + l_dimmSlcaIndex, + l_ramId, + l_status, + (l_area)->ivSize, + l_dimmId, + l_memBusFreq); + + if (l_err) // Failed to add ram fru + { + HDAT_ERR("Error in adding RAM FRU" + "Index:%d Rid:[0x%08X] " + "status:[0x%08X]" + "Size:[0x%08X] RamID:[0x%08X]", + l_index,(l_area)->ivHuid, + l_status,(l_area)->ivSize, + l_ramId); + ERRORLOG::errlCommit(l_err, + HDAT_COMP_ID); + + delete l_err; + l_err = NULL; + continue; + } + }//end of RAM list + + l_addr_range.hi = + (l_procMemBases[l_mccInGrp] & + 0xFFFFFFFF00000000ull) >> 32; + l_addr_range.lo = + l_procMemBases[l_mccInGrp] & + 0x00000000FFFFFFFFull; + + l_end = l_addr_range; + + //Update the range + l_end.hi += + (l_procMemSizesBytes[l_mccInGrp] & + 0xFFFFFFFF00000000ull) >> 32; + l_end.lo += + l_procMemSizesBytes[l_mccInGrp] & + 0x00000000FFFFFFFFull; + + HDAT_INF("MI:0x%08X l_addr_range:0x%08X " + "0x%08X" + " l_end:0x%08X 0x%08X", + l_pMiTarget->getAttr + <TARGETING::ATTR_HUID>(), + l_addr_range.hi, l_addr_range.lo, + l_end.hi,l_end.lo); + + uint64_t l_hdatMirrorAddr_x = 0x0ull; + uint64_t l_hdatMirrorAddr = 0x0ull; + uint32_t l_hdatMemcntrlID = 0x0 ; + uint8_t l_hdatMirrorAlogrithm = 0xFF; + bool l_rangeIsMirrorable = false; + + //Calculate the mirror address and + //related data + uint64_t l_startAddr = + (((uint64_t)(l_addr_range.hi) << 32 ) + | (uint64_t)(l_addr_range.lo)); + l_hdatMirrorAddr_x = (l_startAddr / 2) + + l_mirrorBaseAddress_x; + + HDAT_INF("Start add : 0x%016llX " + "MirrorBase : 0x%016llX" + " MirrorAddr : 0x%016llX" + " PayLoadMirrorMem : 0x%X", + l_startAddr, l_mirrorBaseAddress_x, + l_hdatMirrorAddr_x, l_payLoadMirrorMem); + + if ( 0 != l_payLoadMirrorMem ) + { + for ( int idx=0 ; idx < + (int)(sizeof + (TARGETING::ATTR_PROC_MIRROR_SIZES_type) + / sizeof(uint64_t)) ; idx++ ) + { + HDAT_INF("Mirror size : 0x%016llX" + " MirrorAddr : 0x%016llX" + " hdatMirrorAddr_x : 0x%016llX", + l_MirrorSize[idx], + l_MirrorAddr[idx], + l_hdatMirrorAddr_x); + + if( (0 != l_MirrorSize[idx]) && + (l_MirrorAddr[idx] == + l_hdatMirrorAddr_x) ) + { + l_rangeIsMirrorable = true; + l_hdatMirrorAddr = + l_MirrorAddr[idx] | + HDAT_REAL_ADDRESS_MASK64; + break; + } + } + } + + // Set the memory controller ID + l_hdatMemcntrlID |= + 1 << (31 - l_pMcTarget->getAttr + <TARGETING::ATTR_CHIP_UNIT>()); + l_hdatMemcntrlID |= + 1 << (31 - (l_pMiTarget->getAttr + <TARGETING::ATTR_CHIP_UNIT>() + 4)); + l_hdatMemcntrlID |= + 1 << (31 - (l_pMccTarget->getAttr + <TARGETING::ATTR_CHIP_UNIT>() + 8)); + l_hdatMemcntrlID |= + 1 << (31 - (l_pOmiTarget->getAttr + <TARGETING::ATTR_CHIP_UNIT>() + 16)); + + l_err = addMsAreaAddr(l_index, + l_addr_range, + l_end, + l_procChipId, + l_rangeIsMirrorable, + l_hdatMirrorAlogrithm, + l_hdatMirrorAddr, + l_hdatMemcntrlID); + if(NULL != l_err) + { + HDAT_ERR("Error in adding addMsAreaAddr" + " to ms area index[%d]", + l_index); + break; + } + + // TODO : RTC Story 159682 + // Further CHTM support needs to be added + // which contains the trace array for + // 24 cores + // Reinitializing the NHTM size + + // Don't re-init NHTM size -- only one HTM + // region per proc + uint64_t l_end_hi = l_end.hi; + uint64_t l_end_lo = l_end.lo; + uint64_t l_end_addr = + ((l_end_hi << 32 ) | l_end_lo); + + + uint64_t l_addr_range_hi = l_addr_range.hi; + uint64_t l_addr_range_lo = l_addr_range.lo; + uint64_t l_start_addr = + ((l_addr_range_hi << 32 )| l_addr_range_lo); + + uint64_t l_size_bytes = + ((uint64_t)l_areaSizeInMB) * + l_mccSharingCount[l_mccInGrp] * 1024 * 1024; + + if((0 != l_nhtmSize) && + (l_size_bytes != + (l_end_addr - l_start_addr))) + { + HDAT_INF("NHTM Bar size = 0x%016llX " + " MS area size = 0x%016llX" + " l_end_addr = 0x%016llX" + " l_start_addr = 0x%016llX", + l_nhtmSize,l_size_bytes, + l_end_addr, + l_start_addr); + + l_addr_range.lo = + l_hdatNhtmStartAddr.lo; + l_addr_range.hi = + l_hdatNhtmStartAddr.hi; + + l_end.lo = l_hdatNhtmEndAddr.lo; + l_end.hi = l_hdatNhtmEndAddr.hi; + + l_err = addMsAreaAddr(l_index, + l_addr_range, + l_end, + l_procChipId, + false, 0, 0); + if(NULL != l_err) + { + HDAT_ERR("Error in adding " + " addMsAreaAddr to ms area " + "index[%d]", + l_index); + break; + } + l_nhtmSize=0; //only add 1 entry + } + l_addr_range = l_end; + l_index++; + } // end of OCMB_CHIP list + } //end of OMI list + } //end of MCC list + } //end of MI list + } //end of MC list + } if(l_err) { // Error message recorded above @@ -1823,7 +2447,8 @@ void HdatMsVpd::commit(void * i_addr, /******************************************************************************* * hdatGetMaxMemConfiguredAddress *******************************************************************************/ -uint64_t HdatMsVpd::hdatGetMaxMemConfiguredAddress() +uint64_t HdatMsVpd::hdatGetMaxMemConfiguredAddress( + TARGETING::ATTR_MODEL_type i_model) { //For each processor in the system TARGETING::PredicateCTM l_procChipPred(TARGETING::CLASS_CHIP, @@ -1856,49 +2481,101 @@ uint64_t HdatMsVpd::hdatGetMaxMemConfiguredAddress() assert(l_pProcTarget-> tryGetAttr<TARGETING::ATTR_PROC_MEM_BASES>(l_procMemBases)); + if (i_model == TARGETING::MODEL_NIMBUS) + { + //For each MCA + TARGETING::PredicateCTM l_allMca(TARGETING::CLASS_UNIT, + TARGETING::TYPE_MCA); + TARGETING::PredicateHwas l_funcMca; + l_funcMca.functional(true); + TARGETING::PredicatePostfixExpr l_allFuncMca; + l_allFuncMca.push(&l_allMca).push(&l_funcMca).And(); - //For each MCA - TARGETING::PredicateCTM l_allMca(TARGETING::CLASS_UNIT, - TARGETING::TYPE_MCA); - TARGETING::PredicateHwas l_funcMca; - l_funcMca.functional(true); - TARGETING::PredicatePostfixExpr l_allFuncMca; - l_allFuncMca.push(&l_allMca).push(&l_funcMca).And(); - - TARGETING::TargetHandleList l_mcaList; + TARGETING::TargetHandleList l_mcaList; - TARGETING::targetService(). + TARGETING::targetService(). getAssociated(l_mcaList, l_pProcTarget, TARGETING::TargetService::CHILD, TARGETING::TargetService::ALL, &l_allFuncMca); - for(uint32_t i=0; i < l_mcaList.size(); i++) - { + for(uint32_t i=0; i < l_mcaList.size(); i++) + { - TARGETING::Target *l_pMcaTarget = l_mcaList[i]; + TARGETING::Target *l_pMcaTarget = l_mcaList[i]; - uint32_t l_mcaInGroup = 0; - if(!hdatFindGroupForMc(l_pProcTarget, - l_pMcaTarget, - l_mcaInGroup)) - { - HDAT_INF("Input target is not in group," - " MCA HUID:[0x%08X]", - l_pMcaTarget->getAttr<TARGETING::ATTR_HUID>()); - //Skip this MC not part of any group - continue; + uint32_t l_mcaInGroup = 0; + if(!hdatFindGroupForMc(l_pProcTarget, + l_pMcaTarget, + l_mcaInGroup)) + { + HDAT_INF("Input target is not in group," + " MCA HUID:[0x%08X]", + l_pMcaTarget->getAttr<TARGETING::ATTR_HUID>()); + //Skip this MC not part of any group + continue; + } + + if(!l_processedAnyGroup || + (l_procMemBases[l_mcaInGroup] > l_maxBase)) + { + l_maxBase = l_procMemBases[l_mcaInGroup]; + l_processedAnyGroup = true; + l_maxMsAddress = + l_maxBase + l_procMemSizesBytes[l_mcaInGroup]; + HDAT_INF("Max MS Addr l_maxMsAddress: = 0x%016llX," + "l_maxBase= 0x%016llX," + "l_procMemSizesBytes[l_mcaInGroup]= 0x%016llX", + l_maxMsAddress, l_maxBase, + l_procMemSizesBytes[l_mcaInGroup]); + } } + } + else + { + //For each MCC + TARGETING::PredicateCTM l_allMcc(TARGETING::CLASS_UNIT, + TARGETING::TYPE_MCC); + TARGETING::PredicateHwas l_funcMcc; + l_funcMcc.functional(true); + TARGETING::PredicatePostfixExpr l_allFuncMcc; + l_allFuncMcc.push(&l_allMcc).push(&l_funcMcc).And(); + + TARGETING::TargetHandleList l_mccList; + + TARGETING::targetService(). + getAssociated(l_mccList, l_pProcTarget, + TARGETING::TargetService::CHILD, + TARGETING::TargetService::ALL, &l_allFuncMcc); - if(!l_processedAnyGroup || - (l_procMemBases[l_mcaInGroup] > l_maxBase)) + for(uint32_t i=0; i < l_mccList.size(); i++) { - l_maxBase = l_procMemBases[l_mcaInGroup]; - l_processedAnyGroup = true; - l_maxMsAddress = l_maxBase + l_procMemSizesBytes[l_mcaInGroup]; - HDAT_INF("Max MS Addr l_maxMsAddress: = 0x%016llX," - "l_maxBase= 0x%016llX," - "l_procMemSizesBytes[l_mcaInGroup]= 0x%016llX", - l_maxMsAddress, l_maxBase, l_procMemSizesBytes[l_mcaInGroup]); + TARGETING::Target *l_pMccTarget = l_mccList[i]; + + uint32_t l_mccInGroup = 0; + if(!hdatFindGroupForMcc(l_pProcTarget, + l_pMccTarget, + l_mccInGroup)) + { + HDAT_INF("Input target is not in group," + " MCC HUID:[0x%08X]", + l_pMccTarget->getAttr<TARGETING::ATTR_HUID>()); + //Skip this MCC as its not part of any group + continue; + } + + if(!l_processedAnyGroup || + (l_procMemBases[l_mccInGroup] > l_maxBase)) + { + l_maxBase = l_procMemBases[l_mccInGroup]; + l_processedAnyGroup = true; + l_maxMsAddress = + l_maxBase + l_procMemSizesBytes[l_mccInGroup]; + HDAT_INF("Max MS Addr l_maxMsAddress: = 0x%016llX," + "l_maxBase= 0x%016llX," + "l_procMemSizesBytes[l_omiInGroup]= 0x%016llX", + l_maxMsAddress, l_maxBase, + l_procMemSizesBytes[l_mccInGroup]); + } } } @@ -2004,6 +2681,56 @@ bool HdatMsVpd::hdatFindGroupForMc(const TARGETING::Target *i_pProcTarget, return l_foundGroup; } + +//****************************************************************************** +//* hdatFindGroupForMcc +//****************************************************************************** +bool HdatMsVpd::hdatFindGroupForMcc(const TARGETING::Target *i_pProcTarget, + const TARGETING::Target *i_pMccTarget, + uint32_t& o_groupOfMcc) +{ + bool l_foundGroup = false; + TARGETING::ATTR_MSS_MEM_MC_IN_GROUP_type l_mccGroups = {0}; + assert(i_pProcTarget != NULL || i_pMccTarget != NULL); + + assert(!(i_pProcTarget->getAttr<TARGETING::ATTR_TYPE>() + != TARGETING::TYPE_PROC)|| + !(i_pProcTarget->getAttr<TARGETING::ATTR_CLASS>() + != TARGETING::CLASS_CHIP)); + + assert(i_pProcTarget-> + tryGetAttr<TARGETING::ATTR_MSS_MEM_MC_IN_GROUP>(l_mccGroups)); + + assert(!(i_pMccTarget->getAttr<TARGETING::ATTR_TYPE>() + != TARGETING::TYPE_MCC)|| + !(i_pMccTarget->getAttr<TARGETING::ATTR_CLASS>() + != TARGETING::CLASS_UNIT)); + TARGETING::ATTR_CHIP_UNIT_type l_chipUnit = + i_pMccTarget->getAttr<TARGETING::ATTR_CHIP_UNIT>(); + uint32_t l_sizeOfArray = sizeof(l_mccGroups)/sizeof(l_mccGroups[0]); + + assert(!(sizeof( l_mccGroups[0] ) != sizeof(uint8_t))); + + assert(!( l_chipUnit >= ( sizeof( l_mccGroups[0] ) * HDAT_BITS_PER_BYTE ))); + + const uint8_t MC_IN_GROUP_MCC_0 = 0x80; + for(uint32_t l_idx =0; l_idx < l_sizeOfArray;++l_idx) + { + //Attribute ATTR_MSS_MEM_MC_IN_GROUP is an array of bitmask + //bit 0 of bitmask corresponds to mcc 0, bit 7 to mcc 7 + if((l_mccGroups[l_idx] & (MC_IN_GROUP_MCC_0 >> l_chipUnit)) == + (MC_IN_GROUP_MCC_0 >> l_chipUnit)) + { + HDAT_INF("hdatFindGroupForMcc::: Found group : %d",l_idx); + o_groupOfMcc = l_idx; + l_foundGroup = true; + break; + } + } + + return l_foundGroup; +} + /******************************************************************************* * hdatScanDimms *******************************************************************************/ @@ -2148,6 +2875,145 @@ errlHndl_t HdatMsVpd::hdatScanDimms(const TARGETING::Target *i_pTarget, while(0); return l_err; } + +/******************************************************************************* +* hdatScanDimmsAxone +*******************************************************************************/ +errlHndl_t HdatMsVpd::hdatScanDimmsAxone(const TARGETING::Target *i_pOcmbTarget, + std::list<hdatRamArea>& o_areas, + uint32_t& o_areaSize, + uint32_t& o_dimmNum, + bool& o_areaFunctional, + hdatMemParentType& o_parentType) +{ + errlHndl_t l_err = NULL; + + do + { + if(i_pOcmbTarget->getAttr<TARGETING::ATTR_TYPE>() != + TARGETING::TYPE_OCMB_CHIP) + { + HDAT_ERR("Input Target is type not OCMB_CHIP"); + break; + } + + //for each mem-port connected to this this ocmb_chip + TARGETING::PredicateCTM l_allMemPort(TARGETING::CLASS_UNIT, + TARGETING::TYPE_MEM_PORT); + TARGETING::PredicateHwas l_funcMemPort; + l_funcMemPort.functional(true); + TARGETING::PredicatePostfixExpr l_allFuncMemPort; + l_allFuncMemPort.push(&l_allMemPort).push(&l_funcMemPort).And(); + + TARGETING::TargetHandleList l_memPortList; + + TARGETING::targetService(). + getAssociated(l_memPortList, i_pOcmbTarget, + TARGETING::TargetService::CHILD, + TARGETING::TargetService::ALL, &l_allFuncMemPort); + + for(uint32_t i=0; i < l_memPortList.size(); i++) + { + TARGETING::Target *l_pmemPortTarget = l_memPortList[i]; + + TARGETING::ATTR_MEM_EFF_DIMM_SIZE_type l_dimSizes = {0}; + //Get configured memory size + if(!l_pmemPortTarget-> + tryGetAttr<TARGETING::ATTR_MEM_EFF_DIMM_SIZE>(l_dimSizes)) + { + HDAT_ERR("DIMM size should be available with MEM_PORT"); + } + + //for each DIMM connected to this this MCA + TARGETING::PredicateCTM l_dimmPredicate(TARGETING:: + CLASS_LOGICAL_CARD, + TARGETING::TYPE_DIMM); + TARGETING::PredicateHwas l_predDimm; + l_predDimm.present(true); + TARGETING::PredicatePostfixExpr l_presentDimm; + l_presentDimm.push(&l_dimmPredicate).push(&l_predDimm).And(); + + TARGETING::TargetHandleList l_dimmList; + + // Get associated dimms + TARGETING::targetService(). + getAssociated(l_dimmList, l_pmemPortTarget, + TARGETING::TargetService::CHILD_BY_AFFINITY, + TARGETING::TargetService::ALL, &l_presentDimm); + + for(uint32_t j=0; j < l_dimmList.size(); ++j) + { + //fetch each dimm + TARGETING::Target *l_pDimmTarget = l_dimmList[j]; + + uint32_t l_dimmfru = 0; + l_dimmfru = l_pDimmTarget->getAttr<TARGETING::ATTR_FRU_ID>(); + + TARGETING::ATTR_MEM_PORT_type l_dimmMemPort = 0; + + if(!l_pDimmTarget-> + tryGetAttr<TARGETING::ATTR_MEM_PORT>(l_dimmMemPort)) + { + HDAT_ERR("DIMM size should be available with MEM_PORT"); + } + + //Convert GB to MB + uint32_t l_dimmSizeInMB = l_dimSizes[l_dimmMemPort] * + HDAT_MB_PER_GB; + uint32_t l_huid = TARGETING::get_huid(l_pDimmTarget); + + bool foundArea = false; + for (std::list<hdatRamArea>::iterator l_area = o_areas.begin(); + l_area != o_areas.end(); + ++l_area) + { + //we do not need to compare each dimm fru id with mca fru id + //to create ram area, by the below logic + //dimms with same fruid will fall into same ram area + //even if they have fru id same with mca + if (l_area->ivfruId == l_dimmfru)//this means soldered dimms + { + foundArea = true; + l_area->ivFunctional = (l_area)->ivFunctional || + isFunctional(l_pDimmTarget); + (l_area)->ivFunctional = true; + (l_area)->ivSize += l_dimmSizeInMB; + break; + } + } + + //Search in the list of RAM Areas if not + //present create a new ram area + if (!foundArea) + { + o_dimmNum++; + o_areas.push_back(hdatRamArea(l_huid, + isFunctional(l_pDimmTarget), + l_dimmSizeInMB,l_dimmfru)); + } + o_areaSize += l_dimmSizeInMB; + o_areaFunctional = o_areaFunctional || + isFunctional(l_pDimmTarget); + } //end of dimm list + + o_parentType = HDAT_MEM_PARENT_CEC_FRU; + + if(l_err != NULL) + { + //break if error + break; + } + } // end of mem_port list + if(l_err != NULL) + { + //break if error + break; + } + } + while(0); + return l_err; +} + /******************************************************************************* * hdatGetMaxMemoryBlocks *******************************************************************************/ diff --git a/src/usr/hdat/hdatmsvpd.H b/src/usr/hdat/hdatmsvpd.H index 0778e3e9a..86aecaa42 100755 --- a/src/usr/hdat/hdatmsvpd.H +++ b/src/usr/hdat/hdatmsvpd.H @@ -5,7 +5,7 @@ /* */ /* OpenPOWER HostBoot Project */ /* */ -/* Contributors Listed Below - COPYRIGHT 2016,2018 */ +/* Contributors Listed Below - COPYRIGHT 2016,2019 */ /* [+] International Business Machines Corp. */ /* */ /* */ @@ -63,6 +63,10 @@ const uint32_t HDAT_START_INSTANCE = 0; const uint32_t HDAT_RHB_MAX_RANGE_ENTRIES = 20; const uint32_t MAX_DIMMS_PER_MCBIST = 8; +//@TODO:RTC 213230(HDAT Axone additional support) +//Need to revisit the number if needed +const uint32_t HDAT_MAX_MSAREA_AXONE = 32; + /** @brief Structure version number */ const uint16_t HDAT_MS_VPD_VERSION = 0x24; @@ -809,10 +813,12 @@ class HdatMsVpd : public HdatHdif /** * @brief Gets maximum configured memory address * + * @param[in] i_model Target model * * @return value of ms address */ - uint64_t hdatGetMaxMemConfiguredAddress(); + uint64_t hdatGetMaxMemConfiguredAddress( + TARGETING::ATTR_MODEL_type i_model); /** * @brief Fetches the group of MC @@ -828,6 +834,19 @@ class HdatMsVpd : public HdatHdif uint32_t& o_groupOfMc); /** + * @brief Fetches the group of MCC + * + * @param[in] i_pTarget Proc target + * @param[in] i_pMccTarget MCC target + * @param[out] o_groupOfMcc MCC group value + * + * @return Success or failure + */ + bool hdatFindGroupForMcc(const TARGETING::Target *i_pProcTarget, + const TARGETING::Target *i_pMccTarget, + uint32_t& o_groupOfMcc); + + /** * @brief Get the DIMMS list present on the system * * @param[in] i_pTarget Mca target @@ -854,6 +873,28 @@ class HdatMsVpd : public HdatHdif hdatMemParentType& i_parentType); /** + * @brief Get the DIMMS list present on the axone system + * + * @param[in] i_pTarget OCMB Chip target + * @param[out] o_areas list of ram area structure based on the DIMM + * present. + * @param[out] o_areaSize - Total DIMM size + * @param[out] o_dimmNum - Total DIMM number + * @param[out] o_areaFunctional - DIMM functional status + * @param[out] o_parentType - memory parent type based on whether + * the dimms are pluggable or soldered + * + * @return A null error log handle if successful, else the return the + * error handle + */ + errlHndl_t hdatScanDimmsAxone(const TARGETING::Target *i_pOcmbTarget, + std::list<hdatRamArea>& o_areas, + uint32_t& o_areaSize, + uint32_t& o_dimmNum, + bool& o_areaFunctional, + hdatMemParentType& i_parentType); + + /** * @brief Get max memory blocks connected to membuf * * @param[in] i_pTarget Mcs target diff --git a/src/usr/hdat/hdatpcrd.C b/src/usr/hdat/hdatpcrd.C index b052afb5d..c813b010f 100644 --- a/src/usr/hdat/hdatpcrd.C +++ b/src/usr/hdat/hdatpcrd.C @@ -5,7 +5,7 @@ /* */ /* OpenPOWER HostBoot Project */ /* */ -/* Contributors Listed Below - COPYRIGHT 2016,2018 */ +/* Contributors Listed Below - COPYRIGHT 2016,2019 */ /* [+] Google Inc. */ /* [+] International Business Machines Corp. */ /* */ @@ -446,8 +446,10 @@ errlHndl_t HdatPcrd::hdatLoadPcrd(uint32_t &o_size, uint32_t &o_count) // Need to get i2c Master data correctly std::vector<hdatI2cData_t> l_i2cDevEntries; + TARGETING::ATTR_MODEL_type l_model = TARGETING::MODEL_NIMBUS; + l_model = l_pProcTarget->getAttr<TARGETING::ATTR_MODEL>(); - hdatGetI2cDeviceInfo(l_pProcTarget, l_i2cDevEntries); + hdatGetI2cDeviceInfo(l_pProcTarget, l_model, l_i2cDevEntries); l_pcrdHI2cTotalSize = sizeof(*l_hostI2cFullPcrdHdrPtr) + (sizeof(hdatI2cData_t) * l_i2cDevEntries.size()); diff --git a/src/usr/hdat/hdatutil.C b/src/usr/hdat/hdatutil.C index d0b3edca1..5fdea3cb6 100644 --- a/src/usr/hdat/hdatutil.C +++ b/src/usr/hdat/hdatutil.C @@ -772,7 +772,10 @@ errlHndl_t hdatGetPvpdFullRecord(TARGETING::Target * i_target, theRecord,0,0,0, ERRORLOG::ERRL_SEV_INFORMATIONAL, HDAT_VERSION1, - true); + false); + //@TODO:RTC 213229(Remove HDAT hack or Axone) + //There are known differences where not all records will be + //present. So changing now from true to false. continue; } @@ -1738,6 +1741,7 @@ bool byNodeProcAffinity( * * @param[in] i_pTarget * The i2c master target handle, or nullptr for all i2c masters + * @param[in] i_model Target model * @param[out] o_i2cDevEntries * The host i2c dev entries * @@ -1746,6 +1750,7 @@ bool byNodeProcAffinity( *******************************************************************************/ void hdatGetI2cDeviceInfo( TARGETING::Target* i_pTarget, + TARGETING::ATTR_MODEL_type i_model, std::vector<hdatI2cData_t>& o_i2cDevEntries) { HDAT_ENTER(); @@ -1825,8 +1830,18 @@ void hdatGetI2cDeviceInfo( "detected"); ++linkId.instance; - if( (i_pTarget == nullptr) - || (i_pTarget == i2cDevice.masterChip)) + //@TODO:RTC 213230(HDAT Axone additional support) + //Hacking this now as OCMB is not an i2c master + if (i_model == TARGETING::MODEL_NIMBUS) + { + if( (i_pTarget == nullptr) || + (i_pTarget == i2cDevice.masterChip) + ) + { + o_i2cDevEntries.push_back(l_hostI2cObj); + } + } + else { o_i2cDevEntries.push_back(l_hostI2cObj); } @@ -2144,60 +2159,77 @@ errlHndl_t hdatUpdateSMPLinkInfoData(hdatHDIFDataArray_t * i_SMPInfoFullPcrdHdrP uint32_t getMemBusFreq(const TARGETING::Target* i_pTarget) { - HDAT_ENTER(); - TARGETING::ATTR_MSS_FREQ_type l_MemBusFreqInMHz = 0; + TARGETING::ATTR_MSS_FREQ_type l_MemBusFreqInMHz = 0; TARGETING::ATTR_CLASS_type l_class = GETCLASS(i_pTarget); TARGETING::ATTR_TYPE_type l_type = GETTYPE(i_pTarget); - if((l_class == TARGETING::CLASS_CHIP) && (l_type == TARGETING::TYPE_PROC)) + if((l_class == TARGETING::CLASS_CHIP) && + (l_type == TARGETING::TYPE_PROC)) { TARGETING::PredicateCTM l_mcbistPredicate(TARGETING::CLASS_UNIT, TARGETING::TYPE_MCBIST); TARGETING::PredicateHwas l_predHwasFunc; TARGETING::PredicatePostfixExpr l_presentMcbist; l_presentMcbist.push(&l_mcbistPredicate). - push(&l_predHwasFunc).And(); + push(&l_predHwasFunc).And(); TARGETING::TargetHandleList l_mcbistList; // Find Associated MCBIST list TARGETING::targetService().getAssociated(l_mcbistList, - i_pTarget, - TARGETING::TargetService::CHILD_BY_AFFINITY, - TARGETING::TargetService::ALL, - &l_presentMcbist); + i_pTarget, + TARGETING::TargetService::CHILD_BY_AFFINITY, + TARGETING::TargetService::ALL, + &l_presentMcbist); if(l_mcbistList.size() == 0) { HDAT_ERR("Didn't find any mcbist for a proc with huid [0x%08X]", - i_pTarget->getAttr<TARGETING::ATTR_HUID>()); + i_pTarget->getAttr<TARGETING::ATTR_HUID>()); } else { TARGETING::Target *l_pMcbistTarget = l_mcbistList[0]; if( l_pMcbistTarget->tryGetAttr<TARGETING::ATTR_MSS_FREQ> - (l_MemBusFreqInMHz) == false ) + (l_MemBusFreqInMHz) == false ) { - HDAT_ERR(" MSS_FREQ not present for MCBIST with huid [0x%08X]", - l_pMcbistTarget->getAttr<TARGETING::ATTR_HUID>()); + HDAT_ERR("MSS_FREQ not present for MCBIST with " + "huid [0x%08X]", + l_pMcbistTarget->getAttr<TARGETING::ATTR_HUID>()); } } - } - else if((l_class == TARGETING::CLASS_UNIT) && (l_type == TARGETING::TYPE_MCBIST)) + } + else if((l_class == TARGETING::CLASS_UNIT) && + (l_type == TARGETING::TYPE_MCBIST)) { - if(i_pTarget->tryGetAttr<TARGETING::ATTR_MSS_FREQ> - (l_MemBusFreqInMHz) == false ) - { - HDAT_ERR(" MSS_FREQ not present for MCBIST with huid [0x%08X]", - i_pTarget->getAttr<TARGETING::ATTR_HUID>()); - } + if(i_pTarget->tryGetAttr<TARGETING::ATTR_MSS_FREQ> + (l_MemBusFreqInMHz) == false ) + { + HDAT_ERR(" MSS_FREQ not present for MCBIST with huid [0x%08X]", + i_pTarget->getAttr<TARGETING::ATTR_HUID>()); + } } else { - HDAT_ERR(" Input target with HUID [0x%08X] is not of proc/mcbist target type", - i_pTarget->getAttr<TARGETING::ATTR_HUID>()); + HDAT_ERR(" Input target with HUID [0x%08X] is not of " + "proc/mcbist target type", + i_pTarget->getAttr<TARGETING::ATTR_HUID>()); + } + HDAT_EXIT(); + return l_MemBusFreqInMHz; +} + +uint32_t getMemBusFreqAxone(const TARGETING::Target* i_pTarget) +{ + HDAT_ENTER(); + TARGETING::ATTR_MEM_EFF_FREQ_type l_MemBusFreqInMHz = {0}; + if( i_pTarget->tryGetAttr<TARGETING::ATTR_MEM_EFF_FREQ> + (l_MemBusFreqInMHz) == false ) + { + HDAT_ERR("MSS_EFF_FREQ not present for MEM PORT with " + "huid [0x%08X]", + i_pTarget->getAttr<TARGETING::ATTR_HUID>()); } - HDAT_EXIT(); return l_MemBusFreqInMHz; } diff --git a/src/usr/hdat/hdatutil.H b/src/usr/hdat/hdatutil.H index 893852482..942549467 100755 --- a/src/usr/hdat/hdatutil.H +++ b/src/usr/hdat/hdatutil.H @@ -5,7 +5,7 @@ /* */ /* OpenPOWER HostBoot Project */ /* */ -/* Contributors Listed Below - COPYRIGHT 2015,2018 */ +/* Contributors Listed Below - COPYRIGHT 2015,2019 */ /* [+] International Business Machines Corp. */ /* */ /* */ @@ -572,6 +572,7 @@ errlHndl_t hdatGetFullEepromVpd ( TARGETING::Target * i_target, * * @param[in] i_pTarget * The i2c master target handle + * @param[in] i_model Target model * @param[out] o_i2cDevEntries * The host i2c dev entries * @@ -579,6 +580,7 @@ errlHndl_t hdatGetFullEepromVpd ( TARGETING::Target * i_target, * *******************************************************************************/ void hdatGetI2cDeviceInfo(TARGETING::Target* i_pTarget, + TARGETING::ATTR_MODEL_type i_model, std::vector<hdatI2cData_t>&o_i2cDevEntries); /******************************************************************************* @@ -620,6 +622,13 @@ errlHndl_t hdatUpdateSMPLinkInfoData(hdatHDIFDataArray_t * i_SMPInfoFullPcrdHdrP * @return Memory bus frequency. upon any error conditions it returns 0. *******************************************************************************/ uint32_t getMemBusFreq(const TARGETING::Target* i_pTarget); + +/****************************************************************************** + * @brief get Memory bus frequency of given target. + * @param[in] i_pTarget : input target handle + * @return Memory bus frequency. upon any error conditions it returns 0. +*******************************************************************************/ +uint32_t getMemBusFreqAxone(const TARGETING::Target* i_pTarget); };// end namespace #endif // HDATUTILITY_H diff --git a/src/usr/hdat/hdatvpd.C b/src/usr/hdat/hdatvpd.C index 8a76bf842..9c72c020c 100755 --- a/src/usr/hdat/hdatvpd.C +++ b/src/usr/hdat/hdatvpd.C @@ -207,7 +207,10 @@ iv_kwdSize(0), iv_kwd(NULL) TARGETING::TargetHandleList l_targList; PredicateCTM predNode(TARGETING::CLASS_ENC, TARGETING::TYPE_NODE); PredicateHwas predFunctional; - predFunctional.functional(true); + //@TODO:RTC 213229(Remove HDAT hack or Axone) + //crashes below at l_target because the node got deconfigured + //changed from functional to present + predFunctional.present(true); PredicatePostfixExpr nodeCheckExpr; nodeCheckExpr.push(&predNode).push(&predFunctional).And(); |
