path: root/src/usr/diag/prdf/common/plat/pegasus/Proc_acts_ABUS.rule

# IBM_PROLOG_BEGIN_TAG
# This is an automatically generated prolog.
#
# $Source: src/usr/diag/prdf/common/plat/pegasus/Proc_acts_ABUS.rule $
#
# OpenPOWER HostBoot Project
#
# COPYRIGHT International Business Machines Corp. 2012,2014
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
# implied. See the License for the specific language governing
# permissions and limitations under the License.
#
# IBM_PROLOG_END_TAG

################################################################################
# ABUS Chiplet Registers
################################################################################

rule AbusChipletFir
{
  CHECK_STOP:
     (ABUS_CHIPLET_CS_FIR       & `1C00000000000000`) & ~ABUS_CHIPLET_FIR_MASK;
  RECOVERABLE:
    ((ABUS_CHIPLET_RE_FIR >> 2) & `1C00000000000000`) & ~ABUS_CHIPLET_FIR_MASK;
};

group gAbusChipletFir filter singlebit
{
    /** ABUS_CHIPLET_FIR[3]
     *  Attention from LFIR
     */
    (AbusChipletFir, bit(3)) ? analyze(gAbusLFir);

    /** ABUS_CHIPLET_FIR[4]
     *  Attention from PBESFIR
     */
    (AbusChipletFir, bit(4)) ? analyze(gPbesFir);

    /** ABUS_CHIPLET_FIR[5]
     *  Attention from IOAFIR
     */
    (AbusChipletFir, bit(5)) ? analyze(gIoaFir);
};

################################################################################
# ABUS Chiplet LFIR
################################################################################

rule AbusLFir
{
  CHECK_STOP:  ABUS_LFIR & ~ABUS_LFIR_MASK & ~ABUS_LFIR_ACT0 & ~ABUS_LFIR_ACT1;
  RECOVERABLE: ABUS_LFIR & ~ABUS_LFIR_MASK & ~ABUS_LFIR_ACT0 &  ABUS_LFIR_ACT1;
};

group gAbusLFir filter singlebit
{
    /** ABUS_LFIR[0]
     *  CFIR internal parity error
     */
    (AbusLFir, bit(0)) ? SelfHighThr32PerDay;

    /** ABUS_LFIR[1]
     *  Local errors from GPIO (PCB error)
     */
    (AbusLFir, bit(1)) ? defaultMaskedError;

    /** ABUS_LFIR[2]
     *  Local errors from CC (PCB error)
     */
    (AbusLFir, bit(2)) ? SelfHighThr32PerDay;

    /** ABUS_LFIR[3]
     *  Local errors from CC (OPCG, parity, scan collision, ...)
     */
    (AbusLFir, bit(3)) ? callout2ndLvlMedThr32NoGard;

    /** ABUS_LFIR[4]
     *  Local errors from PSC (PCB error)
     */
    (AbusLFir, bit(4)) ? defaultMaskedError;

    /** ABUS_LFIR[5]
     *  Local errors from PSC (parity error)
     */
    (AbusLFir, bit(5)) ? defaultMaskedError;

    /** ABUS_LFIR[6]
     *  Local errors from Thermal (parity error)
     */
    (AbusLFir, bit(6)) ? defaultMaskedError;

    /** ABUS_LFIR[7]
     *  Local errors from Thermal (PCB error)
     */
    (AbusLFir, bit(7)) ? defaultMaskedError;

    /** ABUS_LFIR[8|9]
     *  Local errors from Thermal (Trip error)
     */
    (AbusLFir, bit(8|9)) ? defaultMaskedError;

    /** ABUS_LFIR[10|11]
     *  Local errors from Trace Array ( error)
     */
    (AbusLFir, bit(10|11)) ? defaultMaskedError;

    /** ABUS_LFIR[12:20]
     *  FIR_IN12: unused local errors
     */
    (AbusLFir, bit(12|13|14|15|16|17|18|19|20)) ? defaultMaskedError;

    /** ABUS_LFIR[21:30]
     *  FIR_IN12: unused local errors
     */
    (AbusLFir, bit(21|22|23|24|25|26|27|28|29|30)) ? defaultMaskedError;

    /** ABUS_LFIR[31:39]
     *  FIR_IN12: unused local errors
     */
    (AbusLFir, bit(31|32|33|34|35|36|37|38|39)) ? defaultMaskedError;

    /** ABUS_LFIR[40]
     *  Malfunction alert
     */
    (AbusLFir, bit(40)) ? defaultMaskedError;
};

