# IBM_PROLOG_BEGIN_TAG
# This is an automatically generated prolog.
# 
# $Source: src/usr/diag/prdf/plat/pegasus/Membuf_acts_NEST.rule $
# 
# IBM CONFIDENTIAL
# 
# COPYRIGHT International Business Machines Corp. 2012
# 
# p1
# 
# Object Code Only (OCO) source materials
# Licensed Internal Code Source Materials
# IBM HostBoot Licensed Internal Code
# 
# The source code for this program is not published or otherwise
# divested of its trade secrets, irrespective of what has been
# deposited with the U.S. Copyright Office.
# 
# Origin: 30
# 
# IBM_PROLOG_END_TAG 

################################################################################
# NEST Chiplet Registers
################################################################################

rule NestChipletFir
{
  CHECK_STOP:
     (NEST_CHIPLET_CS_FIR       & `17fe000000000000`) & ~NEST_CHIPLET_FIR_MASK;
  RECOVERABLE:
    ((NEST_CHIPLET_RE_FIR >> 2) & `17fe000000000000`) & ~NEST_CHIPLET_FIR_MASK;
};

group gNestChipletFir filter singlebit
{
    /** NEST_CHIPLET_FIR[3]
     *  Attention from LFIR
     */
    (NestChipletFir, bit(3)) ? analyze(gNestLFir);

    /** NEST_CHIPLET_FIR[5]
     *  Attention from DMIFIR
     */
    (NestChipletFir, bit(5)) ? analyze(gDmiFir);

    /** NEST_CHIPLET_FIR[6]
     *  Attention from MBIFIR
     */
    (NestChipletFir, bit(6)) ? analyze(gMbiFir);

    /** NEST_CHIPLET_FIR[7]
     *  Attention from MBSFIR
     */
    (NestChipletFir, bit(7)) ? analyze(gMbsFir);

    /** NEST_CHIPLET_FIR[8|9]
     *  Attention from MBSECCFIRs
     */
    (NestChipletFir, bit(8|9)) ? analyze(gMbsEccFir);

    /** NEST_CHIPLET_FIR[10|11]
     *  Attention from MCBISTFIRs
     */
    (NestChipletFir, bit(10|11)) ? analyze(gMcbistFir);

    /** NEST_CHIPLET_FIR[12]
     *  Attention from NESTFBISTFIR
     */
    (NestChipletFir, bit(12))? analyze(gNestFbistFir);

    /** NEST_CHIPLET_FIR[13]
     *  Attention from SENSORCACHEFIR
     */
    (NestChipletFir, bit(13)) ? analyze(gSensorCacheFir);

    /** NEST_CHIPLET_FIR[14]
     *  Attention from MBS secure FIR
     */
    (NestChipletFir, bit(14))? analyze(gMbsSecureFir);
};

################################################################################
# NEST Chiplet LFIR
################################################################################

rule NestLFir
{
  CHECK_STOP:  NEST_LFIR & ~NEST_LFIR_MASK & ~NEST_LFIR_ACT0 & ~NEST_LFIR_ACT1;
  RECOVERABLE: NEST_LFIR & ~NEST_LFIR_MASK & ~NEST_LFIR_ACT0 &  NEST_LFIR_ACT1;
};

group gNestLFir filter singlebit
{
    /** NEST_LFIR[0]
     *  CFIR internal parity error
     */
    (NestLFir, bit(0)) ? TBDDefaultCallout;

    /** NEST_LFIR[1]
     *  Local errors from GPIO (PCB error)
     */
    (NestLFir, bit(1)) ? TBDDefaultCallout;

    /** NEST_LFIR[2]
     *  Local errors from CC (PCB error)
     */
    (NestLFir, bit(2)) ? TBDDefaultCallout;

    /** NEST_LFIR[3]
     *  Local errors from CC (OPCG, parity, scan collision, ...)
     */
    (NestLFir, bit(3)) ? TBDDefaultCallout;

    /** NEST_LFIR[4]
     *  Local errors from PSC (PCB error)
     */
    (NestLFir, bit(4)) ? TBDDefaultCallout;

    /** NEST_LFIR[5]
     *  Local errors from PSC (parity error)
     */
    (NestLFir, bit(5)) ? TBDDefaultCallout;

    /** NEST_LFIR[6]
     *  Local errors from Thermal (parity error)
     */
    (NestLFir, bit(6)) ? TBDDefaultCallout;

    /** NEST_LFIR[7]
     *  Local errors from Thermal (PCB error)
     */
    (NestLFir, bit(7)) ? TBDDefaultCallout;

    /** NEST_LFIR[8|9]
     *  Local errors from Thermal (Trip error)
     */
    (NestLFir, bit(8|9)) ? TBDDefaultCallout;

    /** NEST_LFIR[10|11]
     *  Local errors from Trace Array ( error)
     */
    (NestLFir, bit(10|11)) ? TBDDefaultCallout;
};

################################################################################
#  NEST Chiplet DMIFIR
################################################################################

rule DmiFir
{
    CHECK_STOP:  DMIFIR & ~DMIFIR_MASK & ~DMIFIR_ACT0 & ~DMIFIR_ACT1;
    RECOVERABLE: DMIFIR & ~DMIFIR_MASK & ~DMIFIR_ACT0 &  DMIFIR_ACT1;
};

