/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#ifndef _SYS_ERRCLASSIFY_H
#define _SYS_ERRCLASSIFY_H

#pragma ident   "%Z%%M% %I%     %E% SMI"

#ifdef  __cplusplus
extern "C" {
#endif

#ifndef _ASM

#include <sys/errorq.h>

/*
 * Note that the order in the following must be kept in sync with that
 * in the sun4u DE cmd_memerr.c and with the cetypes array of us3_common.c
 */
typedef enum {
        /*
         * The first byte (256 values) is for type and can be sequential.
         */
        CE_DISP_UNKNOWN,
        CE_DISP_INTERMITTENT,
        CE_DISP_POSS_PERS,
        CE_DISP_PERS,
        CE_DISP_LEAKY,
        CE_DISP_POSS_STICKY,
        CE_DISP_STICKY,
        /*
         * The next byte encodes the next action as a bitmask
         */
        CE_ACT_DONE = 0x100,
        CE_ACT_LKYCHK = 0x200,
        CE_ACT_PTNRCHK = 0x400,
        /*
         * Keep this as the last entry.  Not all entries of the type lookup
         * table are used and this value is the "uninitialized" pattern.
         */
        CE_DISP_BAD = 0xbadbad1
} ce_dispact_t;

/*
 * Extract disposition or action from a ce_dispact_t
 */
#define CE_DISP(dispact) \
        (dispact & 0xff)
#define CE_ACT(dispact) \
        (dispact & 0xff00)

/*
 * Short string names for classification types.
 */
#define CE_DISP_DESC_U          "U"
#define CE_DISP_DESC_I          "I"
#define CE_DISP_DESC_PP         "PP"
#define CE_DISP_DESC_P          "P"
#define CE_DISP_DESC_L          "L"
#define CE_DISP_DESC_PS         "PS"
#define CE_DISP_DESC_S          "S"

/*
 * Various sun4u CPU types use different Ecache state encodings.
 * For CE classification the following unified scheme is used.
 */
#define EC_STATE_M              0x4
#define EC_STATE_O              0x3
#define EC_STATE_E              0x2
#define EC_STATE_S              0x1
#define EC_STATE_I              0x0

/*
 * Macros to generate the initial CE classification table (in both kernel and
 * userland).  An array size CE_INITDISPTBL_SIZE of ce_dispact_t should be
 * defined and passed by name to ECC_INITDISPTBL_POPULATE which will populate
 * the array slots that are use and set the unused ones to CE_DISP_BAD.
 *
 * To perform a lookup use CE_DISPACT passing the name of the same
 * array and the afarmatch, ecstate, ce1 and ce2 information.
 *
 * Other macros defined here should not be used directly.
 *
 * CE_INITDISPTBL_INDEX will generate an index as follows:
 *
 *      <5>     afar match
 *      <4:2>   line state
 *      <1>     ce2 - CE seen on lddphys of scrub algorithm (after writeback)
 *      <0>     ce1 - CE seen on CASXA of scrub algorithm (before writeback)
 *
 * When the afar does not match line state must be zero.
 */
#define CE_INITDISPTBL_SIZE     (1 << 6)
#define CE_INITDISPTBL_INDEX(afarmatch, ecstate, ce1, ce2) \
        ((afarmatch) << 5 | (ecstate) << 2 | (ce2) << 1 | (ce1))

#define CE_DISPACT(array, afarmatch, ecstate, ce1, ce2) \
        (array[CE_INITDISPTBL_INDEX(afarmatch, ecstate, ce1, ce2)])

#define CE_INITDISPTBL_POPULATE(a)                                      \
{                                                                       \
        int i;                                                          \
        for (i = 0; i < CE_INITDISPTBL_SIZE; ++i)                       \
                a[i] = CE_DISP_BAD;                                     \
/*                                                                      \
 *         afar  ec           ce1  ce2  initial disp and next action    \
 *        match  state                                                  \
 */                                                                     \
CE_DISPACT(a, 0, 0,             0, 0) = CE_DISP_UNKNOWN | CE_ACT_DONE; \
CE_DISPACT(a, 0, 0,             0, 1) = CE_DISP_POSS_STICKY | CE_ACT_PTNRCHK; \
CE_DISPACT(a, 0, 0,             1, 0) = CE_DISP_POSS_PERS | CE_ACT_LKYCHK; \
CE_DISPACT(a, 0, 0,             1, 1) = CE_DISP_POSS_STICKY | CE_ACT_PTNRCHK; \
CE_DISPACT(a, 1, EC_STATE_M,    0, 0) = CE_DISP_UNKNOWN | CE_ACT_DONE; \
CE_DISPACT(a, 1, EC_STATE_M,    0, 1) = CE_DISP_UNKNOWN | CE_ACT_DONE; \
CE_DISPACT(a, 1, EC_STATE_M,    1, 0) = CE_DISP_UNKNOWN | CE_ACT_DONE; \
CE_DISPACT(a, 1, EC_STATE_M,    1, 1) = CE_DISP_POSS_STICKY | CE_ACT_PTNRCHK; \
CE_DISPACT(a, 1, EC_STATE_O,    0, 0) = CE_DISP_UNKNOWN | CE_ACT_DONE; \
CE_DISPACT(a, 1, EC_STATE_O,    0, 1) = CE_DISP_UNKNOWN | CE_ACT_DONE; \
CE_DISPACT(a, 1, EC_STATE_O,    1, 0) = CE_DISP_UNKNOWN | CE_ACT_DONE; \
CE_DISPACT(a, 1, EC_STATE_O,    1, 1) = CE_DISP_POSS_STICKY | CE_ACT_PTNRCHK; \
CE_DISPACT(a, 1, EC_STATE_E,    0, 0) = CE_DISP_INTERMITTENT | CE_ACT_DONE; \
CE_DISPACT(a, 1, EC_STATE_E,    0, 1) = CE_DISP_UNKNOWN | CE_ACT_DONE; \
CE_DISPACT(a, 1, EC_STATE_E,    1, 0) = CE_DISP_POSS_PERS | CE_ACT_LKYCHK; \
CE_DISPACT(a, 1, EC_STATE_E,    1, 1) = CE_DISP_POSS_STICKY | CE_ACT_PTNRCHK; \
CE_DISPACT(a, 1, EC_STATE_S,    0, 0) = CE_DISP_INTERMITTENT | CE_ACT_DONE; \
CE_DISPACT(a, 1, EC_STATE_S,    0, 1) = CE_DISP_POSS_STICKY | CE_ACT_PTNRCHK; \
CE_DISPACT(a, 1, EC_STATE_S,    1, 0) = CE_DISP_POSS_PERS | CE_ACT_LKYCHK; \
CE_DISPACT(a, 1, EC_STATE_S,    1, 1) = CE_DISP_POSS_STICKY | CE_ACT_PTNRCHK; \
CE_DISPACT(a, 1, EC_STATE_I,    0, 0) = CE_DISP_UNKNOWN | CE_ACT_DONE; \
CE_DISPACT(a, 1, EC_STATE_I,    0, 1) = CE_DISP_POSS_STICKY | CE_ACT_PTNRCHK; \
CE_DISPACT(a, 1, EC_STATE_I,    1, 0) = CE_DISP_POSS_PERS | CE_ACT_LKYCHK; \
CE_DISPACT(a, 1, EC_STATE_I,    1, 1) = CE_DISP_POSS_STICKY | CE_ACT_PTNRCHK; \
}

#endif  /* !_ASM */

/*
 * Legacy error type names corresponding to the flt_status bits
 */
#define ERR_TYPE_DESC_INTERMITTENT      "Intermittent"
#define ERR_TYPE_DESC_PERSISTENT        "Persistent"
#define ERR_TYPE_DESC_STICKY            "Sticky"
#define ERR_TYPE_DESC_UNKNOWN           "Unknown"

/*
 * flt_disp for a CE will record all scrub test data for the extended
 * classification attempt.
 *
 * --------------------------------------------------------------------------
 * |            | partner |   |          | leaky   | partner | detector     |
 * | partner id | type    | - | skipcode | results | results | results      |
 * |63        32|31     30|   |27      24|23     16|15      8|7            0|
 * --------------------------------------------------------------------------
 */
#define CE_XDIAG_DTCRMASK               0xffULL
#define CE_XDIAG_PTNRSHIFT              8
#define CE_XDIAG_PTNRMASK               (0xffULL << CE_XDIAG_PTNRSHIFT)
#define CE_XDIAG_LKYSHIFT               16
#define CE_XDIAG_LKYMASK                (0xffULL << CE_XDIAG_LKYSHIFT)
#define CE_XDIAG_SKIPCODESHIFT          24
#define CE_XDIAG_SKIPCODEMASK           (0xfULL << CE_XDIAG_SKIPCODESHIFT)
#define CE_XDIAG_PTNRTYPESHIFT          30
#define CE_XDIAG_PTNRTYPEMASK           (0x3ULL << CE_XDIAG_PTNRTYPESHIFT)
#define CE_XDIAG_PTNRIDSHIFT            32

/*
 * Given a CE flt_disp set the given field
 */
#define CE_XDIAG_SETPTNRID(disp, id) \
        ((disp) |= (uint64_t)(id) << CE_XDIAG_PTNRIDSHIFT)
#define CE_XDIAG_SETPTNRTYPE(disp, type) \
        ((disp) |= (uint64_t)type << CE_XDIAG_PTNRTYPESHIFT)
#define CE_XDIAG_SETSKIPCODE(disp, code) \
        ((disp) |= (uint64_t)code << CE_XDIAG_SKIPCODESHIFT)
#define CE_XDIAG_SETLKYINFO(disp, result) \
        ((disp) |= (uint64_t)result << CE_XDIAG_LKYSHIFT)
#define CE_XDIAG_SETPTNRINFO(disp, result) \
        ((disp) |= (uint64_t)result << CE_XDIAG_PTNRSHIFT)
#define CE_XDIAG_SETDTCRINFO(disp, result) \
        ((disp) |= (uint64_t)result)

/*
 * Given a CE flt_disp extract the requested component
 */
#define CE_XDIAG_DTCRINFO(disp) ((disp) & CE_XDIAG_DTCRMASK)
#define CE_XDIAG_PTNRINFO(disp) (((disp) & CE_XDIAG_PTNRMASK) >> \
    CE_XDIAG_PTNRSHIFT)
