# IBM_PROLOG_BEGIN_TAG
# This is an automatically generated prolog.
#
# $Source: src/usr/diag/prdf/common/plat/pegasus/Membuf_acts_MEM.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

################################################################################
# MEM Chiplet Registers
################################################################################

rule MemChipletFir
{
  CHECK_STOP:
     (MEM_CHIPLET_CS_FIR       & `17fc000000000000`) & ~MEM_CHIPLET_FIR_MASK;
  UNIT_CS:
     (MEM_CHIPLET_CS_FIR       & `17fc000000000000`) & ~MEM_CHIPLET_FIR_MASK;
  RECOVERABLE:
    ((MEM_CHIPLET_RE_FIR >> 2) & `17f0000000000000`) & ~MEM_CHIPLET_FIR_MASK;
};

group gMemChipletFir filter singlebit
{
    /** MEM_CHIPLET_FIR[3]
     *  Attention from LFIR
     */
    (MemChipletFir, bit(3)) ? analyze(gMemLFir);

    /** MEM_CHIPLET_FIR[5]
     *  Attention from MBACALFIR (MBA 01)
     */
    (MemChipletFir, bit(5)) ? analyzeMba0;

    /** MEM_CHIPLET_FIR[6]
     *  Attention from MBAFIR (MBA 01)
     */
    (MemChipletFir, bit(6)) ? analyzeMba0;

    /** MEM_CHIPLET_FIR[7]
     *  Attention from MBACALFIR (MBA 23)
     */
    (MemChipletFir, bit(7)) ? analyzeMba1;

    /** MEM_CHIPLET_FIR[8]
     *  Attention from MBAFIR (MBA 23)
     */
    (MemChipletFir, bit(8)) ? analyzeMba1;

    /** MEM_CHIPLET_FIR[9]
     *  Attention from DDRPHYFIR (MBA 01)
     */
    (MemChipletFir, bit(9)) ? analyzeMba0;

    /** MEM_CHIPLET_FIR[10]
     *  Attention from DDRPHYFIR (MBA 23)
     */
    (MemChipletFir, bit(10)) ? analyzeMba1;

    /** MEM_CHIPLET_FIR[11]
     *  Attention from MEMFBISTFIR
     */
    (MemChipletFir, bit(11)) ? defaultMaskedError;

    /** MEM_CHIPLET_FIR[12]
     *  Attention from MBASECUREFIR (MBA 01)
     */
    (MemChipletFir, bit(12)) ? analyzeMba0; # Checkstop only

    /** MEM_CHIPLET_FIR[13]
     *  Attention from MBASECUREFIR (MBA 23)
     */
    (MemChipletFir, bit(13)) ? analyzeMba1; # Checkstop only
};

rule MemChipletSpa
{
    SPECIAL: MEM_CHIPLET_SPA & ~MEM_CHIPLET_SPA_MASK;
};

group gMemChipletSpa filter singlebit
{
    /** MEM_CHIPLET_SPA[0]
     *  Attention from Mba 01
     */
    (MemChipletSpa, bit(0)) ? analyzeMba0;

    /** MEM_CHIPLET_SPA[1]
     *  Attention from Mba 1
     */
    (MemChipletSpa, bit(1)) ? analyzeMba1;
};

################################################################################
# MEM Chiplet LFIR
################################################################################
# RAS spreadsheet: p8dd1_mss_FFDC_37_ reviewd.xls

rule MemLFir
{
  CHECK_STOP:  MEM_LFIR & ~MEM_LFIR_MASK & ~MEM_LFIR_ACT0 & ~MEM_LFIR_ACT1;
  UNIT_CS:     MEM_LFIR & ~MEM_LFIR_MASK & ~MEM_LFIR_ACT0 & ~MEM_LFIR_ACT1;
  RECOVERABLE: MEM_LFIR & ~MEM_LFIR_MASK & ~MEM_LFIR_ACT0 &  MEM_LFIR_ACT1;
};

group gMemLFir filter singlebit
{
    /** MEM_LFIR[0]
     *  CFIR internal parity error
     */
    (MemLFir, bit(0)) ? thresholdAndMask_self;

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

    /** MEM_LFIR[2]
     *  Local errors from CC (PCB error)
     */
    (MemLFir, bit(2)) ? defaultMaskedError;

    /** MEM_LFIR[3]
     *  Local errors from CC (OPCG, parity, scan collision, ...)
     */
    (MemLFir, bit(3)) ? defaultMaskedError;

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

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

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

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

    /** MEM_LFIR[8:10]
     *  Local errors from Thermal (Trip error)
     */
    (MemLFir, bit(8|9|10)) ? defaultMaskedError;

    /** MEM_LFIR[11:12]
     *  Local errors from MBA01 Trace Array ( error)
     */
    (MemLFir, bit(11|12)) ? defaultMaskedError;

    /** MEM_LFIR[13:14]
     *  Local errors from MBA23 Trace Array ( error)
     */
    (MemLFir, bit(13|14)) ? defaultMaskedError;

    /** MEM_LFIR[40]
     *  Malfunction alert
     */
    (MemLFir, bit(40)) ? defaultMaskedError;
};

################################################################################
# Actions specific to MEM chiplet
################################################################################

/** Analyze connected MBA0 */
actionclass analyzeMba0
{
    try ( funccall("MBA1_Starvation"),
          analyze(connected(TYPE_MBA, 0)) );
};

/** Analyze connected MBA1 */
# No need to address starvation issue here
# because MBA0 is not at attention
actionclass analyzeMba1
{
    analyze(connected(TYPE_MBA, 1));
};