################################################################################
# ABUS Chiplet PBESFIR
################################################################################
# based on p8dd1_mss_FFDC_37_ reviewd.xls
################################################################################

rule PbesFir
{
    CHECK_STOP:
        PBESFIR & ~PBESFIR_MASK & ~PBESFIR_ACT0 & ~PBESFIR_ACT1;
    RECOVERABLE:
        PBESFIR & ~PBESFIR_MASK & ~PBESFIR_ACT0 &  PBESFIR_ACT1;
};


group gPbesFir filter singlebit
{
    /** PBESFIR[0]
     *  A0LINK_FMR_ERROR: a0link_fmr_error
     */
    (PbesFir, bit(0)) ? SelfHighThr1;

    /** PBESFIR[1]
     *  A1LINK_FMR_ERROR: a1link_fmr_error
     */
    (PbesFir, bit(1)) ? SelfHighThr1;

    /** PBESFIR[2]
     *  A2LINK_FMR_ERROR: a2link_fmr_error
     */
    (PbesFir, bit(2)) ? SelfHighThr1;

    /** PBESFIR[3]
     *  A0LINK_PSR_ERR: a0link_psr_err
     */
    (PbesFir, bit(3)) ? SelfHighThr1;

    /** PBESFIR[4]
     *  A1LINK_PSR_ERR: a1link_psr_err
     */
    (PbesFir, bit(4)) ? SelfHighThr1;

    /** PBESFIR[5]
     *  A2LINK_PSR_ERR: a2link_psr_err
     */
    (PbesFir, bit(5)) ? SelfHighThr1;

    /** PBESFIR[6]
     *  A0LINK_PSR_COR_ERR
     */
    (PbesFir, bit(6)) ? calloutAbus0InterfaceTh5;

    /** PBESFIR[7]
     *  A0LINK_PSR_DERR_ERR
     */
    (PbesFir, bit(7)) ? defaultMaskedError;

    /** PBESFIR[8]
     *  A0LINK_PSR_UNC_ERR
     */
    (PbesFir, bit(8)) ? calloutAbus0InterfaceTh1;

    /** PBESFIR[9]
     *  A1LINK_PSR_COR_ERR
     */
    (PbesFir, bit(9)) ? calloutAbus1InterfaceTh5;

    /** PBESFIR[10]
     *  A1LINK_PSR_DERR_ERR
     */
    (PbesFir, bit(10)) ? defaultMaskedError;

    /** PBESFIR[11]
     *  A1LINK_PSR_UNC_ERR
     */
    (PbesFir, bit(11)) ? calloutAbus1InterfaceTh1;

    /** PBESFIR[12]
     *  A2LINK_PSR_COR_ERR
     */
    (PbesFir, bit(12)) ? calloutAbus2InterfaceTh5;

    /** PBESFIR[13]
     *  A2LINK_PSR_DERR_ERR
     */
    (PbesFir, bit(13)) ? defaultMaskedError;

    /** PBESFIR[14]
     *  A2LINK_PSR_UNC_ERR
     */
    (PbesFir, bit(14)) ? calloutAbus2InterfaceTh1;

    /** PBESFIR[15]
     *  A0LINK_FMR_COR_ERR_HI
     */
    (PbesFir, bit(15)) ? SelfHighThr32PerDay;

    /** PBESFIR[16]
     *  A0LINK_FMR_COR_ERR_LO
     */
    (PbesFir, bit(16)) ? SelfHighThr32PerDay;

    /** PBESFIR[17]
     *  A0LINK_FMR_SUE_ERR_HI
     */
    (PbesFir, bit(17)) ? defaultMaskedError;

    /** PBESFIR[18]
     *  A0LINK_FMR_SUE_ERR_LO
     */
    (PbesFir, bit(18)) ? defaultMaskedError;

    /** PBESFIR[19]
     *  A0LINK_FMR_UNC_ERR_HI
     */
    (PbesFir, bit(19)) ? calloutProcHighThr1SUE;

    /** PBESFIR[20]
     *  A0LINK_FMR_UNC_ERR_LO
     */
    (PbesFir, bit(20)) ? calloutProcHighThr1SUE;

    /** PBESFIR[21]
     *  A1LINK_FMR_COR_ERR_HI
     */
    (PbesFir, bit(21)) ? SelfHighThr32PerDay;

    /** PBESFIR[22]
     *  A1LINK_FMR_COR_ERR_LO
     */
    (PbesFir, bit(22)) ? SelfHighThr32PerDay;

    /** PBESFIR[23]
     *  A1LINK_FMR_SUE_ERR_HI
     */
    (PbesFir, bit(23)) ? defaultMaskedError;

    /** PBESFIR[24]
     *  A1LINK_FMR_SUE_ERR_LO
     */
    (PbesFir, bit(24)) ? defaultMaskedError;

    /** PBESFIR[25]
     *  A1LINK_FMR_UNC_ERR_HI
     */
    (PbesFir, bit(25)) ? calloutProcHighThr1SUE;

    /** PBESFIR[26]
     *  A1LINK_FMR_UNC_ERR_LO
     */
    (PbesFir, bit(26)) ? calloutProcHighThr1SUE;

    /** PBESFIR[27]
     *  A2LINK_FMR_COR_ERR_HI
     */
    (PbesFir, bit(27)) ? SelfHighThr32PerDay;

    /** PBESFIR[28]
     *  A2LINK_FMR_COR_ERR_LO
     */
    (PbesFir, bit(28)) ? SelfHighThr32PerDay;

    /** PBESFIR[29]
     *  A2LINK_FMR_SUE_ERR_HI
     */
    (PbesFir, bit(29)) ? defaultMaskedError;

    /** PBESFIR[30]
     *  A2LINK_FMR_SUE_ERR_LO
     */
    (PbesFir, bit(30)) ? defaultMaskedError;

    /** PBESFIR[31]
     *  A2LINK_FMR_UNC_ERR_HI
     */
    (PbesFir, bit(31)) ? calloutProcHighThr1SUE;

    /** PBESFIR[32]
     *  A2LINK_FMR_UNC_ERR_LO
     */
    (PbesFir, bit(32)) ? calloutProcHighThr1SUE;

    /** PBESFIR[33]
     *  A0_OBS_CR_OVERFLOW_FIR_ERR
     */
    (PbesFir, bit(33)) ? SelfHighThr1;

    /** PBESFIR[34]
     *  A1_OBS_CR_OVERFLOW_FIR_ERR
     */
    (PbesFir, bit(34)) ? SelfHighThr1;

    /** PBESFIR[35]
     *  A2_OBS_CR_OVERFLOW_FIR_ERR
     */
    (PbesFir, bit(35)) ? SelfHighThr1;

    /** PBESFIR[36]
     *  FIR_SCOM_ERR_DUP
     */
    (PbesFir, bit(36)) ? defaultMaskedError;

    /** PBESFIR[37]
     *  FIR_SCOM_ERR
     */
    (PbesFir, bit(37)) ? defaultMaskedError;

    # If bit 3 and 8 turn on simultaneously, action should be same as
    # in case of bit 8.

    /** PBESFIR[3,8]
     *  A0LINK_PSR_UNC_ERR
     */
    (PbesFir, bit(3,8)) ? calloutAbus0InterfaceTh1;

    # If bit 4 and 11 turn on simultaneously, action should be same as
    # in case of bit 11.

    /** PBESFIR[4,11]
     *  A1LINK_PSR_UNC_ERR
     */
    (PbesFir, bit(4,11)) ? calloutAbus1InterfaceTh1;

    # If bit 5 and 14 turn on simultaneously, action should be same as
    # in case of bit 14.

    /** PBESFIR[5,14]
     *  A2LINK_PSR_UNC_ERR
     */
    (PbesFir, bit(5,14)) ? calloutAbus2InterfaceTh1;
};