#define CE_XDIAG_LKYINFO(disp)  (((disp) & CE_XDIAG_LKYMASK) >> \
    CE_XDIAG_LKYSHIFT)
#define CE_XDIAG_SKIPCODE(disp) (((disp) & CE_XDIAG_SKIPCODEMASK) >> \
    CE_XDIAG_SKIPCODESHIFT)
#define CE_XDIAG_PTNRTYPE(disp) (((disp) & CE_XDIAG_PTNRTYPEMASK) >> \
    CE_XDIAG_PTNRTYPESHIFT)
#define CE_XDIAG_PTNRID(disp)   ((disp) >> CE_XDIAG_PTNRIDSHIFT)

/*
 * Format of individual detector/partner/leaky test results.  CE_XDIAG_EXTALG
 * in the detector case indicates that the extended classification algorithm
 * has been applied;  common code uses this to distinguish between old and new.
 * In the partner check and leaky check cases CE_XDIAG_EXTALG is used to
 * indicate that the given test has run and recorded its results in its
 * result field.
 */
#define CE_XDIAG_STATE_MASK     0x7     /* Low 3 bits are for MOESI state */
#define CE_XDIAG_AFARMATCH      0x08    /* Line at e$ index matched AFAR */
#define CE_XDIAG_NOLOGOUT       0x10    /* Logout data unavailable */
#define CE_XDIAG_CE1            0x20    /* CE logged on casx during scrub */
#define CE_XDIAG_CE2            0x40    /* CE logged on post-scrub reread */
#define CE_XDIAG_EXTALG         0x80    /* Extended algorithm applied */