group gDmiFir filter singlebit
{
    /** DMIFIR[0]
     *  FIR_RX_INVALID_STATE_OR_PARITY_ERROR
     */
    (DmiFir, bit(0)) ? TBDDefaultCallout;

    /** DMIFIR[1]
     *  FIR_TX_INVALID_STATE_OR_PARITY_ERROR
     */
    (DmiFir, bit(1)) ? TBDDefaultCallout;

    /** DMIFIR[2]
     *  FIR_GCR_HANG_ERROR
     */
    (DmiFir, bit(2)) ? TBDDefaultCallout;

    /** DMIFIR[8]
     *  FIR_RX_BUS0_TRAINING_ERROR
     */
    (DmiFir, bit(8)) ? TBDDefaultCallout;

    /** DMIFIR[9]
     *  FIR_RX_BUS0_SPARE_DEPLOYED
     */
    (DmiFir, bit(9)) ? TBDDefaultCallout;

    /** DMIFIR[10]
     *  FIR_RX_BUS0_MAX_SPARES_EXCEEDED
     */
    (DmiFir, bit(10)) ? TBDDefaultCallout;

    /** DMIFIR[11]
     *  FIR_RX_BUS0_RECAL_OR_DYN_REPAIR_ERROR
     */
    (DmiFir, bit(11)) ? TBDDefaultCallout;

    /** DMIFIR[12]
     *  FIR_RX_BUS0_TOO_MANY_BUS_ERRORS
     */
    (DmiFir, bit(12)) ? TBDDefaultCallout;

    /** DMIFIR[16]
     *  FIR_RX_BUS1_TRAINING_ERROR
     */
    (DmiFir, bit(16)) ? TBDDefaultCallout;

    /** DMIFIR[17]
     *  FIR_RX_BUS1_SPARE_DEPLOYED
     */
    (DmiFir, bit(17)) ? TBDDefaultCallout;

    /** DMIFIR[18]
     *  FIR_RX_BUS1_MAX_SPARES_EXCEEDED
     */
    (DmiFir, bit(18)) ? TBDDefaultCallout;

    /** DMIFIR[19]
     *  FIR_RX_BUS1_RECAL_OR_DYN_REPAIR_ERROR
     */
    (DmiFir, bit(19)) ? TBDDefaultCallout;

    /** DMIFIR[20]
     *  FIR_RX_BUS1_TOO_MANY_BUS_ERRORS
     */
    (DmiFir, bit(20)) ? TBDDefaultCallout;

    /** DMIFIR[24]
     *  FIR_RX_BUS2_TRAINING_ERROR
     */
    (DmiFir, bit(24)) ? TBDDefaultCallout;

    /** DMIFIR[25]
     *  FIR_RX_BUS2_SPARE_DEPLOYED
     */
    (DmiFir, bit(25)) ? TBDDefaultCallout;

    /** DMIFIR[26]
     *  FIR_RX_BUS2_MAX_SPARES_EXCEEDED
     */
    (DmiFir, bit(26)) ? TBDDefaultCallout;

    /** DMIFIR[27]
     *  FIR_RX_BUS2_RECAL_OR_DYN_REPAIR_ERROR
     */
    (DmiFir, bit(27)) ? TBDDefaultCallout;

    /** DMIFIR[28]
     *  FIR_RX_BUS2_TOO_MANY_BUS_ERRORS
     */
    (DmiFir, bit(28)) ? TBDDefaultCallout;

    /** DMIFIR[32]
     *  FIR_RX_BUS3_TRAINING_ERROR
     */
    (DmiFir, bit(32)) ? TBDDefaultCallout;

    /** DMIFIR[33]
     *  FIR_RX_BUS3_SPARE_DEPLOYED
     */
    (DmiFir, bit(33)) ? TBDDefaultCallout;

    /** DMIFIR[34]
     *  FIR_RX_BUS3_MAX_SPARES_EXCEEDED
     */
    (DmiFir, bit(34)) ? TBDDefaultCallout;

    /** DMIFIR[35]
     *  FIR_RX_BUS3_RECAL_OR_DYN_REPAIR_ERROR
     */
    (DmiFir, bit(35)) ? TBDDefaultCallout;

    /** DMIFIR[36]
     *  FIR_RX_BUS3_TOO_MANY_BUS_ERRORS
     */
    (DmiFir, bit(36)) ? TBDDefaultCallout;

    /** DMIFIR[40]
     *  FIR_RX_BUS4_TRAINING_ERROR
     */
    (DmiFir, bit(40)) ? TBDDefaultCallout;

    /** DMIFIR[41]
     *  FIR_RX_BUS4_SPARE_DEPLOYED
     */
    (DmiFir, bit(41)) ? TBDDefaultCallout;

    /** DMIFIR[42]
     *  FIR_RX_BUS4_MAX_SPARES_EXCEEDED
     */
    (DmiFir, bit(42)) ? TBDDefaultCallout;

    /** DMIFIR[43]
     *  FIR_RX_BUS4_RECAL_OR_DYN_REPAIR_ERROR
     */
    (DmiFir, bit(43)) ? TBDDefaultCallout;

    /** DMIFIR[44]
     *  FIR_RX_BUS4_TOO_MANY_BUS_ERRORS
     */
    (DmiFir, bit(44)) ? TBDDefaultCallout;

    /** DMIFIR[48]
     *  FIR_SCOMFIR_ERROR
     */
    (DmiFir, bit(48)) ? TBDDefaultCallout;

    /** DMIFIR[49]
     *  FIR_SCOMFIR_ERROR_CLONE
     */
    (DmiFir, bit(49)) ? TBDDefaultCallout;
};

################################################################################
#  NEST Chiplet DMIFIR
################################################################################