################################################################################
# ABUS Chiplet IOAFIR
################################################################################

rule IoaFir
{
    CHECK_STOP:  IOAFIR & ~IOAFIR_MASK & ~IOAFIR_ACT0 & ~IOAFIR_ACT1;
    RECOVERABLE: IOAFIR & ~IOAFIR_MASK & ~IOAFIR_ACT0 &  IOAFIR_ACT1;
};

group gIoaFir filter singlebit
{
    /** IOAFIR[0]
     *  FIR_RX_INVALID_STATE_OR_PARITY_ERROR
     */
    (IoaFir, bit(0)) ? defaultMaskedError;

    /** IOAFIR[1]
     *  FIR_TX_INVALID_STATE_OR_PARITY_ERROR
     */
    (IoaFir, bit(1)) ? defaultMaskedError;

    /** IOAFIR[2]
     *  FIR_GCR_HANG_ERROR
     */
    (IoaFir, bit(2)) ? SelfHighThr1;

    /** IOAFIR[3:7]
     *  Reserved
     */
    (IoaFir, bit(3|4|5|6|7)) ? defaultMaskedError;

    /** IOAFIR[8:15]
     *  FIR_RX_BUS0 unused
     */
    (IoaFir, bit(8|9|10|11|12|13|14|15)) ? defaultMaskedError;

    /** IOAFIR[16]
     *  ABUS0 Training Error
     */
    (IoaFir, bit(16)) ? defaultMaskedError;

    /** IOAFIR[17]
     *  ABUS0 Spare Deployed
     */
    (IoaFir, bit(17)) ? spareDeployed_abus0;

    /** IOAFIR[18]
     *  ABUS0 Max Spares Exceeded
     */
    (IoaFir, bit(18)) ? maxSparesExceeded_abus0;

    /** IOAFIR[19]
     *  ABUS0 Recalibration or Dynamic Repair Error
     */
    (IoaFir, bit(19)) ? calloutAbus0InterfaceTh1;

    /** IOAFIR[20]
     *  ABUS0 Too Many Bus Errors
     */
    (IoaFir, bit(20)) ? tooManyBusErrors_abus0;

    /** IOAFIR[21:23]
     *  Reserved
     */
    (IoaFir, bit(21|22|23)) ? defaultMaskedError;

    /** IOAFIR[24]
     *  ABUS1 Training Error
     */
    (IoaFir, bit(24)) ? defaultMaskedError;

    /** IOAFIR[25]
     *  ABUS1 Spare Deployed
     */
    (IoaFir, bit(25)) ? spareDeployed_abus1;

    /** IOAFIR[26]
     *  ABUS1 Max Spares Exceeded
     */
    (IoaFir, bit(26)) ? maxSparesExceeded_abus1;

    /** IOAFIR[27]
     *  ABUS1 Recalibration or Dynamic Repair Error
     */
    (IoaFir, bit(27)) ? calloutAbus1InterfaceTh1;

    /** IOAFIR[28]
     *  ABUS1 Too Many Bus Errors
     */
    (IoaFir, bit(28)) ? tooManyBusErrors_abus1;

    /** IOAFIR[29:31]
     *  Reserved
     */
    (IoaFir, bit(29|30|31)) ? defaultMaskedError;

    /** IOAFIR[32]
     *  ABUS2 Training Error
     */
    (IoaFir, bit(32)) ? defaultMaskedError;

    /** IOAFIR[33]
     *  ABUS2 Spare Deployed
     */
    (IoaFir, bit(33)) ? spareDeployed_abus2;

    /** IOAFIR[34]
     *  ABUS2 Max Spares Exceeded
     */
    (IoaFir, bit(34)) ? maxSparesExceeded_abus2;

    /** IOAFIR[35]
     *  ABUS2 Recalibration or Dynamic Repair Error
     */
    (IoaFir, bit(35)) ? calloutAbus2InterfaceTh1;

    /** IOAFIR[36]
     *  ABUS2 Too Many Bus Errors
     */
    (IoaFir, bit(36)) ? tooManyBusErrors_abus2;

    /** IOAFIR[37:39]
     *  Reserved
     */
    (IoaFir, bit(37|38|39)) ? defaultMaskedError;

    /** IOAFIR[40:47]
     *  FIR_RX_BUS4 unused
     */
    (IoaFir, bit(40|41|42|43|44|45|46|47)) ? defaultMaskedError;

    /** IOAFIR[48]
     *  FIR_SCOMFIR_ERROR
     */
    (IoaFir, bit(48)) ? defaultMaskedError;

    /** IOAFIR[49]
     *  FIR_SCOMFIR_ERROR_CLONE
     */
    (IoaFir, bit(49)) ? defaultMaskedError;
};

