summaryrefslogtreecommitdiffstats
path: root/src/usr/hdat
diff options
context:
space:
mode:
authorJayashankar Padath <jayashankar.padath@in.ibm.com>2019-07-18 04:54:41 -0500
committerDaniel M Crowell <dcrowell@us.ibm.com>2019-08-08 09:35:23 -0500
commit103d85c965173bbaf5aae610d77c40b40d64d42b (patch)
tree61082dcc9f768c59c4649199c465b38e94b4a200 /src/usr/hdat
parent5fffa914a20043989c4f6dd187aa22109f1810a4 (diff)
downloadtalos-hostboot-103d85c965173bbaf5aae610d77c40b40d64d42b.tar.gz
talos-hostboot-103d85c965173bbaf5aae610d77c40b40d64d42b.zip
HDAT: Support for Swift/Axone memory sub system
Added support to scan the dimms using OCMB chip target path and fetched the memory related data using the new targeting model. Updated PVPD and MVPD keywords for axone chip. Change-Id: I2c7288dd57d60243569b4648a309dfcb11baf9d8 Reviewed-on: http://rchgit01.rchland.ibm.com/gerrit1/80591 Reviewed-by: Sampa Misra <sampmisr@in.ibm.com> Tested-by: Jenkins Server <pfd-jenkins+hostboot@us.ibm.com> Tested-by: Jenkins OP Build CI <op-jenkins+hostboot@us.ibm.com> Tested-by: FSP CI Jenkins <fsp-CI-jenkins+hostboot@us.ibm.com> Tested-by: Jenkins OP HW <op-hw-jenkins+hostboot@us.ibm.com> Reviewed-by: Daniel M Crowell <dcrowell@us.ibm.com>
Diffstat (limited to 'src/usr/hdat')
-rw-r--r--src/usr/hdat/hdatiohub.C41
-rwxr-xr-xsrc/usr/hdat/hdatiohub.H3
-rwxr-xr-xsrc/usr/hdat/hdatmsarea.H4
-rwxr-xr-xsrc/usr/hdat/hdatmsvpd.C1738
-rwxr-xr-xsrc/usr/hdat/hdatmsvpd.H45
-rw-r--r--src/usr/hdat/hdatpcrd.C6
-rw-r--r--src/usr/hdat/hdatutil.C84
-rwxr-xr-xsrc/usr/hdat/hdatutil.H11
-rwxr-xr-xsrc/usr/hdat/hdatvpd.C5
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();
OpenPOWER on IntegriCloud