From 23b60e06e20b3aac21238c32b3736cbfebc6837b Mon Sep 17 00:00:00 2001 From: Zane Shelley Date: Thu, 15 Aug 2013 13:35:40 -0500 Subject: PRD: Mem UE priority and MPE FIR clearing issue Change-Id: I159f766aa21853f513766fe7decbbd6b9f14df1c CQ: SW218867 Reviewed-on: http://gfw160.austin.ibm.com:8080/gerrit/5803 Tested-by: Jenkins Server Reviewed-by: Christopher T. Phan Reviewed-by: Sachin Gupta Reviewed-by: A. Patrick Williams III Reviewed-on: http://gfw160.austin.ibm.com:8080/gerrit/5830 --- .../prdf/common/plat/pegasus/Membuf_acts_NEST.rule | 290 ++++++++++++++++++--- .../diag/prdf/common/plat/pegasus/prdfCenMembuf.C | 161 ++++++++---- src/usr/diag/prdf/plat/pegasus/prdfPlatCenMembuf.C | 39 ++- 3 files changed, 392 insertions(+), 98 deletions(-) (limited to 'src/usr') diff --git a/src/usr/diag/prdf/common/plat/pegasus/Membuf_acts_NEST.rule b/src/usr/diag/prdf/common/plat/pegasus/Membuf_acts_NEST.rule index 27f0f28f8..50a6b744c 100755 --- a/src/usr/diag/prdf/common/plat/pegasus/Membuf_acts_NEST.rule +++ b/src/usr/diag/prdf/common/plat/pegasus/Membuf_acts_NEST.rule @@ -739,17 +739,87 @@ rule Mba1_MbsEccFir ~MBA1_MBSECCFIR_ACT0 & MBA1_MBSECCFIR_ACT1; }; -group gMbsEccFir filter singlebit +group gMbsEccFir filter priority(19,41) # UEs highest priority { - /** MBA0_MBSECCFIR[0:7] - * Memory MPE + /** MBA0_MBSECCFIR[0] + * Memory chip mark on rank 0 */ - (Mba0_MbsEccFir, bit(0|1|2|3|4|5|6|7)) ? analyzeFetchMpe0; + (Mba0_MbsEccFir, bit(0)) ? analyzeFetchMpe0_0; - /** MBA1_MBSECCFIR[0:7] - * Memory MPE + /** MBA1_MBSECCFIR[0] + * Memory chip mark on rank 0 */ - (Mba1_MbsEccFir, bit(0|1|2|3|4|5|6|7)) ? analyzeFetchMpe1; + (Mba1_MbsEccFir, bit(0)) ? analyzeFetchMpe1_0; + + /** MBA0_MBSECCFIR[1] + * Memory chip mark on rank 1 + */ + (Mba0_MbsEccFir, bit(1)) ? analyzeFetchMpe0_1; + + /** MBA1_MBSECCFIR[1] + * Memory chip mark on rank 1 + */ + (Mba1_MbsEccFir, bit(1)) ? analyzeFetchMpe1_1; + + /** MBA0_MBSECCFIR[2] + * Memory chip mark on rank 2 + */ + (Mba0_MbsEccFir, bit(2)) ? analyzeFetchMpe0_2; + + /** MBA1_MBSECCFIR[2] + * Memory chip mark on rank 2 + */ + (Mba1_MbsEccFir, bit(2)) ? analyzeFetchMpe1_2; + + /** MBA0_MBSECCFIR[3] + * Memory chip mark on rank 3 + */ + (Mba0_MbsEccFir, bit(3)) ? analyzeFetchMpe0_3; + + /** MBA1_MBSECCFIR[3] + * Memory chip mark on rank 3 + */ + (Mba1_MbsEccFir, bit(3)) ? analyzeFetchMpe1_3; + + /** MBA0_MBSECCFIR[4] + * Memory chip mark on rank 4 + */ + (Mba0_MbsEccFir, bit(4)) ? analyzeFetchMpe0_4; + + /** MBA1_MBSECCFIR[4] + * Memory chip mark on rank 4 + */ + (Mba1_MbsEccFir, bit(4)) ? analyzeFetchMpe1_4; + + /** MBA0_MBSECCFIR[5] + * Memory chip mark on rank 5 + */ + (Mba0_MbsEccFir, bit(5)) ? analyzeFetchMpe0_5; + + /** MBA1_MBSECCFIR[5] + * Memory chip mark on rank 5 + */ + (Mba1_MbsEccFir, bit(5)) ? analyzeFetchMpe1_5; + + /** MBA0_MBSECCFIR[6] + * Memory chip mark on rank 6 + */ + (Mba0_MbsEccFir, bit(6)) ? analyzeFetchMpe0_6; + + /** MBA1_MBSECCFIR[6] + * Memory chip mark on rank 6 + */ + (Mba1_MbsEccFir, bit(6)) ? analyzeFetchMpe1_6; + + /** MBA0_MBSECCFIR[7] + * Memory chip mark on rank 7 + */ + (Mba0_MbsEccFir, bit(7)) ? analyzeFetchMpe0_7; + + /** MBA1_MBSECCFIR[7] + * Memory chip mark on rank 7 + */ + (Mba1_MbsEccFir, bit(7)) ? analyzeFetchMpe1_7; /** MBA0_MBSECCFIR[8:15] * Reserved @@ -801,15 +871,85 @@ group gMbsEccFir filter singlebit */ (Mba1_MbsEccFir, bit(19)) ? analyzeFetchUe1; - /** MBA0_MBSECCFIR[20:27] - * MBECCFIR_MAINT_MPE_RANK_0_7 + /** MBA0_MBSECCFIR[20] + * Maintenance chip mark on rank 0 + */ + (Mba0_MbsEccFir, bit(20)) ? analyzeMaintMpe0_0; + + /** MBA1_MBSECCFIR[20] + * Maintenance chip mark on rank 0 + */ + (Mba1_MbsEccFir, bit(20)) ? analyzeMaintMpe1_0; + + /** MBA0_MBSECCFIR[21] + * Maintenance chip mark on rank 1 + */ + (Mba0_MbsEccFir, bit(21)) ? analyzeMaintMpe0_1; + + /** MBA1_MBSECCFIR[21] + * Maintenance chip mark on rank 1 + */ + (Mba1_MbsEccFir, bit(21)) ? analyzeMaintMpe1_1; + + /** MBA0_MBSECCFIR[22] + * Maintenance chip mark on rank 2 + */ + (Mba0_MbsEccFir, bit(22)) ? analyzeMaintMpe0_2; + + /** MBA1_MBSECCFIR[22] + * Maintenance chip mark on rank 2 + */ + (Mba1_MbsEccFir, bit(22)) ? analyzeMaintMpe1_2; + + /** MBA0_MBSECCFIR[23] + * Maintenance chip mark on rank 3 + */ + (Mba0_MbsEccFir, bit(23)) ? analyzeMaintMpe0_3; + + /** MBA1_MBSECCFIR[23] + * Maintenance chip mark on rank 3 */ - (Mba0_MbsEccFir, bit(20|21|22|23|24|25|26|27)) ? analyzeMaintMpe0; + (Mba1_MbsEccFir, bit(23)) ? analyzeMaintMpe1_3; - /** MBA1_MBSECCFIR[20:27] - * MBECCFIR_MAINT_MPE_RANK_0_7 + /** MBA0_MBSECCFIR[24] + * Maintenance chip mark on rank 4 */ - (Mba1_MbsEccFir, bit(20|21|22|23|24|25|26|27)) ? analyzeMaintMpe1; + (Mba0_MbsEccFir, bit(24)) ? analyzeMaintMpe0_4; + + /** MBA1_MBSECCFIR[24] + * Maintenance chip mark on rank 4 + */ + (Mba1_MbsEccFir, bit(24)) ? analyzeMaintMpe1_4; + + /** MBA0_MBSECCFIR[25] + * Maintenance chip mark on rank 5 + */ + (Mba0_MbsEccFir, bit(25)) ? analyzeMaintMpe0_5; + + /** MBA1_MBSECCFIR[25] + * Maintenance chip mark on rank 5 + */ + (Mba1_MbsEccFir, bit(25)) ? analyzeMaintMpe1_5; + + /** MBA0_MBSECCFIR[26] + * Maintenance chip mark on rank 6 + */ + (Mba0_MbsEccFir, bit(26)) ? analyzeMaintMpe0_6; + + /** MBA1_MBSECCFIR[26] + * Maintenance chip mark on rank 6 + */ + (Mba1_MbsEccFir, bit(26)) ? analyzeMaintMpe1_6; + + /** MBA0_MBSECCFIR[27] + * Maintenance chip mark on rank 7 + */ + (Mba0_MbsEccFir, bit(27)) ? analyzeMaintMpe0_7; + + /** MBA1_MBSECCFIR[27] + * Maintenance chip mark on rank 7 + */ + (Mba1_MbsEccFir, bit(27)) ? analyzeMaintMpe1_7; /** MBA0_MBSECCFIR[28:35] * Reserved @@ -822,62 +962,62 @@ group gMbsEccFir filter singlebit (Mba1_MbsEccFir, bit(28|29|30|31|32|33|34|35)) ? defaultMaskedError; /** MBA0_MBSECCFIR[36] - * MBECCFIR_MAINTENANCE_NCE + * Maintenance NCE */ (Mba0_MbsEccFir, bit(36)) ? defaultMaskedError; /** MBA1_MBSECCFIR[36] - * MBECCFIR_MAINTENANCE_NCE + * Maintenance NCE */ (Mba1_MbsEccFir, bit(36)) ? defaultMaskedError; /** MBA0_MBSECCFIR[37] - * MBECCFIR_MAINTENANCE_SCE + * Maintenance SCE */ (Mba0_MbsEccFir, bit(37)) ? defaultMaskedError; /** MBA1_MBSECCFIR[37] - * MBECCFIR_MAINTENANCE_SCE + * Maintenance SCE */ (Mba1_MbsEccFir, bit(37)) ? defaultMaskedError; /** MBA0_MBSECCFIR[38] - * MBECCFIR_MAINTENANCE_MCE + * Maintenance MCE */ (Mba0_MbsEccFir, bit(38)) ? defaultMaskedError; /** MBA1_MBSECCFIR[38] - * MBECCFIR_MAINTENANCE_MCE + * Maintenance MCE */ (Mba1_MbsEccFir, bit(38)) ? defaultMaskedError; /** MBA0_MBSECCFIR[39] - * MBECCFIR_MAINTENANCE_RCE + * Maintenance RCE */ (Mba0_MbsEccFir, bit(39)) ? defaultMaskedError; /** MBA1_MBSECCFIR[39] - * MBECCFIR_MAINTENANCE_RCE + * Maintenance RCE */ (Mba1_MbsEccFir, bit(39)) ? defaultMaskedError; /** MBA0_MBSECCFIR[40] - * MBECCFIR_MAINTENANCE_SUE + * Maintenance SUE */ (Mba0_MbsEccFir, bit(40)) ? defaultMaskedError; /** MBA1_MBSECCFIR[40] - * MBECCFIR_MAINTENANCE_SUE + * Maintenance SUE */ (Mba1_MbsEccFir, bit(40)) ? defaultMaskedError; /** MBA0_MBSECCFIR[41] - * MBECCFIR_MAINTENANCE_UE + * Maintenance UE */ (Mba0_MbsEccFir, bit(41)) ? analyzeMaintUe0; /** MBA1_MBSECCFIR[41] - * MBECCFIR_MAINTENANCE_UE + * Maintenance UE */ (Mba1_MbsEccFir, bit(41)) ? analyzeMaintUe1; @@ -1141,11 +1281,53 @@ actionclass spareDeployed actionclass maxSparesExceeded { calloutDmiBusTh1; funccall("maxSparesExceeded"); }; -/** Analyze a fetch MPE on MBA0 */ -actionclass analyzeFetchMpe0 { funccall("AnalyzeFetchMpe0"); }; +/** Analyze a fetch MPE on MBA0 rank 0 */ +actionclass analyzeFetchMpe0_0 { funccall("AnalyzeFetchMpe0_0"); }; + +/** Analyze a fetch MPE on MBA1 rank 0 */ +actionclass analyzeFetchMpe1_0 { funccall("AnalyzeFetchMpe1_0"); }; + +/** Analyze a fetch MPE on MBA0 rank 1 */ +actionclass analyzeFetchMpe0_1 { funccall("AnalyzeFetchMpe0_1"); }; + +/** Analyze a fetch MPE on MBA1 rank 1 */ +actionclass analyzeFetchMpe1_1 { funccall("AnalyzeFetchMpe1_1"); }; + +/** Analyze a fetch MPE on MBA0 rank 2 */ +actionclass analyzeFetchMpe0_2 { funccall("AnalyzeFetchMpe0_2"); }; + +/** Analyze a fetch MPE on MBA1 rank 2 */ +actionclass analyzeFetchMpe1_2 { funccall("AnalyzeFetchMpe1_2"); }; + +/** Analyze a fetch MPE on MBA0 rank 3 */ +actionclass analyzeFetchMpe0_3 { funccall("AnalyzeFetchMpe0_3"); }; + +/** Analyze a fetch MPE on MBA1 rank 3 */ +actionclass analyzeFetchMpe1_3 { funccall("AnalyzeFetchMpe1_3"); }; -/** Analyze a fetch MPE on MBA1 */ -actionclass analyzeFetchMpe1 { funccall("AnalyzeFetchMpe1"); }; +/** Analyze a fetch MPE on MBA0 rank 4 */ +actionclass analyzeFetchMpe0_4 { funccall("AnalyzeFetchMpe0_4"); }; + +/** Analyze a fetch MPE on MBA1 rank 4 */ +actionclass analyzeFetchMpe1_4 { funccall("AnalyzeFetchMpe1_4"); }; + +/** Analyze a fetch MPE on MBA0 rank 5 */ +actionclass analyzeFetchMpe0_5 { funccall("AnalyzeFetchMpe0_5"); }; + +/** Analyze a fetch MPE on MBA1 rank 5 */ +actionclass analyzeFetchMpe1_5 { funccall("AnalyzeFetchMpe1_5"); }; + +/** Analyze a fetch MPE on MBA0 rank 6 */ +actionclass analyzeFetchMpe0_6 { funccall("AnalyzeFetchMpe0_6"); }; + +/** Analyze a fetch MPE on MBA1 rank 6 */ +actionclass analyzeFetchMpe1_6 { funccall("AnalyzeFetchMpe1_6"); }; + +/** Analyze a fetch MPE on MBA0 rank 7 */ +actionclass analyzeFetchMpe0_7 { funccall("AnalyzeFetchMpe0_7"); }; + +/** Analyze a fetch MPE on MBA1 rank 7 */ +actionclass analyzeFetchMpe1_7 { funccall("AnalyzeFetchMpe1_7"); }; /** Analyze a fetch NCE on MBA0 */ actionclass analyzeFetchNce0 { funccall("AnalyzeFetchNce0"); threshold32pday; }; @@ -1168,11 +1350,53 @@ actionclass analyzeFetchUe0 { funccall("AnalyzeFetchUe0"); threshold1; }; /** Analyze a fetch UE on MBA1 */ actionclass analyzeFetchUe1 { funccall("AnalyzeFetchUe1"); threshold1; }; -/** Analyze a maintenance MPE on MBA0 */ -actionclass analyzeMaintMpe0 { funccall("AnalyzeMaintMpe0"); }; +/** Analyze a maintenance MPE on MBA0 rank 0 */ +actionclass analyzeMaintMpe0_0 { funccall("AnalyzeMaintMpe0_0"); }; + +/** Analyze a maintenance MPE on MBA1 rank 0 */ +actionclass analyzeMaintMpe1_0 { funccall("AnalyzeMaintMpe1_0"); }; + +/** Analyze a maintenance MPE on MBA0 rank 1 */ +actionclass analyzeMaintMpe0_1 { funccall("AnalyzeMaintMpe0_1"); }; + +/** Analyze a maintenance MPE on MBA1 rank 1 */ +actionclass analyzeMaintMpe1_1 { funccall("AnalyzeMaintMpe1_1"); }; + +/** Analyze a maintenance MPE on MBA0 rank 2 */ +actionclass analyzeMaintMpe0_2 { funccall("AnalyzeMaintMpe0_2"); }; + +/** Analyze a maintenance MPE on MBA1 rank 2 */ +actionclass analyzeMaintMpe1_2 { funccall("AnalyzeMaintMpe1_2"); }; + +/** Analyze a maintenance MPE on MBA0 rank 3 */ +actionclass analyzeMaintMpe0_3 { funccall("AnalyzeMaintMpe0_3"); }; + +/** Analyze a maintenance MPE on MBA1 rank 3 */ +actionclass analyzeMaintMpe1_3 { funccall("AnalyzeMaintMpe1_3"); }; + +/** Analyze a maintenance MPE on MBA0 rank 4 */ +actionclass analyzeMaintMpe0_4 { funccall("AnalyzeMaintMpe0_4"); }; + +/** Analyze a maintenance MPE on MBA1 rank 4 */ +actionclass analyzeMaintMpe1_4 { funccall("AnalyzeMaintMpe1_4"); }; + +/** Analyze a maintenance MPE on MBA0 rank 5 */ +actionclass analyzeMaintMpe0_5 { funccall("AnalyzeMaintMpe0_5"); }; + +/** Analyze a maintenance MPE on MBA1 rank 5 */ +actionclass analyzeMaintMpe1_5 { funccall("AnalyzeMaintMpe1_5"); }; + +/** Analyze a maintenance MPE on MBA0 rank 6 */ +actionclass analyzeMaintMpe0_6 { funccall("AnalyzeMaintMpe0_6"); }; + +/** Analyze a maintenance MPE on MBA1 rank 6 */ +actionclass analyzeMaintMpe1_6 { funccall("AnalyzeMaintMpe1_6"); }; + +/** Analyze a maintenance MPE on MBA0 rank 7 */ +actionclass analyzeMaintMpe0_7 { funccall("AnalyzeMaintMpe0_7"); }; -/** Analyze a maintenance MPE on MBA1 */ -actionclass analyzeMaintMpe1 { funccall("AnalyzeMaintMpe1"); }; +/** Analyze a maintenance MPE on MBA1 rank 7 */ +actionclass analyzeMaintMpe1_7 { funccall("AnalyzeMaintMpe1_7"); }; /** Analyze a maintenance UE on MBA0 */ actionclass analyzeMaintUe0 { funccall("AnalyzeMaintUe0"); threshold1; }; diff --git a/src/usr/diag/prdf/common/plat/pegasus/prdfCenMembuf.C b/src/usr/diag/prdf/common/plat/pegasus/prdfCenMembuf.C index 0ca252c1b..a895f689f 100755 --- a/src/usr/diag/prdf/common/plat/pegasus/prdfCenMembuf.C +++ b/src/usr/diag/prdf/common/plat/pegasus/prdfCenMembuf.C @@ -25,6 +25,7 @@ * @brief Contains all the plugin code for the PRD Centaur Membuf */ +// Framework includes #include #include #include @@ -37,6 +38,7 @@ #include #include #include +#include #include #include @@ -392,15 +394,19 @@ PRDF_PLUGIN_DEFINE( Membuf, checkSpareBit ); * @param i_membChip A Centaur chip. * @param i_sc The step code data struct. * @param i_mbaPos The MBA position. + * @param i_rank The target rank. * @return SUCCESS */ int32_t AnalyzeFetchMpe( ExtensibleChip * i_membChip, - STEP_CODE_DATA_STRUCT & i_sc, uint32_t i_mbaPos ) + STEP_CODE_DATA_STRUCT & i_sc, uint32_t i_mbaPos, + uint8_t i_rank ) { #define PRDF_FUNC "[AnalyzeFetchMpe] " int32_t l_rc = SUCCESS; + TargetHandle_t mbaTrgt = NULL; + do { CenMembufDataBundle * membdb = getMembufDataBundle( i_membChip ); @@ -410,52 +416,37 @@ int32_t AnalyzeFetchMpe( ExtensibleChip * i_membChip, PRDF_ERR( PRDF_FUNC"getMbaChip() returned NULL" ); l_rc = FAIL; break; } - TargetHandle_t mbaTrgt = mbaChip->GetChipHandle(); - // Callout all DIMMs with chip marks. - const char * reg_str = ( 0 == i_mbaPos ) ? "MBA0_MBSECCFIR" - : "MBA1_MBSECCFIR"; - SCAN_COMM_REGISTER_CLASS * fir = i_membChip->getRegister( reg_str ); - l_rc = fir->Read(); - if ( SUCCESS != l_rc ) + mbaTrgt = mbaChip->GetChipHandle(); + + // Get the current marks in hardware. + CenRank rank ( i_rank ); + CenMark mark; + if ( SUCCESS != mssGetMarkStore(mbaTrgt, rank, mark) ) { - PRDF_ERR( PRDF_FUNC"Read() failed on %s", reg_str ); - break; + PRDF_ERR( PRDF_FUNC"mssGetMarkStore() failed"); + l_rc = FAIL; break; } - for ( uint8_t r = 0; r < MAX_RANKS_PER_MBA; r++ ) + if ( !mark.getCM().isValid() ) { - if ( !fir->IsBitSet(r) ) continue; // nothing to do. - - CenRank rank ( r ); - CenMark mark; - - // Get the current marks in hardware. - if ( SUCCESS != mssGetMarkStore(mbaTrgt, rank, mark) ) - { - PRDF_ERR( PRDF_FUNC"mssGetMarkStore() failed"); - l_rc = FAIL; - continue; // check the other ranks. - } - - if ( !mark.getCM().isValid() ) - { - PRDF_ERR( PRDF_FUNC"FIR bit set but no valid chip mark: " - "rank=%d", r ); - l_rc = FAIL; - continue; // check the other ranks. - } - - // Callout the mark. - CalloutUtil::calloutMark( mbaTrgt, rank, mark, i_sc ); + PRDF_ERR( PRDF_FUNC"FIR bit set but no valid chip mark" ); + l_rc = FAIL; break; } + // Callout the mark. + CalloutUtil::calloutMark( mbaTrgt, rank, mark, i_sc ); + } while (0); + // Add ECC capture data for FFDC. + if ( NULL != mbaTrgt ) + CenMbaCaptureData::addMemEccData( mbaTrgt, i_sc ); + if ( SUCCESS != l_rc ) { - PRDF_ERR( PRDF_FUNC"Failed: MEMBUF=0x%08x i_mbaPos=%d", - i_membChip->GetId(), i_mbaPos ); + PRDF_ERR( PRDF_FUNC"Failed: i_membChip=0x%08x i_mbaPos=%d i_rank=%d", + i_membChip->GetId(), i_mbaPos, i_rank ); CalloutUtil::defaultError( i_sc ); } @@ -474,12 +465,14 @@ int32_t AnalyzeFetchMpe( ExtensibleChip * i_membChip, * @return SUCCESS */ int32_t AnalyzeFetchNce( ExtensibleChip * i_membChip, - STEP_CODE_DATA_STRUCT & i_sc, uint32_t i_mbaPos ) + STEP_CODE_DATA_STRUCT & i_sc, uint32_t i_mbaPos ) { #define PRDF_FUNC "[AnalyzeFetchNce] " int32_t l_rc = SUCCESS; + TargetHandle_t mbaTrgt = NULL; + do { CenMembufDataBundle * membdb = getMembufDataBundle( i_membChip ); @@ -490,6 +483,8 @@ int32_t AnalyzeFetchNce( ExtensibleChip * i_membChip, l_rc = FAIL; break; } + mbaTrgt = mbaChip->GetChipHandle(); + CenReadAddrReg reg = (0 == i_mbaPos) ? READ_NCE_ADDR_0 : READ_NCE_ADDR_1; CenAddr addr; @@ -505,15 +500,19 @@ int32_t AnalyzeFetchNce( ExtensibleChip * i_membChip, // workaround but is it complicated. Need to check with Ken if it // is ok to just callout the rank for DD1.x. - MemoryMru memmru ( mbaChip->GetChipHandle(), addr.getRank(), + MemoryMru memmru ( mbaTrgt, addr.getRank(), MemoryMruData::CALLOUT_RANK ); i_sc.service_data->SetCallout( memmru ); } while (0); + // Add ECC capture data for FFDC. + if ( NULL != mbaTrgt ) + CenMbaCaptureData::addMemEccData( mbaTrgt, i_sc ); + if ( SUCCESS != l_rc ) { - PRDF_ERR( PRDF_FUNC"Failed: MEMBUF=0x%08x i_mbaPos=%d", + PRDF_ERR( PRDF_FUNC"Failed: i_membChip=0x%08x i_mbaPos=%d", i_membChip->GetId(), i_mbaPos ); CalloutUtil::defaultError( i_sc ); } @@ -539,6 +538,8 @@ int32_t AnalyzeFetchRce( ExtensibleChip * i_membChip, int32_t l_rc = SUCCESS; + TargetHandle_t mbaTrgt = NULL; + do { CenMembufDataBundle * membdb = getMembufDataBundle( i_membChip ); @@ -549,6 +550,8 @@ int32_t AnalyzeFetchRce( ExtensibleChip * i_membChip, l_rc = FAIL; break; } + mbaTrgt = mbaChip->GetChipHandle(); + CenReadAddrReg reg = (0 == i_mbaPos) ? READ_RCE_ADDR_0 : READ_RCE_ADDR_1; CenAddr addr; @@ -566,9 +569,13 @@ int32_t AnalyzeFetchRce( ExtensibleChip * i_membChip, } while (0); + // Add ECC capture data for FFDC. + if ( NULL != mbaTrgt ) + CenMbaCaptureData::addMemEccData( mbaTrgt, i_sc ); + if ( SUCCESS != l_rc ) { - PRDF_ERR( PRDF_FUNC"Failed: MEMBUF=0x%08x i_mbaPos=%d", + PRDF_ERR( PRDF_FUNC"Failed: i_membChip=0x%08x i_mbaPos=%d", i_membChip->GetId(), i_mbaPos ); CalloutUtil::defaultError( i_sc ); } @@ -588,14 +595,21 @@ int32_t AnalyzeFetchRce( ExtensibleChip * i_membChip, * @return SUCCESS */ int32_t AnalyzeFetchUe( ExtensibleChip * i_membChip, - STEP_CODE_DATA_STRUCT & i_sc, uint32_t i_mbaPos ) + STEP_CODE_DATA_STRUCT & i_sc, uint32_t i_mbaPos ) { #define PRDF_FUNC "[AnalyzeFetchUe] " int32_t l_rc = SUCCESS; + TargetHandle_t mbaTrgt = NULL; + do { + // All memory UEs should be customer viewable. Normally, this would be + // done by setting the threshold to 1, but we do not want to mask UEs + // on the first occurrence. + i_sc.service_data->SetServiceCall(); + CenMembufDataBundle * membdb = getMembufDataBundle( i_membChip ); ExtensibleChip * mbaChip = membdb->getMbaChip( i_mbaPos ); if ( NULL == mbaChip ) @@ -604,6 +618,8 @@ int32_t AnalyzeFetchUe( ExtensibleChip * i_membChip, l_rc = FAIL; break; } + mbaTrgt = mbaChip->GetChipHandle(); + CenReadAddrReg reg = (0 == i_mbaPos) ? READ_UE_ADDR_0 : READ_UE_ADDR_1; CenAddr addr; @@ -621,9 +637,13 @@ int32_t AnalyzeFetchUe( ExtensibleChip * i_membChip, } while (0); + // Add ECC capture data for FFDC. + if ( NULL != mbaTrgt ) + CenMbaCaptureData::addMemEccData( mbaTrgt, i_sc ); + if ( SUCCESS != l_rc ) { - PRDF_ERR( PRDF_FUNC"Failed: MEMBUF=0x%08x i_mbaPos=%d", + PRDF_ERR( PRDF_FUNC"Failed: i_membChip=0x%08x i_mbaPos=%d", i_membChip->GetId(), i_mbaPos ); CalloutUtil::defaultError( i_sc ); } @@ -636,24 +656,51 @@ int32_t AnalyzeFetchUe( ExtensibleChip * i_membChip, //------------------------------------------------------------------------------ // Define the plugins for memory ECC errors. -#define PLUGIN_MEMORY_ECC_ERROR( TYPE, ECC, POS ) \ -int32_t Analyze##TYPE##ECC##POS( ExtensibleChip * i_membChip, \ +#define PLUGIN_FETCH_ECC_ERROR( TYPE, MBA ) \ +int32_t AnalyzeFetch##TYPE##MBA( ExtensibleChip * i_membChip, \ STEP_CODE_DATA_STRUCT & i_sc ) \ { \ - return Analyze##TYPE##ECC( i_membChip, i_sc, POS ); \ + return AnalyzeFetch##TYPE( i_membChip, i_sc, MBA ); \ +} \ +PRDF_PLUGIN_DEFINE( Membuf, AnalyzeFetch##TYPE##MBA ); + +PLUGIN_FETCH_ECC_ERROR( Nce, 0 ) +PLUGIN_FETCH_ECC_ERROR( Nce, 1 ) +PLUGIN_FETCH_ECC_ERROR( Rce, 0 ) +PLUGIN_FETCH_ECC_ERROR( Rce, 1 ) +PLUGIN_FETCH_ECC_ERROR( Ue, 0 ) +PLUGIN_FETCH_ECC_ERROR( Ue, 1 ) + +#undef PLUGIN_FETCH_ECC_ERROR + +// Define the plugins for memory MPE errors. +#define PLUGIN_FETCH_MPE_ERROR( MBA, RANK ) \ +int32_t AnalyzeFetchMpe##MBA##_##RANK( ExtensibleChip * i_membChip, \ + STEP_CODE_DATA_STRUCT & i_sc ) \ +{ \ + return AnalyzeFetchMpe( i_membChip, i_sc, MBA, RANK ); \ } \ -PRDF_PLUGIN_DEFINE( Membuf, Analyze##TYPE##ECC##POS ); - -PLUGIN_MEMORY_ECC_ERROR( Fetch, Mpe, 0 ) -PLUGIN_MEMORY_ECC_ERROR( Fetch, Mpe, 1 ) -PLUGIN_MEMORY_ECC_ERROR( Fetch, Nce, 0 ) -PLUGIN_MEMORY_ECC_ERROR( Fetch, Nce, 1 ) -PLUGIN_MEMORY_ECC_ERROR( Fetch, Rce, 0 ) -PLUGIN_MEMORY_ECC_ERROR( Fetch, Rce, 1 ) -PLUGIN_MEMORY_ECC_ERROR( Fetch, Ue, 0 ) -PLUGIN_MEMORY_ECC_ERROR( Fetch, Ue, 1 ) - -#undef PLUGIN_MEMORY_ECC_ERROR +PRDF_PLUGIN_DEFINE( Membuf, AnalyzeFetchMpe##MBA##_##RANK ); + +PLUGIN_FETCH_MPE_ERROR( 0, 0 ) +PLUGIN_FETCH_MPE_ERROR( 0, 1 ) +PLUGIN_FETCH_MPE_ERROR( 0, 2 ) +PLUGIN_FETCH_MPE_ERROR( 0, 3 ) +PLUGIN_FETCH_MPE_ERROR( 0, 4 ) +PLUGIN_FETCH_MPE_ERROR( 0, 5 ) +PLUGIN_FETCH_MPE_ERROR( 0, 6 ) +PLUGIN_FETCH_MPE_ERROR( 0, 7 ) + +PLUGIN_FETCH_MPE_ERROR( 1, 0 ) +PLUGIN_FETCH_MPE_ERROR( 1, 1 ) +PLUGIN_FETCH_MPE_ERROR( 1, 2 ) +PLUGIN_FETCH_MPE_ERROR( 1, 3 ) +PLUGIN_FETCH_MPE_ERROR( 1, 4 ) +PLUGIN_FETCH_MPE_ERROR( 1, 5 ) +PLUGIN_FETCH_MPE_ERROR( 1, 6 ) +PLUGIN_FETCH_MPE_ERROR( 1, 7 ) + +#undef PLUGIN_FETCH_MPE_ERROR } // end namespace Membuf diff --git a/src/usr/diag/prdf/plat/pegasus/prdfPlatCenMembuf.C b/src/usr/diag/prdf/plat/pegasus/prdfPlatCenMembuf.C index fc4b98b2c..21c9b7a54 100644 --- a/src/usr/diag/prdf/plat/pegasus/prdfPlatCenMembuf.C +++ b/src/usr/diag/prdf/plat/pegasus/prdfPlatCenMembuf.C @@ -62,17 +62,40 @@ PRDF_PLUGIN_DEFINE( Membuf, FUNC ); // //############################################################################## -// MBSECCFIR[20-27,39,41] +// MBSECCFIR[20-27] -#define PLUGIN_MEMORY_ECC_ERROR( TYPE, ECC, POS ) \ - PLUGIN_UNEXPECTED_ATTN( Analyze##TYPE##ECC##POS ) +#define PLUGIN_MAINT_MPE_ERROR( MBA, RANK ) \ + PLUGIN_UNEXPECTED_ATTN( AnalyzeMaintMpe##MBA##_##RANK ) -PLUGIN_MEMORY_ECC_ERROR( Maint, Mpe, 0 ) -PLUGIN_MEMORY_ECC_ERROR( Maint, Mpe, 1 ) -PLUGIN_MEMORY_ECC_ERROR( Maint, Ue, 0 ) -PLUGIN_MEMORY_ECC_ERROR( Maint, Ue, 1 ) +PLUGIN_MAINT_MPE_ERROR( 0, 0 ) +PLUGIN_MAINT_MPE_ERROR( 0, 1 ) +PLUGIN_MAINT_MPE_ERROR( 0, 2 ) +PLUGIN_MAINT_MPE_ERROR( 0, 3 ) +PLUGIN_MAINT_MPE_ERROR( 0, 4 ) +PLUGIN_MAINT_MPE_ERROR( 0, 5 ) +PLUGIN_MAINT_MPE_ERROR( 0, 6 ) +PLUGIN_MAINT_MPE_ERROR( 0, 7 ) -#undef PLUGIN_MEMORY_ECC_ERROR +PLUGIN_MAINT_MPE_ERROR( 1, 0 ) +PLUGIN_MAINT_MPE_ERROR( 1, 1 ) +PLUGIN_MAINT_MPE_ERROR( 1, 2 ) +PLUGIN_MAINT_MPE_ERROR( 1, 3 ) +PLUGIN_MAINT_MPE_ERROR( 1, 4 ) +PLUGIN_MAINT_MPE_ERROR( 1, 5 ) +PLUGIN_MAINT_MPE_ERROR( 1, 6 ) +PLUGIN_MAINT_MPE_ERROR( 1, 7 ) + +#undef PLUGIN_MAINT_MPE_ERROR + +// MBSECCFIR[39,41] + +#define PLUGIN_MAINT_UE_ERROR( MBA ) \ + PLUGIN_UNEXPECTED_ATTN( AnalyzeMaintUe##MBA ) + +PLUGIN_MAINT_UE_ERROR( 0 ) +PLUGIN_MAINT_UE_ERROR( 1 ) + +#undef PLUGIN_MAINT_UE_ERROR //------------------------------------------------------------------------------ -- cgit v1.2.1