rule SensorCacheFir
{
    CHECK_STOP:  SENSORCACHEFIR & ~SENSORCACHEFIR_MASK & ~SENSORCACHEFIR_ACT0 & ~SENSORCACHEFIR_ACT1;
    RECOVERABLE: SENSORCACHEFIR & ~SENSORCACHEFIR_MASK & ~SENSORCACHEFIR_ACT0 &  SENSORCACHEFIR_ACT1;
};

group gSensorCacheFir filter singlebit
{
    /** SENSORCACHEFIR[0]
     *  SCAC_LFIR_I2CMINVADDR
     */
    (SensorCacheFir, bit(0)) ? TBDDefaultCallout;

    /** SENSORCACHEFIR[1]
     *  SCAC_LFIR_I2CMINVWRITE
     */
    (SensorCacheFir, bit(1)) ? TBDDefaultCallout;

    /** SENSORCACHEFIR[2]
     *  SCAC_LFIR_I2CMINVREAD
     */
    (SensorCacheFir, bit(2)) ? TBDDefaultCallout;

    /** SENSORCACHEFIR[3]
     *  SCAC_LFIR_I2CMAPAR
     */
    (SensorCacheFir, bit(3)) ? TBDDefaultCallout;

    /** SENSORCACHEFIR[4]
     *  SCAC_LFIR_I2CMPAR
     */
    (SensorCacheFir, bit(4)) ? TBDDefaultCallout;

    /** SENSORCACHEFIR[5]
     *  SCAC_LFIR_I2CMLBPAR
     */
    (SensorCacheFir, bit(5)) ? TBDDefaultCallout;

    /** SENSORCACHEFIR[10]
     *  SCAC_LFIR_I2CMINVCMD
     */
    (SensorCacheFir, bit(10)) ? TBDDefaultCallout;

    /** SENSORCACHEFIR[11]
     *  SCAC_LFIR_I2CMPERR
     */
    (SensorCacheFir, bit(11)) ? TBDDefaultCallout;

    /** SENSORCACHEFIR[12]
     *  SCAC_LFIR_I2CMOVERRUN
     */
    (SensorCacheFir, bit(12)) ? TBDDefaultCallout;

    /** SENSORCACHEFIR[13]
     *  SCAC_LFIR_I2CMACCESS
     */
    (SensorCacheFir, bit(13)) ? TBDDefaultCallout;

    /** SENSORCACHEFIR[14]
     *  SCAC_LFIR_I2CMARB
     */
    (SensorCacheFir, bit(14)) ? TBDDefaultCallout;

    /** SENSORCACHEFIR[15]
     *  SCAC_LFIR_I2CMNACK
     */
    (SensorCacheFir, bit(15)) ? TBDDefaultCallout;

    /** SENSORCACHEFIR[16]
     *  SCAC_LFIR_I2CMSTOP
     */
    (SensorCacheFir, bit(16)) ? TBDDefaultCallout;

    /** SENSORCACHEFIR[17]
     *  SCAC_LFIR_LOCALPIB1
     */
    (SensorCacheFir, bit(17)) ? TBDDefaultCallout;

    /** SENSORCACHEFIR[18]
     *  SCAC_LFIR_LOCALPIB2
     */
    (SensorCacheFir, bit(18)) ? TBDDefaultCallout;

    /** SENSORCACHEFIR[19]
     *  SCAC_LFIR_LOCALPIB3
     */
    (SensorCacheFir, bit(19)) ? TBDDefaultCallout;

    /** SENSORCACHEFIR[20]
     *  SCAC_LFIR_LOCALPIB4
     */
    (SensorCacheFir, bit(20)) ? TBDDefaultCallout;

    /** SENSORCACHEFIR[21]
     *  SCAC_LFIR_LOCALPIB5
     */
    (SensorCacheFir, bit(21)) ? TBDDefaultCallout;

    /** SENSORCACHEFIR[22]
     *  SCAC_LFIR_LOCALPIB6
     */
    (SensorCacheFir, bit(22)) ? TBDDefaultCallout;

    /** SENSORCACHEFIR[23]
     *  SCAC_LFIR_LOCALPIB7
     */
    (SensorCacheFir, bit(23)) ? TBDDefaultCallout;

    /** SENSORCACHEFIR[24]
     *  SCAC_LFIR_STALLERROR
     */
    (SensorCacheFir, bit(24)) ? TBDDefaultCallout;

    /** SENSORCACHEFIR[25]
     *  SCAC_LFIR_REGPARERR
     */
    (SensorCacheFir, bit(25)) ? TBDDefaultCallout;

    /** SENSORCACHEFIR[26]
     *  SCAC_LFIR_REGPARERRX
     */
    (SensorCacheFir, bit(26)) ? TBDDefaultCallout;

    /** SENSORCACHEFIR[32]
     *  SCAC_LFIR_SMERR
     */
    (SensorCacheFir, bit(32)) ? TBDDefaultCallout;

    /** SENSORCACHEFIR[33]
     *  SCAC_LFIR_REGACCERR
     */
    (SensorCacheFir, bit(33)) ? TBDDefaultCallout;

    /** SENSORCACHEFIR[34]
     *  SCAC_LFIR_RESETERR
     */
    (SensorCacheFir, bit(34)) ? TBDDefaultCallout;

    /** SENSORCACHEFIR[35]
     *  SCAC_LFIR_INTERNAL_SCOM_ERROR
     */
    (SensorCacheFir, bit(35)) ? TBDDefaultCallout;

    /** SENSORCACHEFIR[36]
     *  SCAC_LFIR_INTERNAL_SCOM_ERROR_CLONE
     */
    (SensorCacheFir, bit(36)) ? TBDDefaultCallout;
};