/*
 * Extract classification information for detector/partner.  Expects
 * a value from one of CE_XDIAG_{DTCR,PTNR,LKY}_INFO.
 */
#define CE_XDIAG_AFARMATCHED(c)         (((c) & CE_XDIAG_AFARMATCH) != 0)
#define CE_XDIAG_LOGOUTVALID(c)         (((c) & CE_XDIAG_NOLOGOUT) == 0)
#define CE_XDIAG_CE1SEEN(c)             (((c) & CE_XDIAG_CE1) != 0)
#define CE_XDIAG_CE2SEEN(c)             (((c) & CE_XDIAG_CE2) != 0)
#define CE_XDIAG_STATE(c)               (CE_XDIAG_AFARMATCHED(c) ? \
        ((c) & CE_XDIAG_STATE_MASK) : 0)
#define CE_XDIAG_EXT_ALG_APPLIED(c)     (((c) & CE_XDIAG_EXTALG) != 0)

/*
 * A leaky or partner test is considered valid if the line was not present
 * in cache, or was present but Invalid, at the time of the additional scrub.
 */
#define CE_XDIAG_TESTVALID(c) (CE_XDIAG_EXT_ALG_APPLIED(c) && \
        (!CE_XDIAG_AFARMATCHED(c) || CE_XDIAG_STATE(c) == EC_STATE_I))

/*
 * Skipcodes - reasons for not applying extended diags; 4 bits
 */
#define CE_XDIAG_SKIP_NOPP              0x1     /* Can't lookup page pointer */
#define CE_XDIAG_SKIP_PAGEDET           0x2     /* Page deteriorating/retired */
#define CE_XDIAG_SKIP_NOTMEM            0x3     /* AFAR is not memory */
#define CE_XDIAG_SKIP_DUPFAIL           0x4     /* errorq recirculate failed */
#define CE_XDIAG_SKIP_NOPTNR            0x5     /* no suitable partner avail */
#define CE_XDIAG_SKIP_UNIPROC           0x6     /* test needs 2 or more cpus */
#define CE_XDIAG_SKIP_ACTBAD            0x7     /* bad action lookup - bug */
#define CE_XDIAG_SKIP_NOSCRUB           0x8     /* detector did not scrub */

/*
 * Partner type information.
 */
#define CE_XDIAG_PTNR_REMOTE    0x0     /* partner in different lgroup */
#define CE_XDIAG_PTNR_LOCAL     0x1     /* partner in same lgroup */
#define CE_XDIAG_PTNR_SIBLING   0x2     /* partner is a sibling core */
#define CE_XDIAG_PTNR_SELF      0x3     /* partnered self */

#ifdef  __cplusplus
}
#endif

#endif  /* _SYS_ERRCLASSIFY_H */