diff options
| -rw-r--r-- | src/usr/diag/prdf/common/plat/p9/p9_cumulus.rule | 32 | ||||
| -rw-r--r-- | src/usr/diag/prdf/common/plat/p9/p9_obus.rule | 134 | ||||
| -rw-r--r-- | src/usr/diag/prdf/common/plat/p9/p9_obus_actions.rule | 72 | ||||
| -rw-r--r-- | src/usr/diag/prdf/common/plat/p9/p9_proc_common_actions.rule | 89 | ||||
| -rw-r--r-- | src/usr/diag/prdf/common/plat/p9/prdfLaneRepair.C | 461 |
5 files changed, 732 insertions, 56 deletions
diff --git a/src/usr/diag/prdf/common/plat/p9/p9_cumulus.rule b/src/usr/diag/prdf/common/plat/p9/p9_cumulus.rule index 576b2a4a4..8eb2c01aa 100644 --- a/src/usr/diag/prdf/common/plat/p9/p9_cumulus.rule +++ b/src/usr/diag/prdf/common/plat/p9/p9_cumulus.rule @@ -6519,42 +6519,42 @@ group gPBIOOFIR filter singlebit, cs_root_cause( 8, 11, 14, 17 ) /** PBIOOFIR[28] * parser00 attn */ - (rPBIOOFIR, bit(28)) ? calloutBusInterface_obus0_th_1; + (rPBIOOFIR, bit(28)) ? obus0SmpFailure_L0; /** PBIOOFIR[29] * parser01 attn */ - (rPBIOOFIR, bit(29)) ? calloutBusInterface_obus0_th_1; + (rPBIOOFIR, bit(29)) ? obus0SmpFailure_L1; /** PBIOOFIR[30] * parser02 attn */ - (rPBIOOFIR, bit(30)) ? calloutBusInterface_obus1_th_1; + (rPBIOOFIR, bit(30)) ? obus1SmpFailure_L0; /** PBIOOFIR[31] * parser03 attn */ - (rPBIOOFIR, bit(31)) ? calloutBusInterface_obus1_th_1; + (rPBIOOFIR, bit(31)) ? obus1SmpFailure_L1; /** PBIOOFIR[32] * parser04 attn */ - (rPBIOOFIR, bit(32)) ? calloutBusInterface_obus2_th_1; + (rPBIOOFIR, bit(32)) ? obus2SmpFailure_L0; /** PBIOOFIR[33] * parser05 attn */ - (rPBIOOFIR, bit(33)) ? calloutBusInterface_obus2_th_1; + (rPBIOOFIR, bit(33)) ? obus2SmpFailure_L1; /** PBIOOFIR[34] * parser06 attn */ - (rPBIOOFIR, bit(34)) ? calloutBusInterface_obus3_th_1; + (rPBIOOFIR, bit(34)) ? obus3SmpFailure_L0; /** PBIOOFIR[35] * parser07 attn */ - (rPBIOOFIR, bit(35)) ? calloutBusInterface_obus3_th_1; + (rPBIOOFIR, bit(35)) ? obus3SmpFailure_L1; /** PBIOOFIR[36] * mailbox 00 special attention @@ -6639,42 +6639,42 @@ group gPBIOOFIR filter singlebit, cs_root_cause( 8, 11, 14, 17 ) /** PBIOOFIR[52] * data outbound switch internal-links 01 */ - (rPBIOOFIR, bit(52)) ? calloutBusInterface_obus0_th_1; + (rPBIOOFIR, bit(52)) ? obus0SmpFailure_LALL; /** PBIOOFIR[53] * data outbound switch internal - links 23 */ - (rPBIOOFIR, bit(53)) ? calloutBusInterface_obus1_th_1; + (rPBIOOFIR, bit(53)) ? obus1SmpFailure_LALL; /** PBIOOFIR[54] * data outbound switch internal-links 45 */ - (rPBIOOFIR, bit(54)) ? calloutBusInterface_obus2_th_1; + (rPBIOOFIR, bit(54)) ? obus2SmpFailure_LALL; /** PBIOOFIR[55] * data outbound switch internal-links 67 */ - (rPBIOOFIR, bit(55)) ? calloutBusInterface_obus3_th_1; + (rPBIOOFIR, bit(55)) ? obus3SmpFailure_LALL; /** PBIOOFIR[56] * data inbound switch internal-links 01 */ - (rPBIOOFIR, bit(56)) ? calloutBusInterface_obus0_th_1; + (rPBIOOFIR, bit(56)) ? obus0SmpFailure_LALL; /** PBIOOFIR[57] * data inbound switch internal-links 23 */ - (rPBIOOFIR, bit(57)) ? calloutBusInterface_obus1_th_1; + (rPBIOOFIR, bit(57)) ? obus1SmpFailure_LALL; /** PBIOOFIR[58] * data inbound switch internal-links 45 */ - (rPBIOOFIR, bit(58)) ? calloutBusInterface_obus2_th_1; + (rPBIOOFIR, bit(58)) ? obus2SmpFailure_LALL; /** PBIOOFIR[59] * data inbound switch internal-links 67 */ - (rPBIOOFIR, bit(59)) ? calloutBusInterface_obus3_th_1; + (rPBIOOFIR, bit(59)) ? obus3SmpFailure_LALL; /** PBIOOFIR[60:61] * spare diff --git a/src/usr/diag/prdf/common/plat/p9/p9_obus.rule b/src/usr/diag/prdf/common/plat/p9/p9_obus.rule index 92d11df06..45927e91d 100644 --- a/src/usr/diag/prdf/common/plat/p9/p9_obus.rule +++ b/src/usr/diag/prdf/common/plat/p9/p9_obus.rule @@ -133,6 +133,7 @@ chip p9_obus reset (&, 0x09010801); mask (|, 0x09010805); capture group default; + capture group smpCableFFDC; }; register IOOLFIR_MASK @@ -158,6 +159,23 @@ chip p9_obus capture req nonzero("IOOLFIR"); }; + register IOOLFIR_AND + { + name "P9 chip IOOLFIR atomic AND"; + scomaddr 0x09010801; + capture group never; + access write_only; + }; + + register IOOLFIR_MASK_OR + { + name "P9 chip IOOLFIR atomic OR"; + scomaddr 0x09010805; + capture group never; + access write_only; + }; + + ############################################################################ # P9 OBUS target IOOBFIR ############################################################################ @@ -230,6 +248,94 @@ chip p9_obus capture req nonzero("OBPPEFIR"); }; + ############################################################################ + # P9 OBUS targets for cable FFDC + # One additional reg (IOOLFIR) is in default group + ############################################################################ + register OLL0_XMITLANE_CTL + { + name "P9 OBUS target OLL LINK0 TRANSMIT LANE CTL"; + scomaddr 0x09010810; + capture group smpCableFFDC; + }; + + register OLL1_XMITLANE_CTL + { + name "P9 OBUS target OLL LINK1 TRANSMIT LANE CTL"; + scomaddr 0x09010811; + capture group smpCableFFDC; + }; + + register OLL0_RECVLANE_CTL + { + name "P9 OBUS target OLL LINK0 RECEIVE LANE CTL"; + scomaddr 0x09010812; + capture group smpCableFFDC; + }; + + register OLL1_RECVLANE_CTL + { + name "P9 OBUS target OLL LINK1 RECEIVE LANE CTL"; + scomaddr 0x09010813; + capture group smpCableFFDC; + }; + + register OLL0_INFO_REG + { + name "P9 OBUS target OLL LINK0 INFORMATION REG"; + scomaddr 0x09010814; + capture group smpCableFFDC; + }; + + register OLL1_INFO_REG + { + name "P9 OBUS target OLL LINK1 INFORMATION REG"; + scomaddr 0x09010815; + capture group smpCableFFDC; + }; + + register OLL0_ERROR_STATUS_REG + { + name "P9 OBUS target OLL LINK0 ERROR STATUS"; + scomaddr 0x09010816; + capture group smpCableFFDC; + }; + + register OLL1_ERROR_STATUS_REG + { + name "P9 OBUS target OLL LINK1 ERROR STATUS"; + scomaddr 0x09010817; + capture group smpCableFFDC; + }; + + register OLL_REPLAY_THRESHOLD_REG + { + name "P9 OBUS target OLL REPLAY THRESHOLD"; + scomaddr 0x09010818; + capture group smpCableFFDC; + }; + + register OLL_SLECC_THRESHOLD_REG + { + name "P9 OBUS target OLL SL ECC THRESHOLD"; + scomaddr 0x09010819; + capture group smpCableFFDC; + }; + + register OLL0_SYNDROME_CAP_REG + { + name "P9 OBUS target OLL LINK0 SYNDROME CAPTURE"; + scomaddr 0x09010822; + capture group smpCableFFDC; + }; + + register OLL1_SYNDROME_CAP_REG + { + name "P9 OBUS target OLL LINK1 SYNDROME CAPTURE"; + scomaddr 0x09010823; + capture group smpCableFFDC; + }; + # Include registers not defined by the xml .include "p9_obus_regs.rule"; @@ -629,32 +735,32 @@ group gIOOLFIR filter singlebit, cs_root_cause( 54, 55, 56, 57, 58, 59 ) /** IOOLFIR[42] * link0 no spare lane available */ - (rIOOLFIR, bit(42)) ? maxSparesExceeded_obus_clkgrp0; + (rIOOLFIR, bit(42)) ? obusSmpCallout_L0; /** IOOLFIR[43] * link1 no spare lane available */ - (rIOOLFIR, bit(43)) ? maxSparesExceeded_obus_clkgrp1; + (rIOOLFIR, bit(43)) ? obusSmpCallout_L1; /** IOOLFIR[44] * link0 spare done */ - (rIOOLFIR, bit(44)) ? spareDeployed_obus_clkgrp0; + (rIOOLFIR, bit(44)) ? obusSmpCallout_th32_L0; /** IOOLFIR[45] * link1 spare done */ - (rIOOLFIR, bit(45)) ? spareDeployed_obus_clkgrp1; + (rIOOLFIR, bit(45)) ? obusSmpCallout_th32_L1; /** IOOLFIR[46] * link0 too many crc errors */ - (rIOOLFIR, bit(46)) ? tooManyBusErrors_obus_clkgrp0; + (rIOOLFIR, bit(46)) ? obusSmpCallout_L0; /** IOOLFIR[47] * link1 too many crc errors */ - (rIOOLFIR, bit(47)) ? tooManyBusErrors_obus_clkgrp1; + (rIOOLFIR, bit(47)) ? obusSmpCallout_L1; /** IOOLFIR[48] * link0 npu error @@ -679,42 +785,42 @@ group gIOOLFIR filter singlebit, cs_root_cause( 54, 55, 56, 57, 58, 59 ) /** IOOLFIR[52] * link0 correctable array error */ - (rIOOLFIR, bit(52)) ? calloutBusInterface_th_32perDay; + (rIOOLFIR, bit(52)) ? obusSmpCallout_th32_L0; /** IOOLFIR[53] * link1 correctable array error */ - (rIOOLFIR, bit(53)) ? calloutBusInterface_th_32perDay; + (rIOOLFIR, bit(53)) ? obusSmpCallout_th32_L1; /** IOOLFIR[54] * link0 uncorrectable array error */ - (rIOOLFIR, bit(54)) ? calloutBusInterface_th_32perDay; + (rIOOLFIR, bit(54)) ? obusSmpCallout_th32_L0; /** IOOLFIR[55] * link1 uncorrectable array error */ - (rIOOLFIR, bit(55)) ? calloutBusInterface_th_32perDay; + (rIOOLFIR, bit(55)) ? obusSmpCallout_th32_L1; /** IOOLFIR[56] * link0 training failed */ - (rIOOLFIR, bit(56)) ? calloutBusInterface_th_32perDay; + (rIOOLFIR, bit(56)) ? obusSmpFailure_L0; /** IOOLFIR[57] * link1 training failed */ - (rIOOLFIR, bit(57)) ? calloutBusInterface_th_32perDay; + (rIOOLFIR, bit(57)) ? obusSmpFailure_L1; /** IOOLFIR[58] * link0 unrecoverable error */ - (rIOOLFIR, bit(58)) ? calloutBusInterface_th_32perDay; + (rIOOLFIR, bit(58)) ? obusSmpCallout_th32_L0; /** IOOLFIR[59] * link1 unrecoverable error */ - (rIOOLFIR, bit(59)) ? calloutBusInterface_th_32perDay; + (rIOOLFIR, bit(59)) ? obusSmpCallout_th32_L1; /** IOOLFIR[60] * link0 internal error diff --git a/src/usr/diag/prdf/common/plat/p9/p9_obus_actions.rule b/src/usr/diag/prdf/common/plat/p9/p9_obus_actions.rule index 0d5b9390f..ad24b3a40 100644 --- a/src/usr/diag/prdf/common/plat/p9/p9_obus_actions.rule +++ b/src/usr/diag/prdf/common/plat/p9/p9_obus_actions.rule @@ -23,48 +23,68 @@ # # IBM_PROLOG_END_TAG -/** Callout the OBUS interface */ -actionclass calloutObusInterface +actionclass smpCallout0 { - funccall("calloutBusInterfacePlugin"); + funccall("obus_callout_L0"); }; -/** Callout the OBUS interface, threshold 32 per day */ -actionclass calloutBusInterface_th_32perDay +actionclass smpCallout1 { - calloutObusInterface; + funccall("obus_callout_L1"); +}; + +actionclass smpCableFail0 +{ + funccall("obus_fail_L0"); +}; + +actionclass smpCableFail1 +{ + funccall("obus_fail_L1"); +}; + +/** OBUS targets for IOOLFIR handling **/ +actionclass obusSmpCallout_th32_L0 +{ + capture(smpCableFFDC); + smpCallout0; threshold32pday; }; -/** Lane Repair: spare deployed */ -actionclass spareDeployed +actionclass obusSmpCallout_th32_L1 { - calloutObusInterface; - funccall("spareDeployed"); + capture(smpCableFFDC); + smpCallout1; + threshold32pday; +}; + +actionclass obusSmpCallout_L0 +{ + capture(smpCableFFDC); + smpCallout0; + threshold1; }; -/** Lane Repair: max spares exceeded */ -actionclass maxSparesExceeded +actionclass obusSmpCallout_L1 { - calloutObusInterface; + capture(smpCableFFDC); + smpCallout1; threshold1; - funccall("maxSparesExceeded"); }; -/** Lane Repair: too many bus errors */ -actionclass tooManyBusErrors +actionclass obusSmpFailure_L0 { - calloutObusInterface; + capture(smpCableFFDC); + smpCallout0; + smpCableFail0; threshold1; - funccall("tooManyBusErrors"); }; -# Currently handling each OBUS clock group with the same plugins. May optimize -# this later when we add in the DMI Lane Repair support. -actionclass spareDeployed_obus_clkgrp0 { spareDeployed; }; -actionclass spareDeployed_obus_clkgrp1 { spareDeployed; }; -actionclass maxSparesExceeded_obus_clkgrp0 { maxSparesExceeded; }; -actionclass maxSparesExceeded_obus_clkgrp1 { maxSparesExceeded; }; -actionclass tooManyBusErrors_obus_clkgrp0 { tooManyBusErrors; }; -actionclass tooManyBusErrors_obus_clkgrp1 { tooManyBusErrors; }; +actionclass obusSmpFailure_L1 +{ + capture(smpCableFFDC); + smpCallout1; + smpCableFail1; + threshold1; +}; diff --git a/src/usr/diag/prdf/common/plat/p9/p9_proc_common_actions.rule b/src/usr/diag/prdf/common/plat/p9/p9_proc_common_actions.rule index 2aea9f915..6e87a336c 100644 --- a/src/usr/diag/prdf/common/plat/p9/p9_proc_common_actions.rule +++ b/src/usr/diag/prdf/common/plat/p9/p9_proc_common_actions.rule @@ -579,3 +579,92 @@ actionclass analyzeIntCqFirPcRecovError { try( funccall("handleIntCqFirPcRecovError"), level2_M_self_L_th_1 ); }; + +/** proc targets for PBIOOFIR handling **/ +actionclass obus0SmpFailure_L0 +{ + funccall("captureSmpObus0"); + funccall("obus0_callout_L0"); + threshold1; +}; + +actionclass obus0SmpFailure_L1 +{ + funccall("captureSmpObus0"); + funccall("obus0_callout_L1"); + threshold1; +}; + +actionclass obus1SmpFailure_L0 +{ + funccall("captureSmpObus1"); + funccall("obus1_callout_L0"); + threshold1; +}; + +actionclass obus1SmpFailure_L1 +{ + funccall("captureSmpObus1"); + funccall("obus1_callout_L1"); + threshold1; +}; + +actionclass obus2SmpFailure_L0 +{ + funccall("captureSmpObus2"); + funccall("obus2_callout_L0"); + threshold1; +}; + +actionclass obus2SmpFailure_L1 +{ + funccall("captureSmpObus2"); + funccall("obus2_callout_L1"); + threshold1; +}; + +actionclass obus3SmpFailure_L0 +{ + funccall("captureSmpObus3"); + funccall("obus3_callout_L0"); + threshold1; +}; + +actionclass obus3SmpFailure_L1 +{ + funccall("captureSmpObus3"); + funccall("obus3_callout_L1"); + threshold1; +}; + +actionclass obus0SmpFailure_LALL +{ + funccall("captureSmpObus0"); + funccall("obus0_callout_L0"); + funccall("obus0_callout_L1"); + threshold1; +}; + +actionclass obus1SmpFailure_LALL +{ + funccall("captureSmpObus1"); + funccall("obus1_callout_L0"); + funccall("obus1_callout_L1"); + threshold1; +}; + +actionclass obus2SmpFailure_LALL +{ + funccall("captureSmpObus2"); + funccall("obus2_callout_L0"); + funccall("obus2_callout_L1"); + threshold1; +}; + +actionclass obus3SmpFailure_LALL +{ + funccall("captureSmpObus3"); + funccall("obus3_callout_L0"); + funccall("obus3_callout_L1"); + threshold1; +}; diff --git a/src/usr/diag/prdf/common/plat/p9/prdfLaneRepair.C b/src/usr/diag/prdf/common/plat/p9/prdfLaneRepair.C index 0e29cc43a..c7c5d7d10 100644 --- a/src/usr/diag/prdf/common/plat/p9/prdfLaneRepair.C +++ b/src/usr/diag/prdf/common/plat/p9/prdfLaneRepair.C @@ -40,6 +40,10 @@ #include <prdfP9ProcMbCommonExtraSig.H> #include <hwas/common/hwasCallout.H> +#ifndef __HOSTBOOT_MODULE +#include <hwsvSvrErrl.H> +#endif // not hostboot module + using namespace TARGETING; @@ -367,6 +371,463 @@ int32_t handleLaneRepairEvent( ExtensibleChip * i_chip, } +void obus_smpCallout_link( TargetHandle_t &i_smpTgt ) +{ + errlHndl_t l_mainElog = NULL; + l_mainElog = ServiceGeneratorClass::ThisServiceGenerator().getErrl(); + + + if ( NULL == l_mainElog ) + { + PRDF_ERR("smpCallout_link Failed to get the global error log" ); + } + else + { + // add callout(s) on any bit firing + #ifdef __HOSTBOOT_MODULE + l_mainElog->addPartCallout( i_smpTgt, HWAS::SMP_CABLE, + HWAS::SRCI_PRIORITY_MED, HWAS::NO_DECONFIG, HWAS::GARD_Predictive ); + #else + // FSP code + #ifndef ESW_SIM_COMPILE + errlHndl_t l_err = NULL; + + // Call SVPD routine to add callouts + l_err = HWSV::SvrError::AddSMPCalloutAndFFDC(i_smpTgt, l_mainElog); + + if (NULL != l_err) + { + PRDF_ERR("handleSmpCable callouts failed"); + l_err->CollectTrace(PRDF_COMP_NAME, 1024); + l_err->commit( PRDF_COMP_ID, ERRL_ACTION_REPORT ); + delete l_err; + l_err = NULL; + } + #endif // not simulation + + #endif // else FSP side + } // main elog is non-null + + +} // end obus_smpCallout_link - SMP target + + +/** Given the OBUS TARGET and SMP link number -- do the callout **/ +void obus_smpCallout_link( TargetHandle_t &i_obusTgt, uint32_t i_link ) +{ + PredicateCTM l_unitMatch(CLASS_UNIT, TYPE_SMPGROUP ); + TargetHandleList l_smpTargetList; + uint32_t l_smpNum = 0; + TYPE l_targType = getTargetType(i_obusTgt); + + + // Validate we have expected target + if ( TYPE_OBUS != l_targType ) + { + PRDF_ERR("obus_callout Invalid Target(%d) on link%d", + l_targType, i_link ); + PRDF_ASSERT(false); + } + + // Get all SMPGROUPS associated with OBUS target + targetService().getAssociated( + l_smpTargetList, + i_obusTgt, + TARGETING::TargetService::CHILD, + TARGETING::TargetService::ALL, + &l_unitMatch); + + // Find the match in SMPGROUP targets + for ( auto l_smp : l_smpTargetList ) + { + l_smpNum = l_smp->getAttr<ATTR_CHIP_UNIT>(); + + if (i_link == l_smpNum) + { + // We found the right SMPGROUP to call out + obus_smpCallout_link( l_smp ); + break; + } // end if right LINK + + } // end for on smp targets + + return; +} // end obus_smpCallout_link - smp link number + + +/** Given the OBUS unit number and SMP link number -- do the callout **/ +void obus_smpCallout_link( uint32_t i_obusNum, + ExtensibleChip * i_chip, uint32_t i_link ) +{ + // From NEST so it will be a processor target + TargetHandle_t rxTrgt = i_chip->getTrgt(); + + // We need the right OBUS target from this processor + TargetHandle_t l_obus = getConnectedChild(rxTrgt, + TYPE_OBUS, i_obusNum); + + PRDF_ASSERT( NULL != l_obus ); + + // We found the right OBUS target + obus_smpCallout_link( l_obus, i_link ); + +} // end obus_smpCallout_link - obus & smp link numbers + + +int32_t obus_callout_L0( ExtensibleChip * i_chip, + STEP_CODE_DATA_STRUCT & i_sc ) +{ + int32_t rc = SUCCESS; + + // Need the obus target + TargetHandle_t rxTrgt = i_chip->getTrgt(); + // Call out LINK0 in SMPGROUP + obus_smpCallout_link( rxTrgt, 0 ); + + return rc; + +} // end obus_callout_L0 +PRDF_PLUGIN_DEFINE_NS( p9_obus, LaneRepair, obus_callout_L0 ); + + +int32_t obus_callout_L1( ExtensibleChip * i_chip, + STEP_CODE_DATA_STRUCT & i_sc ) +{ + int32_t rc = SUCCESS; + + // Need the obus target + TargetHandle_t rxTrgt = i_chip->getTrgt(); + // Call out LINK1 in SMPGROUP + obus_smpCallout_link( rxTrgt, 1 ); + + return rc; + +} // end obus_callout_L1 +PRDF_PLUGIN_DEFINE_NS( p9_obus, LaneRepair, obus_callout_L1 ); + + +int32_t obus0_callout_L0( ExtensibleChip * i_chip, + STEP_CODE_DATA_STRUCT & i_sc ) +{ + int32_t rc = SUCCESS; + + // callout obus0 link0 + obus_smpCallout_link( 0, i_chip, 0 ); + + return rc; + +} // end obus0_callout_L0 +PRDF_PLUGIN_DEFINE_NS( p9_cumulus, LaneRepair, obus0_callout_L0 ); +PRDF_PLUGIN_DEFINE_NS( p9_nimbus, LaneRepair, obus0_callout_L0 ); + + +int32_t obus0_callout_L1( ExtensibleChip * i_chip, + STEP_CODE_DATA_STRUCT & i_sc ) +{ + int32_t rc = SUCCESS; + + // callout obus0 link1 + obus_smpCallout_link( 0, i_chip, 1 ); + + return rc; + +} // end obus0_callout_L1 +PRDF_PLUGIN_DEFINE_NS( p9_cumulus, LaneRepair, obus0_callout_L1 ); +PRDF_PLUGIN_DEFINE_NS( p9_nimbus, LaneRepair, obus0_callout_L1 ); + + +int32_t obus1_callout_L0( ExtensibleChip * i_chip, + STEP_CODE_DATA_STRUCT & i_sc ) +{ + int32_t rc = SUCCESS; + + // callout obus1 link0 + obus_smpCallout_link( 1, i_chip, 0 ); + + return rc; + +} // end obus1_callout_L0 +PRDF_PLUGIN_DEFINE_NS( p9_cumulus, LaneRepair, obus1_callout_L0 ); +PRDF_PLUGIN_DEFINE_NS( p9_nimbus, LaneRepair, obus1_callout_L0 ); + + +int32_t obus1_callout_L1( ExtensibleChip * i_chip, + STEP_CODE_DATA_STRUCT & i_sc ) +{ + int32_t rc = SUCCESS; + + // callout obus1 link1 + obus_smpCallout_link( 1, i_chip, 1 ); + + return rc; + +} // end obus1_callout_L1 +PRDF_PLUGIN_DEFINE_NS( p9_cumulus, LaneRepair, obus1_callout_L1 ); +PRDF_PLUGIN_DEFINE_NS( p9_nimbus, LaneRepair, obus1_callout_L1 ); + + +int32_t obus2_callout_L0( ExtensibleChip * i_chip, + STEP_CODE_DATA_STRUCT & i_sc ) +{ + int32_t rc = SUCCESS; + + // callout obus2 link0 + obus_smpCallout_link( 2, i_chip, 0 ); + + return rc; + +} // end obus2_callout_L0 +PRDF_PLUGIN_DEFINE_NS( p9_cumulus, LaneRepair, obus2_callout_L0 ); +PRDF_PLUGIN_DEFINE_NS( p9_nimbus, LaneRepair, obus2_callout_L0 ); + + +int32_t obus2_callout_L1( ExtensibleChip * i_chip, + STEP_CODE_DATA_STRUCT & i_sc ) +{ + int32_t rc = SUCCESS; + + // callout obus2 link1 + obus_smpCallout_link( 2, i_chip, 1 ); + + return rc; + +} // end obus2_callout_L1 +PRDF_PLUGIN_DEFINE_NS( p9_cumulus, LaneRepair, obus2_callout_L1 ); +PRDF_PLUGIN_DEFINE_NS( p9_nimbus, LaneRepair, obus2_callout_L1 ); + + +int32_t obus3_callout_L0( ExtensibleChip * i_chip, + STEP_CODE_DATA_STRUCT & i_sc ) +{ + int32_t rc = SUCCESS; + + // callout obus3 link0 + obus_smpCallout_link( 3, i_chip, 0 ); + + return rc; + +} // end obus3_callout_L0 +PRDF_PLUGIN_DEFINE_NS( p9_cumulus, LaneRepair, obus3_callout_L0 ); +PRDF_PLUGIN_DEFINE_NS( p9_nimbus, LaneRepair, obus3_callout_L0 ); + + +int32_t obus3_callout_L1( ExtensibleChip * i_chip, + STEP_CODE_DATA_STRUCT & i_sc ) +{ + int32_t rc = SUCCESS; + + // callout obus3 link0 + obus_smpCallout_link( 3, i_chip, 1 ); + + return rc; + +} // end obus3_callout_L1 +PRDF_PLUGIN_DEFINE_NS( p9_cumulus, LaneRepair, obus3_callout_L1 ); +PRDF_PLUGIN_DEFINE_NS( p9_nimbus, LaneRepair, obus3_callout_L1 ); + + +void obus_clearMaskFail( errlHndl_t &io_errl, TargetHandle_t &i_rxTrgt, + TargetHandle_t &i_txTrgt, uint32_t i_link ) +{ + // ensure we have valid inputs + PRDF_ASSERT( NULL != i_rxTrgt ); + PRDF_ASSERT( NULL != i_txTrgt ); + PRDF_ASSERT( NULL != io_errl ); + + uint32_t l_rc = SUCCESS; + ExtensibleChip *l_rxChip = + (ExtensibleChip *)systemPtr->GetChip( i_rxTrgt ); + ExtensibleChip *l_txChip = + (ExtensibleChip *)systemPtr->GetChip( i_txTrgt ); + + + do + { + if (MODEL_NIMBUS == getChipModel(i_rxTrgt)) + { + PRDF_ERR("[obus_clearMaskFail] called on NIMBUS"); + break; + } // nimbus not supported + + + // These defines are for LINK0 + // (LINK1 will be the next bit for each of these) + #define OBUS_CRC_ERRORS 6 + #define OBUS_ECC_ERRORS 14 + #define OBUS_NO_SPARE 42 + #define OBUS_SPARE_DONE 44 + #define OBUS_TOO_MANY_CRC 46 + #define OBUS_LNK0_TRAINING_FAILED 56 + + // Normal rule file handling should clear bit 56 + // or bit 57 and mask it for the target we got the + // attention on. + // We still need to do it for the other end of the cable. + + // Clear the FIR on other end + SCAN_COMM_REGISTER_CLASS * obusTxFir_and = l_txChip->getRegister("IOOLFIR_AND"); + obusTxFir_and->setAllBits(); + obusTxFir_and->ClearBit(OBUS_LNK0_TRAINING_FAILED + i_link); + // MASK the attention on the other end + SCAN_COMM_REGISTER_CLASS * obusTxMask_or = l_txChip->getRegister("IOOLFIR_MASK_OR"); + obusTxMask_or->clearAllBits(); + obusTxMask_or->SetBit(OBUS_LNK0_TRAINING_FAILED + i_link); + + // Clear other related bits for link0 or link1 + // on the current target with the active attention + SCAN_COMM_REGISTER_CLASS * obusRxFir_and = l_rxChip->getRegister("IOOLFIR_AND"); + obusRxFir_and->setAllBits(); + obusRxFir_and->ClearBit(OBUS_CRC_ERRORS + i_link); + obusRxFir_and->ClearBit(OBUS_ECC_ERRORS + i_link); + obusRxFir_and->ClearBit(OBUS_NO_SPARE + i_link); + obusRxFir_and->ClearBit(OBUS_SPARE_DONE + i_link); + obusRxFir_and->ClearBit(OBUS_TOO_MANY_CRC + i_link); + + // put back the MASK and FIRs to hardware + l_rc = obusTxMask_or->Write(); + l_rc |= obusTxFir_and->Write(); + l_rc |= obusRxFir_and->Write(); + + if ( SUCCESS != l_rc ) + { + PRDF_ERR("obus_clearMaskFail failed handling link %d", i_link); + } + + } while (0); + +} // end obus_clearMaskFail + + + +int32_t obus_fail_L0( ExtensibleChip * i_chip, + STEP_CODE_DATA_STRUCT & i_sc ) +{ + int32_t rc = SUCCESS; + + TargetHandle_t rxTrgt = i_chip->getTrgt(); + TargetHandle_t txTrgt = getTxBusEndPt(rxTrgt); + + do + { + errlHndl_t l_mainElog = NULL; + l_mainElog = ServiceGeneratorClass::ThisServiceGenerator().getErrl(); + if ( NULL == l_mainElog ) + { + PRDF_ERR( "obus_fail Failed to get the global error log" ); + rc = FAIL; + break; + } + + // invoke routine to clear and mask the failure and + // other related bits. + obus_clearMaskFail( l_mainElog, rxTrgt, txTrgt, 0 ); + + } while(0); + + + return rc; + +} // end obus_fail_L0 +PRDF_PLUGIN_DEFINE_NS( p9_obus, LaneRepair, obus_fail_L0 ); + + +int32_t obus_fail_L1( ExtensibleChip * i_chip, + STEP_CODE_DATA_STRUCT & i_sc ) +{ + int32_t rc = SUCCESS; + + TargetHandle_t rxTrgt = i_chip->getTrgt(); + TargetHandle_t txTrgt = getTxBusEndPt(rxTrgt); + + do + { + errlHndl_t l_mainElog = NULL; + l_mainElog = ServiceGeneratorClass::ThisServiceGenerator().getErrl(); + if ( NULL == l_mainElog ) + { + PRDF_ERR( "obus_fail_Failed to get the global error log" ); + rc = FAIL; + break; + } + + // invoke routine to clear and mask the failure and + // other related bits. + obus_clearMaskFail( l_mainElog, rxTrgt, txTrgt, 1 ); + + } while(0); + + return rc; + +} // end obus_fail_L1 +PRDF_PLUGIN_DEFINE_NS( p9_obus, LaneRepair, obus_fail_L1 ); + + +/** Need routine to capture FFDC for PBIOOFIR **/ +void baseCaptureSmpFFDC( ExtensibleChip * i_chip, + STEP_CODE_DATA_STRUCT & io_sc, + uint32_t i_obusNum ) +{ + // get the specific OBUS target we are interested in + TargetHandle_t l_obus = getConnectedChild(i_chip->getTrgt(), + TYPE_OBUS, i_obusNum); + + ExtensibleChip * l_obusChip; + l_obusChip = (ExtensibleChip *)systemPtr->GetChip(l_obus); + // Add OBUS registers for this instance + if( NULL != l_obusChip ) + { + l_obusChip->CaptureErrorData( + io_sc.service_data->GetCaptureData(), + Util::hashString("smpCableFFDC")); + } + +} // baseCaptureSmpFFDC + +int32_t captureSmpObus0( ExtensibleChip * i_chip, + STEP_CODE_DATA_STRUCT & io_sc ) +{ + baseCaptureSmpFFDC( i_chip, io_sc, 0 ); + return SUCCESS; + +} // end captureSmpObus0 +PRDF_PLUGIN_DEFINE_NS( p9_cumulus, LaneRepair, captureSmpObus0 ); +PRDF_PLUGIN_DEFINE_NS( p9_nimbus, LaneRepair, captureSmpObus0 ); + + +int32_t captureSmpObus1( ExtensibleChip * i_chip, + STEP_CODE_DATA_STRUCT & io_sc ) +{ + baseCaptureSmpFFDC( i_chip, io_sc, 1 ); + return SUCCESS; + +} // end captureSmpObus1 +PRDF_PLUGIN_DEFINE_NS( p9_cumulus, LaneRepair, captureSmpObus1 ); +PRDF_PLUGIN_DEFINE_NS( p9_nimbus, LaneRepair, captureSmpObus1 ); + + +int32_t captureSmpObus2( ExtensibleChip * i_chip, + STEP_CODE_DATA_STRUCT & io_sc ) +{ + baseCaptureSmpFFDC( i_chip, io_sc, 2 ); + return SUCCESS; + +} // end captureSmpObus2 +PRDF_PLUGIN_DEFINE_NS( p9_cumulus, LaneRepair, captureSmpObus2 ); +PRDF_PLUGIN_DEFINE_NS( p9_nimbus, LaneRepair, captureSmpObus2 ); + + +int32_t captureSmpObus3( ExtensibleChip * i_chip, + STEP_CODE_DATA_STRUCT & io_sc ) +{ + baseCaptureSmpFFDC( i_chip, io_sc, 3 ); + return SUCCESS; + +} // end captureSmpObus3 +PRDF_PLUGIN_DEFINE_NS( p9_cumulus, LaneRepair, captureSmpObus3 ); +PRDF_PLUGIN_DEFINE_NS( p9_nimbus, LaneRepair, captureSmpObus3 ); + + + int32_t calloutBusInterface( ExtensibleChip * i_chip, STEP_CODE_DATA_STRUCT & i_sc, PRDpriority i_priority ) |