################################################################################
#  NEST Chiplet MBIFIR
################################################################################

rule MbiFir
{
    CHECK_STOP:  MBIFIR & ~MBIFIR_MASK & ~MBIFIR_ACT0 & ~MBIFIR_ACT1;
    RECOVERABLE: MBIFIR & ~MBIFIR_MASK & ~MBIFIR_ACT0 &  MBIFIR_ACT1;
};

group gMbiFir filter singlebit
{
    /** MbiFir[0]
     *  MBIFIRQ_REPLAY_TIMEOUT
     */
    (MbiFir, bit(0)) ? TBDDefaultCallout;

    /** MbiFir[1]
     *  MBIFIRQ_CHANNEL_FAIL
     */
    (MbiFir, bit(1)) ? TBDDefaultCallout;

    /** MbiFir[2]
     *  MBIFIRQ_CRC_ERROR
     */
    (MbiFir, bit(2)) ? TBDDefaultCallout;

    /** MbiFir[3]
     *  MBIFIRQ_FRAME_NOACK
     */
    (MbiFir, bit(3)) ? TBDDefaultCallout;

    /** MbiFir[4]
     *  MBIFIRQ_SEQID_OUT_OF_ORDER
     */
    (MbiFir, bit(4)) ? TBDDefaultCallout;

    /** MbiFir[5]
     *  MBIFIRQ_REPLAY_BUFFER_ECC_CE
     */
    (MbiFir, bit(5)) ? TBDDefaultCallout;

    /** MbiFir[6]
     *  MBIFIRQ_REPLAY_BUFFER_ECC_UE
     */
    (MbiFir, bit(6)) ? TBDDefaultCallout;

    /** MbiFir[7]
     *  MBIFIRQ_MBI_STATE_MACHINE_TIMEOUT
     */
    (MbiFir, bit(7)) ? TBDDefaultCallout;

    /** MbiFir[8]
     *  MBIFIRQ_MBI_INTERNAL_CONTROL_PARITY_ERROR
     */
    (MbiFir, bit(8)) ? TBDDefaultCallout;

    /** MbiFir[9]
     *  MBIFIRQ_MBI_DATA_FLOW_PARITY_ERROR
     */
    (MbiFir, bit(9)) ? TBDDefaultCallout;

    /** MbiFir[10]
     *  MBIFIRQ_CRC_PERFORMANCE_DEGRADATION
     */
    (MbiFir, bit(10)) ? TBDDefaultCallout;

    /** MbiFir[11]
     *  MBIFIRQ_HOST_MC_GLOBAL_CHECKSTOP
     */
    (MbiFir, bit(11)) ? TBDDefaultCallout;

    /** MbiFir[12]
     *  MBIFIRQ_HOST_MC_TRACESTOP
     */
    (MbiFir, bit(12)) ? TBDDefaultCallout;

    /** MbiFir[13]
     *  MBIFIRQ_CHANNEL_INTERLOCK_FAIL
     */
    (MbiFir, bit(13)) ? TBDDefaultCallout;

    /** MbiFir[14]
     *  MBIFIRQ_HOST_MC_LOCAL_CHECKSTOP
     */
    (MbiFir, bit(14)) ? TBDDefaultCallout;

    /** MbiFir[15]
     *  MBIFIRQ_FRTL_CONTER_OVERFLOW
     */
    (MbiFir, bit(15)) ? TBDDefaultCallout;

    /** MbiFir[16]
     *  MBIFIRQ_SCOM_REGISTER_PARITY_ERROR
     */
    (MbiFir, bit(16)) ? TBDDefaultCallout;

    /** MbiFir[17]
     *  MBIFIRQ_IO_FAULT: IO to MBI
     */
    (MbiFir, bit(17)) ? TBDDefaultCallout;

    /** MbiFir[18]
     *  MBIFIRQ_MULTIPLE_REPLAY
     */
    (MbiFir, bit(18)) ? TBDDefaultCallout;

    /** MbiFir[19]
     *  MBIFIRQ_MBICFG_PARITY_SCOM_ERROR
     */
    (MbiFir, bit(19)) ? TBDDefaultCallout;

    /** MbiFir[20]
     *  MBIFIRQ_BUFFER_OVERRUN_ERROR
     */
    (MbiFir, bit(20)) ? TBDDefaultCallout;

    /** MbiFir[25]
     *  MBIFIRQ_INTERNAL_SCOM_ERROR_CLONE
     */
    (MbiFir, bit(25)) ? TBDDefaultCallout;

    /** MbiFir[26]
     *  MBIFIRQ_INTERNAL_SCOM_ERROR_CLONE_COPY
     */
    (MbiFir, bit(26)) ? TBDDefaultCallout;
};

################################################################################
#  NEST Chiplet MBSFIR
################################################################################

rule MbsFir
{
    CHECK_STOP:  MBSFIR & ~MBSFIR_MASK & ~MBSFIR_ACT0 & ~MBSFIR_ACT1;
    RECOVERABLE: MBSFIR & ~MBSFIR_MASK & ~MBSFIR_ACT0 &  MBSFIR_ACT1;
};