################################################################################
# Actions specific to ABUS chiplet
################################################################################


/** Callout the ABUS 0 interface */
actionclass calloutAbus0Interface
{
    callout(procedure(PassiveFabric_OffNode_ENUM), MRU_MED);
    callout(connected(TYPE_ABUS, 0), MRU_MEDA);
    callout(connected_peer(TYPE_ABUS, 0), MRU_MEDA);
};

/** Callout the ABUS 1 interface */
actionclass calloutAbus1Interface
{
    callout(procedure(PassiveFabric_OffNode_ENUM), MRU_MED);
    callout(connected(TYPE_ABUS, 1), MRU_MEDA);
    callout(connected_peer(TYPE_ABUS, 1), MRU_MEDA);
};

/** Callout the ABUS 2 interface */
actionclass calloutAbus2Interface
{
    callout(procedure(PassiveFabric_OffNode_ENUM), MRU_MED);
    callout(connected(TYPE_ABUS, 2), MRU_MEDA);
    callout(connected_peer(TYPE_ABUS, 2), MRU_MEDA);
};

/** Callout the ABUS 0 interface, threshold 1 */
actionclass calloutAbus0InterfaceTh1 { calloutAbus0Interface; threshold1; };

/** Callout the ABUS 1 interface, threshold 1 */
actionclass calloutAbus1InterfaceTh1 { calloutAbus1Interface; threshold1; };