group gMbsFir filter singlebit
{
    /** MBSFIR[0]
     *  MBS_FIR_REG_HOST_PROTOCOL_ERROR
     */
    (MbsFir, bit(0)) ? TBDDefaultCallout;

    /** MBSFIR[1]
     *  MBS_FIR_REG_INT_PROTOCOL_ERROR
     */
    (MbsFir, bit(1)) ? TBDDefaultCallout;

    /** MBSFIR[2]
     *  MBS_FIR_REG_INVALID_ADDRESS_ERROR
     */
    (MbsFir, bit(2)) ? TBDDefaultCallout;

    /** MBSFIR[3]
     *  MBS_FIR_REG_EXTERNAL_TIMEOUT
     */
    (MbsFir, bit(3)) ? TBDDefaultCallout;

    /** MBSFIR[4]
     *  MBS_FIR_REG_INTERNAL_TIMEOUT
     */
    (MbsFir, bit(4)) ? TBDDefaultCallout;

    /** MBSFIR[5]
     *  MBS_FIR_REG_INT_BUFFER_CE
     */
    (MbsFir, bit(5)) ? TBDDefaultCallout;

    /** MBSFIR[6]
     *  MBS_FIR_REG_INT_BUFFER_UE
     */
    (MbsFir, bit(6)) ? TBDDefaultCallout;

    /** MBSFIR[7]
     *  MBS_FIR_REG_INT_BUFFER_SUE
     */
    (MbsFir, bit(7)) ? TBDDefaultCallout;

    /** MBSFIR[8]
     *  MBS_FIR_REG_INT_PARITY_ERROR
     */
    (MbsFir, bit(8)) ? TBDDefaultCallout;

    /** MBSFIR[9]
     *  MBS_FIR_REG_CACHE_SRW_CE
     */
    (MbsFir, bit(9)) ? TBDDefaultCallout;

    /** MBSFIR[10]
     *  MBS_FIR_REG_CACHE_SRW_UE
     */
    (MbsFir, bit(10)) ? TBDDefaultCallout;

    /** MBSFIR[11]
     *  MBS_FIR_REG_CACHE_SRW_SUE
     */
    (MbsFir, bit(11)) ? TBDDefaultCallout;

    /** MBSFIR[12]
     *  MBS_FIR_REG_CACHE_CO_CE
     */
    (MbsFir, bit(12)) ? TBDDefaultCallout;

    /** MBSFIR[13]
     *  MBS_FIR_REG_CACHE_CO_UE
     */
    (MbsFir, bit(13)) ? TBDDefaultCallout;

    /** MBSFIR[14]
     *  MBS_FIR_REG_CACHE_CO_SUE
     */
    (MbsFir, bit(14)) ? TBDDefaultCallout;

    /** MBSFIR[15]
     *  MBS_FIR_REG_DIR_CE
     */
    (MbsFir, bit(15)) ? TBDDefaultCallout;

    /** MBSFIR[16]
     *  MBS_FIR_REG_DIR_UE
     */
    (MbsFir, bit(16)) ? TBDDefaultCallout;

    /** MBSFIR[17]
     *  MBS_FIR_REG_DIR_MEMBER_DELETED
     */
    (MbsFir, bit(17)) ? TBDDefaultCallout;

    /** MBSFIR[18]
     *  MBS_FIR_REG_DIR_ALL_MEMBERS_DELETED
     */
    (MbsFir, bit(18)) ? TBDDefaultCallout;

    /** MBSFIR[19]
     *  MBS_FIR_REG_LRU_ERROR
     */
    (MbsFir, bit(19)) ? TBDDefaultCallout;

    /** MBSFIR[20]
     *  MBS_FIR_REG_EDRAM_ERROR
     */
    (MbsFir, bit(20)) ? TBDDefaultCallout;

    /** MBSFIR[21]
     *  MBS_FIR_REG_EMERGENCY_THROTTLE_SET
     */
    (MbsFir, bit(21)) ? TBDDefaultCallout;

    /** MBSFIR[22]
     *  MBS_FIR_REG_HOST_INBAND_READ_ERROR
     */
    (MbsFir, bit(22)) ? TBDDefaultCallout;

    /** MBSFIR[23]
     *  MBS_FIR_REG_HOST_INBAND_WRITE_ERROR
     */
    (MbsFir, bit(23)) ? TBDDefaultCallout;

    /** MBSFIR[24]
     *  MBS_FIR_REG_OCC_INBAND_READ_ERROR
     */
    (MbsFir, bit(24)) ? TBDDefaultCallout;

    /** MBSFIR[25]
     *  MBS_FIR_REG_OCC_INBAND_WRITE_ERROR
     */
    (MbsFir, bit(25)) ? TBDDefaultCallout;

    /** MBSFIR[26]
     *  MBS_FIR_REG_SRB_BUFFER_CE
     */
    (MbsFir, bit(26)) ? TBDDefaultCallout;

    /** MBSFIR[27]
     *  MBS_FIR_REG_SRB_BUFFER_UE
     */
    (MbsFir, bit(27)) ? TBDDefaultCallout;

    /** MBSFIR[28]
     *  MBS_FIR_REG_SRB_BUFFER_SUE
     */
    (MbsFir, bit(28)) ? TBDDefaultCallout;

    /** MBSFIR[29]
     *  MBS_FIR_REG_INTERNAL_SCOM_ERROR
     */
    (MbsFir, bit(29)) ? TBDDefaultCallout;

    /** MBSFIR[30]
     *  MBS_FIR_REG_INTERNAL_SCOM_ERROR_COPY
     */
    (MbsFir, bit(30)) ? TBDDefaultCallout;
};

################################################################################
#  NEST Chiplet MBSECC01FIR and MBSECC23FIR
################################################################################

rule MbsEcc01Fir
{
  CHECK_STOP:
    MBSECC01FIR & ~MBSECC01FIR_MASK & ~MBSECC01FIR_ACT0 & ~MBSECC01FIR_ACT1;
  RECOVERABLE:
    MBSECC01FIR & ~MBSECC01FIR_MASK & ~MBSECC01FIR_ACT0 &  MBSECC01FIR_ACT1;
};

rule MbsEcc23Fir
{
  CHECK_STOP:
    MBSECC23FIR & ~MBSECC23FIR_MASK & ~MBSECC23FIR_ACT0 & ~MBSECC23FIR_ACT1;
  RECOVERABLE:
    MBSECC23FIR & ~MBSECC23FIR_MASK & ~MBSECC23FIR_ACT0 &  MBSECC23FIR_ACT1;
};

group gMbsEccFir filter singlebit
{
    /** MBSECCFIR01[0:7]
     *  MBECCFIR_MEMORY_MPE_RANK_0_7
     */
    (MbsEcc01Fir, bit(0|1|2|3|4|5|6|7)) ? TBDDefaultCallout;

    /** MBSECCFIR23[0:7]
     *  MBECCFIR_MEMORY_MPE_RANK_0_7
     */
    (MbsEcc23Fir, bit(0|1|2|3|4|5|6|7)) ? TBDDefaultCallout;

    /** MBSECCFIR01[16]
     *  MBECCFIR_MEMORY_NCE
     */
    (MbsEcc01Fir, bit(16)) ? TBDDefaultCallout;

    /** MBSECCFIR23[16]
     *  MBECCFIR_MEMORY_NCE
     */
    (MbsEcc23Fir, bit(16)) ? TBDDefaultCallout;

    /** MBSECCFIR01[17]
     *  MBECCFIR_MEMORY_RCE
     */
    (MbsEcc01Fir, bit(17)) ? TBDDefaultCallout;

    /** MBSECCFIR23[17]
     *  MBECCFIR_MEMORY_RCE
     */
    (MbsEcc23Fir, bit(17)) ? TBDDefaultCallout;

    /** MBSECCFIR01[18]
     *  MBECCFIR_MEMORY_SUE
     */
    (MbsEcc01Fir, bit(18)) ? TBDDefaultCallout;

    /** MBSECCFIR23[18]
     *  MBECCFIR_MEMORY_SUE
     */
    (MbsEcc23Fir, bit(18)) ? TBDDefaultCallout;

    /** MBSECCFIR01[19]
     *  MBECCFIR_MEMORY_UE
     */
    (MbsEcc01Fir, bit(19)) ? TBDDefaultCallout;

    /** MBSECCFIR23[19]
     *  MBECCFIR_MEMORY_UE
     */
    (MbsEcc23Fir, bit(19)) ? TBDDefaultCallout;

    /** MBSECCFIR01[20:27]
     *  MBECCFIR_MAINT_MPE_RANK_0_7
     */
    (MbsEcc01Fir, bit(20|21|22|23|24|25|26|27)) ? TBDDefaultCallout;

    /** MBSECCFIR23[20:27]
     *  MBECCFIR_MAINT_MPE_RANK_0_7
     */
    (MbsEcc23Fir, bit(20|21|22|23|24|25|26|27)) ? TBDDefaultCallout;

    /** MBSECCFIR01[36]
     *  MBECCFIR_MAINTENANCE_NCE
     */
    (MbsEcc01Fir, bit(36)) ? TBDDefaultCallout;

    /** MBSECCFIR23[36]
     *  MBECCFIR_MAINTENANCE_NCE
     */
    (MbsEcc23Fir, bit(36)) ? TBDDefaultCallout;

    /** MBSECCFIR01[37]
     *  MBECCFIR_MAINTENANCE_SCE
     */
    (MbsEcc01Fir, bit(37)) ? TBDDefaultCallout;

    /** MBSECCFIR23[37]
     *  MBECCFIR_MAINTENANCE_SCE
     */
    (MbsEcc23Fir, bit(37)) ? TBDDefaultCallout;

    /** MBSECCFIR01[38]
     *  MBECCFIR_MAINTENANCE_MCE
     */
    (MbsEcc01Fir, bit(38)) ? TBDDefaultCallout;

    /** MBSECCFIR23[38]
     *  MBECCFIR_MAINTENANCE_MCE
     */
    (MbsEcc23Fir, bit(38)) ? TBDDefaultCallout;

    /** MBSECCFIR01[39]
     *  MBECCFIR_MAINTENANCE_RCE
     */
    (MbsEcc01Fir, bit(39)) ? TBDDefaultCallout;

    /** MBSECCFIR23[39]
     *  MBECCFIR_MAINTENANCE_RCE
     */
    (MbsEcc23Fir, bit(39)) ? TBDDefaultCallout;

    /** MBSECCFIR01[40]
     *  MBECCFIR_MAINTENANCE_SUE
     */
    (MbsEcc01Fir, bit(40)) ? TBDDefaultCallout;

    /** MBSECCFIR23[40]
     *  MBECCFIR_MAINTENANCE_SUE
     */
    (MbsEcc23Fir, bit(40)) ? TBDDefaultCallout;

    /** MBSECCFIR01[41]
     *  MBECCFIR_MAINTENANCE_UE
     */
    (MbsEcc01Fir, bit(41)) ? TBDDefaultCallout;

    /** MBSECCFIR23[41]
     *  MBECCFIR_MAINTENANCE_UE
     */
    (MbsEcc23Fir, bit(41)) ? TBDDefaultCallout;

    /** MBSECCFIR01[42]
     *  MBECCFIR_MPE_DURING_USE_MAINTENANCE_MARK_MODE
     */
    (MbsEcc01Fir, bit(42)) ? TBDDefaultCallout;

    /** MBSECCFIR23[42]
     *  MBECCFIR_MPE_DURING_USE_MAINTENANCE_MARK_MODE
     */
    (MbsEcc23Fir, bit(42)) ? TBDDefaultCallout;

    /** MBSECCFIR01[43]
     *  MBECCFIR_PREFETCH_MEMORY_UE
     */
    (MbsEcc01Fir, bit(43)) ? TBDDefaultCallout;

    /** MBSECCFIR23[43]
     *  MBECCFIR_PREFETCH_MEMORY_UE
     */
    (MbsEcc23Fir, bit(43)) ? TBDDefaultCallout;

    /** MBSECCFIR01[44]
     *  MBECCFIR_MEMORY_RCD_PARITY_ERROR
     */
    (MbsEcc01Fir, bit(44)) ? TBDDefaultCallout;

    /** MBSECCFIR23[44]
     *  MBECCFIR_MEMORY_RCD_PARITY_ERROR
     */
    (MbsEcc23Fir, bit(44)) ? TBDDefaultCallout;

    /** MBSECCFIR01[45]
     *  MBECCFIR_MAINTENANCE_RCD_PARITY_ERROR
     */
    (MbsEcc01Fir, bit(45)) ? TBDDefaultCallout;

    /** MBSECCFIR23[45]
     *  MBECCFIR_MAINTENANCE_RCD_PARITY_ERROR
     */
    (MbsEcc23Fir, bit(45)) ? TBDDefaultCallout;

    /** MBSECCFIR01[46]
     *  MBECCFIR_RECOVERABLE_CONFIGURATION_REGISTER_PARITY_ERROR
     */
    (MbsEcc01Fir, bit(46)) ? TBDDefaultCallout;

    /** MBSECCFIR23[46]
     *  MBECCFIR_RECOVERABLE_CONFIGURATION_REGISTER_PARITY_ERROR
     */
    (MbsEcc23Fir, bit(46)) ? TBDDefaultCallout;

    /** MBSECCFIR01[47]
     *  MBECCFIR_UNRECOVERABLE_CONFIGURATION_REGISTER_PARITY_ERROR
     */
    (MbsEcc01Fir, bit(47)) ? TBDDefaultCallout;

    /** MBSECCFIR23[47]
     *  MBECCFIR_UNRECOVERABLE_CONFIGURATION_REGISTER_PARITY_ERROR
     */
    (MbsEcc23Fir, bit(47)) ? TBDDefaultCallout;

    /** MBSECCFIR01[48]
     *  MBECCFIR_MASKABLE_CONFIGURATION_REGISTER_PARITY_ERROR
     */
    (MbsEcc01Fir, bit(48)) ? TBDDefaultCallout;

    /** MBSECCFIR23[48]
     *  MBECCFIR_MASKABLE_CONFIGURATION_REGISTER_PARITY_ERROR
     */
    (MbsEcc23Fir, bit(48)) ? TBDDefaultCallout;

    /** MBSECCFIR01[49]
     *  MBECCFIR_ECC_DATAPATH_PARITY_ERROR
     */
    (MbsEcc01Fir, bit(49)) ? TBDDefaultCallout;

    /** MBSECCFIR23[49]
     *  MBECCFIR_ECC_DATAPATH_PARITY_ERROR
     */
    (MbsEcc23Fir, bit(49)) ? TBDDefaultCallout;

    /** MBSECCFIR01[50]
     *  MBECCFIR_INTERNAL_SCOM_ERROR
     */
    (MbsEcc01Fir, bit(50)) ? TBDDefaultCallout;

    /** MBSECCFIR23[50]
     *  MBECCFIR_INTERNAL_SCOM_ERROR
     */
    (MbsEcc23Fir, bit(50)) ? TBDDefaultCallout;

    /** MBSECCFIR01[51]
     *  MBECCFIR_INTERNAL_SCOM_ERROR_COPY
     */
    (MbsEcc01Fir, bit(51)) ? TBDDefaultCallout;

    /** MBSECCFIR23[51]
     *  MBECCFIR_INTERNAL_SCOM_ERROR_COPY
     */
    (MbsEcc23Fir, bit(51)) ? TBDDefaultCallout;
};