/** Callout the ABUS 2 interface, threshold 1 */
actionclass calloutAbus2InterfaceTh1 { calloutAbus2Interface; threshold1; };

/** Threshold 5 per day, mask but do not predictively callout ABUS 0 */
actionclass calloutAbus0InterfaceTh5
{
    calloutAbus0Interface;
    threshold5pday;
    funccall("ClearServiceCallFlag");
};

/** Threshold 5 per day, mask but do not predictively callout ABUS 1 */
actionclass calloutAbus1InterfaceTh5
{
    calloutAbus1Interface;
    threshold5pday;
    funccall("ClearServiceCallFlag");
};

/** Threshold 5 per day, mask but do not predictively callout ABUS 2 */
actionclass calloutAbus2InterfaceTh5
{
    calloutAbus2Interface;
    threshold5pday;
    funccall("ClearServiceCallFlag");
};

/** Lane Repair: spare deployed - ABUS 0 */
actionclass spareDeployed_abus0
{ calloutAbus0Interface; funccall("spareDeployed_abus0"); };

/** Lane Repair: spare deployed - ABUS 1 */
actionclass spareDeployed_abus1
{ calloutAbus1Interface; funccall("spareDeployed_abus1"); };

/** Lane Repair: spare deployed - ABUS 2 */
actionclass spareDeployed_abus2
{ calloutAbus2Interface; funccall("spareDeployed_abus2"); };

/** Lane Repair: max spares exceeded - ABUS 0 */
actionclass maxSparesExceeded_abus0
{ calloutAbus0InterfaceTh1; funccall("maxSparesExceeded_abus0"); };

/** Lane Repair: max spares exceeded - ABUS 1 */
actionclass maxSparesExceeded_abus1
{ calloutAbus1InterfaceTh1; funccall("maxSparesExceeded_abus1"); };

/** Lane Repair: max spares exceeded - ABUS 1 */
actionclass maxSparesExceeded_abus2
{ calloutAbus2InterfaceTh1; funccall("maxSparesExceeded_abus2"); };

/** Lane Repair: too many bus errors - ABUS 0 */
actionclass tooManyBusErrors_abus0
{ calloutAbus0InterfaceTh1; funccall("tooManyBusErrors_abus0"); };

/** Lane Repair: too many bus errors - ABUS 1 */
actionclass tooManyBusErrors_abus1
{ calloutAbus1InterfaceTh1; funccall("tooManyBusErrors_abus1"); };

/** Lane Repair: too many bus errors - ABUS 2 */
actionclass tooManyBusErrors_abus2
{ calloutAbus2InterfaceTh1; funccall("tooManyBusErrors_abus2"); };