################################################################################
#  NEST Chiplet MCBIST01FIR and MCBIST23FIR
################################################################################

rule Mcbist01Fir
{
  CHECK_STOP:
    MCBIST01FIR & ~MCBIST01FIR_MASK & ~MCBIST01FIR_ACT0 & ~MCBIST01FIR_ACT1;
  RECOVERABLE:
    MCBIST01FIR & ~MCBIST01FIR_MASK & ~MCBIST01FIR_ACT0 &  MCBIST01FIR_ACT1;
};

rule Mcbist23Fir
{
  CHECK_STOP:
    MCBIST23FIR & ~MCBIST23FIR_MASK & ~MCBIST23FIR_ACT0 & ~MCBIST23FIR_ACT1;
  RECOVERABLE:
    MCBIST23FIR & ~MCBIST23FIR_MASK & ~MCBIST23FIR_ACT0 &  MCBIST23FIR_ACT1;
};

group gMcbistFir filter singlebit
{
    /** MCBISTFIR01[0]
     *  MBSFIRQ_SCOM_PAR_ERRORS
     */
    (Mcbist01Fir, bit(0)) ? TBDDefaultCallout;

    /** MCBISTFIR23[0]
     *  MBSFIRQ_SCOM_PAR_ERRORS
     */
    (Mcbist23Fir, bit(0)) ? TBDDefaultCallout;

    /** MCBISTFIR01[1]
     *  MBSFIRQ_MBX_PAR_ERRORS
     */
    (Mcbist01Fir, bit(1)) ? TBDDefaultCallout;

    /** MCBISTFIR23[1]
     *  MBSFIRQ_MBX_PAR_ERRORS
     */
    (Mcbist23Fir, bit(1)) ? TBDDefaultCallout;

    /** MCBISTFIR01[15]
     *  MBSFIRQ_INTERNAL_SCOM_ERROR
     */
    (Mcbist01Fir, bit(15)) ? TBDDefaultCallout;

    /** MCBISTFIR23[15]
     *  MBSFIRQ_INTERNAL_SCOM_ERROR
     */
    (Mcbist23Fir, bit(15)) ? TBDDefaultCallout;

    /** MCBISTFIR01[16]
     *  MBSFIRQ_INTERNAL_SCOM_ERROR_CLONE
     */
    (Mcbist01Fir, bit(16)) ? TBDDefaultCallout;

    /** MCBISTFIR23[16]
     *  MBSFIRQ_INTERNAL_SCOM_ERROR_CLONE
     */
    (Mcbist23Fir, bit(16)) ? TBDDefaultCallout;
};

################################################################################
#  NEST Chiplet NESTFBISTFIR
################################################################################

rule NestFbistFir
{
  CHECK_STOP:
    NESTFBISTFIR & ~NESTFBISTFIR_MASK & ~NESTFBISTFIR_ACT0 & ~NESTFBISTFIR_ACT1;
  RECOVERABLE:
    NESTFBISTFIR & ~NESTFBISTFIR_MASK & ~NESTFBISTFIR_ACT0 &  NESTFBISTFIR_ACT1;
};

group gNestFbistFir filter singlebit
{
    /** NESTFBISTFIR[0]
     *  FBN_FIR_REG_FBN_SCOM_UE
     */
    (NestFbistFir, bit(0)) ? TBDDefaultCallout;

    /** NESTFBISTFIR[1]
     *  FBN_FIR_REG_FBN_USCHK_1HOT
     */
    (NestFbistFir, bit(1)) ? TBDDefaultCallout;

    /** NESTFBISTFIR[2]
     *  FBN_FIR_REG_FBN_USCHK_DATA_DROP
     */
    (NestFbistFir, bit(2)) ? TBDDefaultCallout;

    /** NESTFBISTFIR[3]
     *  FBN_FIR_REG_FBN_DGEN_1HOT
     */
    (NestFbistFir, bit(3)) ? TBDDefaultCallout;

    /** NESTFBISTFIR[4]
     *  FBN_FIR_REG_FBN_CMD_1HOT
     */
    (NestFbistFir, bit(4)) ? TBDDefaultCallout;

    /** NESTFBISTFIR[5]
     *  FBN_FIR_REG_FBN_CMD_EARLY_RESPONSE
     */
    (NestFbistFir, bit(5)) ? TBDDefaultCallout;

    /** NESTFBISTFIR[6]
     *  FBN_FIR_REG_FBN_FBIST_FAIL
     */
    (NestFbistFir, bit(6)) ? TBDDefaultCallout;

    /** NESTFBISTFIR[7]
     *  FBN_FIR_REG_FBN_US_CRC_ERR
     */
    (NestFbistFir, bit(7)) ? TBDDefaultCallout;

    /** NESTFBISTFIR[15]
     *  FBN_FIR_REG_INTERNAL_SCOM_ERROR
     */
    (NestFbistFir, bit(15)) ? TBDDefaultCallout;

    /** NESTFBISTFIR[16]
     *  FBN_FIR_REG_INTERNAL_SCOM_ERROR_CLONE
     */
    (NestFbistFir, bit(16)) ? TBDDefaultCallout;
};

################################################################################
#  NEST Chiplet MBSSECUREFIR
################################################################################

rule MbsSecureFir
{
  CHECK_STOP:
    MBSSECUREFIR & ~MBSSECUREFIR_MASK & ~MBSSECUREFIR_ACT0 & ~MBSSECUREFIR_ACT1;
  # NOTE: This secure FIR will only report checkstop attentions.
};

group gMbsSecureFir filter singlebit
{
    /** MBSSECUREFIR[0]
     *  MBSSIRQ_INVALID_MBSXCR_ACCESS
     */
    (MbsSecureFir, bit(0)) ? TBDDefaultCallout;

    /** MBSSECUREFIR[1]
     *  MBSSIRQ_INVALID_MBAXCR01_ACCESS
     */
    (MbsSecureFir, bit(1)) ? TBDDefaultCallout;

    /** MBSSECUREFIR[2]
     *  MBSSIRQ_INVALID_MBAXCR23_ACCESS
     */
    (MbsSecureFir, bit(2)) ? TBDDefaultCallout;

    /** MBSSECUREFIR[3]
     *  MBSSIRQ_INVALID_MBAXCRMS_ACCRESS
     */
    (MbsSecureFir, bit(3)) ? TBDDefaultCallout;

    /** MBSSECUREFIR[5]
     *  MBSSIRQ_INVALID_SIR_MASK_OR_ACTION_REGISTER_ACCESS
     */
    (MbsSecureFir, bit(5)) ? TBDDefaultCallout;
};

################################################################################
# Actions specific to NEST chiplet
################################################################################