The MPC7448 has ECC on its L2 data array and parity on its tag array,
but L2ERRINTEN resets to 0, so uncorrectable L2 errors are never
reported and the bad data is used.

Enable machine checks for multi-bit ECC and tag parity errors at boot,
and save and restore L2ERRINTEN across sleep.  These errors now oops
instead of silently corrupting data.  Single-bit errors stay disabled:
there is no threshold to set, since L2ERRCTL[L2CTHRESH] is read-only and
0, and they are counted in L2ERRCTL[L2CCOUNT] anyway.

Add machine_check_7448(), which adds the L2 error registers to what
machine_check_745x() prints, and counts these machine checks per CPU for
the EDAC driver added in the next patch.  The CPU clears SRR1[RI] for
them, so they are never recoverable.

A multi-bit error injected with reporting enabled is decoded as

  Machine check in kernel mode.
  Caused by (from SRR1=101030, MSSSR0=20000): [L2 data parity/ECC]
  MPC7448 L2 error: L2ERRDET=80000008 [multi-bit ECC] [multiple errors]
    address 0x0054e1100 (dw 0): data read, 32 bytes burst
    data 00000000_00000003 syndrome 81 ECC 00
  Oops: Machine check, sig: 7 [#1]

Signed-off-by: Matt Turner <[email protected]>
---
 MAINTAINERS                               |   8 ++
 arch/powerpc/include/asm/cpu_setup.h      |   1 +
 arch/powerpc/include/asm/cputable.h       |   1 +
 arch/powerpc/include/asm/mpc7448_l2.h     |  31 ++++++++
 arch/powerpc/include/asm/reg.h            |  32 ++++++++
 arch/powerpc/kernel/Makefile              |   3 +-
 arch/powerpc/kernel/cpu_setup_6xx.S       |  38 ++++++++-
 arch/powerpc/kernel/cpu_specs_book3s_32.h |   4 +-
 arch/powerpc/kernel/mpc7448_l2.c          | 124 ++++++++++++++++++++++++++++++
 9 files changed, 238 insertions(+), 4 deletions(-)

diff --git a/MAINTAINERS b/MAINTAINERS
index fde7147bfa1e..4ea66ea2be2d 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -9747,6 +9747,14 @@ L:       [email protected]
 S:     Maintained
 F:     drivers/edac/intel-bff.c
 
+EDAC-MPC7448-L2
+M:     Matt Turner <[email protected]>
+L:     [email protected]
+L:     [email protected]
+S:     Maintained
+F:     arch/powerpc/include/asm/mpc7448_l2.h
+F:     arch/powerpc/kernel/mpc7448_l2.c
+
 EDAC-MPC85XX
 L:     [email protected]
 S:     Orphan
diff --git a/arch/powerpc/include/asm/cpu_setup.h 
b/arch/powerpc/include/asm/cpu_setup.h
index 26d2c0e2c99c..c4d7f49027df 100644
--- a/arch/powerpc/include/asm/cpu_setup.h
+++ b/arch/powerpc/include/asm/cpu_setup.h
@@ -37,6 +37,7 @@ void __setup_cpu_750fx(unsigned long offset, struct cpu_spec 
*spec);
 void __setup_cpu_7400(unsigned long offset, struct cpu_spec *spec);
 void __setup_cpu_7410(unsigned long offset, struct cpu_spec *spec);
 void __setup_cpu_745x(unsigned long offset, struct cpu_spec *spec);
+void __setup_cpu_7448(unsigned long offset, struct cpu_spec *spec);
 
 void __setup_cpu_ppc970(unsigned long offset, struct cpu_spec *spec);
 void __setup_cpu_ppc970MP(unsigned long offset, struct cpu_spec *spec);
diff --git a/arch/powerpc/include/asm/cputable.h 
b/arch/powerpc/include/asm/cputable.h
index 8445533c946b..648e72fe7e6c 100644
--- a/arch/powerpc/include/asm/cputable.h
+++ b/arch/powerpc/include/asm/cputable.h
@@ -35,6 +35,7 @@ extern int machine_check_47x(struct pt_regs *regs);
 int machine_check_8xx(struct pt_regs *regs);
 int machine_check_83xx(struct pt_regs *regs);
 int machine_check_745x(struct pt_regs *regs);
+int machine_check_7448(struct pt_regs *regs);
 
 extern void cpu_down_flush_e500v2(void);
 extern void cpu_down_flush_e500mc(void);
diff --git a/arch/powerpc/include/asm/mpc7448_l2.h 
b/arch/powerpc/include/asm/mpc7448_l2.h
new file mode 100644
index 000000000000..a10c694b8583
--- /dev/null
+++ b/arch/powerpc/include/asm/mpc7448_l2.h
@@ -0,0 +1,31 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * MPC7448 L2 cache error capture and reporting.
+ */
+#ifndef _ASM_POWERPC_MPC7448_L2_H
+#define _ASM_POWERPC_MPC7448_L2_H
+
+#include <linux/types.h>
+
+/* Snapshot of the L2 error detect and capture registers */
+struct mpc7448_l2_err {
+       u32 det;        /* L2ERRDET */
+       u32 attr;       /* L2ERRATTR */
+       u32 eaddr;      /* L2ERREADDR */
+       u32 addr;       /* L2ERRADDR */
+       u32 capt_hi;    /* L2CAPTDATAHI */
+       u32 capt_lo;    /* L2CAPTDATALO */
+       u32 capt_ecc;   /* L2CAPTECC */
+};
+
+/* 36-bit physical address of the double word that took the error */
+static inline u64 mpc7448_l2_err_paddr(const struct mpc7448_l2_err *e)
+{
+       return ((u64)(e->eaddr & 0xf) << 32) | e->addr;
+}
+
+void mpc7448_l2_err_capture(struct mpc7448_l2_err *e);
+void mpc7448_l2_err_print(const struct mpc7448_l2_err *e);
+unsigned int mpc7448_l2_mce_take(void);
+
+#endif /* _ASM_POWERPC_MPC7448_L2_H */
diff --git a/arch/powerpc/include/asm/reg.h b/arch/powerpc/include/asm/reg.h
index 82a85d44776e..2f4adf5a606e 100644
--- a/arch/powerpc/include/asm/reg.h
+++ b/arch/powerpc/include/asm/reg.h
@@ -706,6 +706,38 @@
 #define L2CR_L2DO_745x         0x00010000      /* L2 data only (745x) */
 #define L2CR_L2REP_745x                0x00001000      /* L2 repl. algorithm 
(745x) */
 #define L2CR_L2HWF_745x                0x00000800      /* L2 hardware flush 
(745x) */
+
+/* MPC7448 L2 error injection, capture and reporting registers */
+#define SPRN_L2ERRINJHI                0x3D9   /* L2 error injection mask, 
data high */
+#define SPRN_L2ERRINJLO                0x3DA   /* L2 error injection mask, 
data low */
+#define SPRN_L2ERRINJCTL       0x3DB   /* L2 error injection control */
+#define   L2ERRINJCTL_ECCMB    0x00000200      /* Mirror data MSB onto ECC */
+#define   L2ERRINJCTL_DERRIEN  0x00000100      /* Data/ECC error injection */
+#define   L2ERRINJCTL_ECCERRIM 0x000000ff      /* ECC bit injection mask */
+#define SPRN_L2CAPTDATAHI      0x3DC   /* L2 error capture data, high word */
+#define SPRN_L2CAPTDATALO      0x3DD   /* L2 error capture data, low word */
+#define SPRN_L2CAPTECC         0x3DE   /* L2 error syndrome */
+#define   L2CAPTECC_ECCSYND    0xff000000      /* Calculated syndrome */
+#define   L2CAPTECC_ECCCHKSUM  0x000000ff      /* Datapath ECC */
+#define SPRN_L2ERRDET          0x3DF   /* L2 error detect (write 1 to clear) */
+#define SPRN_L2ERRINTEN                0x3E1   /* L2 error interrupt enable */
+/* Error bits shared by L2ERRDET and L2ERRINTEN */
+#define   L2ERR_MULL2ERR       0x80000000      /* Multiple errors (DET only) */
+#define   L2ERR_TPARERR                0x00000010      /* Tag parity error */
+#define   L2ERR_MBECCERR       0x00000008      /* Multiple-bit ECC error */
+#define   L2ERR_SBECCERR       0x00000004      /* Single-bit ECC error */
+#define SPRN_L2ERRATTR         0x3E2   /* L2 error attributes capture */
+#define   L2ERRATTR_DWNUM      0x30000000      /* Double word number */
+#define   L2ERRATTR_TRANSSIZ   0x07000000      /* Transaction size */
+#define   L2ERRATTR_BURST      0x00800000      /* Burst transaction */
+#define   L2ERRATTR_TRANSSRC   0x001f0000      /* Transaction source */
+#define   L2ERRATTR_TRANSTYPE  0x00003000      /* Transaction type */
+#define   L2ERRATTR_VALINFO    0x00000001      /* Capture registers valid */
+#define SPRN_L2ERRADDR         0x3E3   /* L2 error address, bits 4-35 */
+#define SPRN_L2ERREADDR                0x3E4   /* L2 error address, bits 0-3 */
+#define SPRN_L2ERRCTL          0x3E5   /* L2 error control */
+#define   L2ERRCTL_L2CCOUNT    0x000000ff      /* SBE count */
+
 #define SPRN_L3CR              0x3FA   /* Level 3 Cache Control Register */
 #define L3CR_L3E               0x80000000      /* L3 enable */
 #define L3CR_L3PE              0x40000000      /* L3 data parity enable */
diff --git a/arch/powerpc/kernel/Makefile b/arch/powerpc/kernel/Makefile
index 7bf6b16b2d93..3681dd45a056 100644
--- a/arch/powerpc/kernel/Makefile
+++ b/arch/powerpc/kernel/Makefile
@@ -106,7 +106,8 @@ obj-$(CONFIG_CRASH_DUMP)    += crash_dump.o
 obj-$(CONFIG_FA_DUMP)          += fadump.o
 obj-$(CONFIG_PRESERVE_FA_DUMP) += fadump.o
 obj-$(CONFIG_PPC_85xx)         += idle_85xx.o
-obj-$(CONFIG_PPC_BOOK3S_32)    += idle_6xx.o l2cr_6xx.o cpu_setup_6xx.o
+obj-$(CONFIG_PPC_BOOK3S_32)    += idle_6xx.o l2cr_6xx.o cpu_setup_6xx.o \
+                                  mpc7448_l2.o
 obj-$(CONFIG_TAU)              += tau_6xx.o
 obj-$(CONFIG_HIBERNATION)      += swsusp.o suspend.o
 ifdef CONFIG_PPC_85xx
diff --git a/arch/powerpc/kernel/cpu_setup_6xx.S 
b/arch/powerpc/kernel/cpu_setup_6xx.S
index ab3ca74e6730..dc17d5a8bd79 100644
--- a/arch/powerpc/kernel/cpu_setup_6xx.S
+++ b/arch/powerpc/kernel/cpu_setup_6xx.S
@@ -90,6 +90,13 @@ _GLOBAL(__setup_cpu_745x)
        bl      setup_745x_specifics
        mtlr    r5
        blr
+_GLOBAL(__setup_cpu_7448)
+       mflr    r5
+       bl      setup_common_caches
+       bl      setup_745x_specifics
+       bl      setup_7448_l2_errors
+       mtlr    r5
+       blr
 
 /* Enable caches for 603's, 604, 750 & 7400 */
 SYM_FUNC_START_LOCAL(setup_common_caches)
@@ -300,6 +307,23 @@ END_FTR_SECTION_IFSET(CPU_FTR_NO_DPM)
        blr
 SYM_FUNC_END(setup_745x_specifics)
 
+/*
+ * Clear L2 errors left by firmware and raise a machine check for
+ * uncorrectable ones.
+ */
+SYM_FUNC_START_LOCAL(setup_7448_l2_errors)
+       li      r3,-1
+       mtspr   SPRN_L2ERRDET,r3        /* write 1 to clear */
+       li      r3,0
+       mtspr   SPRN_L2ERRATTR,r3       /* clear VALINFO: re-arm capture */
+       li      r3,L2ERR_TPARERR | L2ERR_MBECCERR
+       sync
+       mtspr   SPRN_L2ERRINTEN,r3
+       sync
+       isync
+       blr
+SYM_FUNC_END(setup_7448_l2_errors)
+
 /*
  * Initialize the FPU registers. This is needed to work around an errata
  * in some 750 cpus where using a not yet initialized FPU register after
@@ -329,7 +353,8 @@ _ASM_NOKPROBE_SYMBOL(__init_fpu_registers)
 #define CS_ICTRL       20
 #define CS_LDSTCR      24
 #define CS_LDSTDB      28
-#define CS_SIZE                32
+#define CS_L2ERRINTEN  32
+#define CS_SIZE                36
 
        .data
        .balign L1_CACHE_BYTES
@@ -391,6 +416,10 @@ _GLOBAL(__save_cpu_setup)
        stw     r4,CS_LDSTCR(r5)
        mfspr   r4,SPRN_LDSTDB
        stw     r4,CS_LDSTDB(r5)
+       bne     cr7,1f
+       /* Backup 7448 specific registers */
+       mfspr   r4,SPRN_L2ERRINTEN
+       stw     r4,CS_L2ERRINTEN(r5)
 1:
        bne     cr6,1f
        /* Backup 750FX specific registers */
@@ -484,6 +513,13 @@ _GLOBAL(__restore_cpu_setup)
        mtspr   SPRN_LDSTDB,r4
        isync
        sync
+       bne     cr7,2f
+       /* Restore 7448 specific registers */
+       lwz     r4,CS_L2ERRINTEN(r5)
+       sync
+       mtspr   SPRN_L2ERRINTEN,r4
+       isync
+       sync
 2:     bne     cr6,1f
        /* Restore 750FX specific registers
         * that is restore HID2 on rev 2.x and PLL config & switch
diff --git a/arch/powerpc/kernel/cpu_specs_book3s_32.h 
b/arch/powerpc/kernel/cpu_specs_book3s_32.h
index 90ca26405c1d..039094c1c245 100644
--- a/arch/powerpc/kernel/cpu_specs_book3s_32.h
+++ b/arch/powerpc/kernel/cpu_specs_book3s_32.h
@@ -585,8 +585,8 @@ static struct cpu_spec cpu_specs[] __initdata = {
                .dcache_bsize           = 32,
                .num_pmcs               = 6,
                .pmc_type               = PPC_PMC_G4,
-               .cpu_setup              = __setup_cpu_745x,
-               .machine_check          = machine_check_745x,
+               .cpu_setup              = __setup_cpu_7448,
+               .machine_check          = machine_check_7448,
                .platform               = "ppc7450",
        },
        {       /* default match, we assume split I/D cache & TB (non-601)... */
diff --git a/arch/powerpc/kernel/mpc7448_l2.c b/arch/powerpc/kernel/mpc7448_l2.c
new file mode 100644
index 000000000000..4ec3c6a0558e
--- /dev/null
+++ b/arch/powerpc/kernel/mpc7448_l2.c
@@ -0,0 +1,124 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * MPC7448 L2 cache error capture and machine check decode.
+ *
+ * The MPC7448 protects its L2 data array with SEC-DED ECC and its tag
+ * array with parity.  Detected errors are latched in L2ERRDET and, for
+ * the error types enabled in L2ERRINTEN, raise a machine check with
+ * SRR1[MSS] and MSSSR0[L2DAT] or MSSSR0[L2TAG] set.  See the MPC7450 RISC
+ * Microprocessor Family Reference Manual, rev. 5, sections 2.2.5.5 and
+ * 3.6.3.4.
+ */
+
+#include <linux/bitfield.h>
+#include <linux/export.h>
+#include <linux/kernel.h>
+#include <linux/percpu.h>
+#include <linux/printk.h>
+
+#include <asm/cputable.h>
+#include <asm/local.h>
+#include <asm/mpc7448_l2.h>
+#include <asm/ptrace.h>
+#include <asm/reg.h>
+
+/* L2 machine checks not yet collected by mpc7448_l2_mce_take() */
+static DEFINE_PER_CPU(local_t, mpc7448_l2_mce_count);
+
+/*
+ * Read the error detect and capture registers, then clear the detected
+ * errors and re-arm capture.  Must run on the CPU whose L2 is of interest.
+ */
+void mpc7448_l2_err_capture(struct mpc7448_l2_err *e)
+{
+       e->det = mfspr(SPRN_L2ERRDET);
+       e->attr = mfspr(SPRN_L2ERRATTR);
+       e->eaddr = mfspr(SPRN_L2ERREADDR);
+       e->addr = mfspr(SPRN_L2ERRADDR);
+       e->capt_hi = mfspr(SPRN_L2CAPTDATAHI);
+       e->capt_lo = mfspr(SPRN_L2CAPTDATALO);
+       e->capt_ecc = mfspr(SPRN_L2CAPTECC);
+
+       if (e->det)
+               mtspr(SPRN_L2ERRDET, e->det);   /* write 1 to clear */
+       if (e->attr & L2ERRATTR_VALINFO)
+               mtspr(SPRN_L2ERRATTR, 0);       /* unfreeze capture */
+}
+EXPORT_SYMBOL_GPL(mpc7448_l2_err_capture);
+
+static const char *transsrc_str(u32 attr)
+{
+       switch (FIELD_GET(L2ERRATTR_TRANSSRC, attr)) {
+       case 0x00:
+               return "external";
+       case 0x10:
+               return "instruction";
+       case 0x11:
+               return "data";
+       default:
+               return "unknown source";
+       }
+}
+
+static const char *transtype_str(u32 attr)
+{
+       static const char * const types[] = {
+               "snoop", "write", "read", "reserved"
+       };
+
+       return types[FIELD_GET(L2ERRATTR_TRANSTYPE, attr)];
+}
+
+static unsigned int transsize(u32 attr)
+{
+       unsigned int siz = FIELD_GET(L2ERRATTR_TRANSSIZ, attr);
+
+       if (attr & L2ERRATTR_BURST)
+               return siz * 16;
+       return siz ?: 8;
+}
+
+void mpc7448_l2_err_print(const struct mpc7448_l2_err *e)
+{
+       pr_err("MPC7448 L2 error: L2ERRDET=%08x%s%s%s%s\n", e->det,
+              e->det & L2ERR_TPARERR ? " [tag parity]" : "",
+              e->det & L2ERR_MBECCERR ? " [multi-bit ECC]" : "",
+              e->det & L2ERR_SBECCERR ? " [single-bit ECC]" : "",
+              e->det & L2ERR_MULL2ERR ? " [multiple errors]" : "");
+       pr_err("  address 0x%09llx (dw %u): %s %s, %u bytes%s%s\n",
+              mpc7448_l2_err_paddr(e),
+              (unsigned int)FIELD_GET(L2ERRATTR_DWNUM, e->attr),
+              transsrc_str(e->attr), transtype_str(e->attr), 
transsize(e->attr),
+              e->attr & L2ERRATTR_BURST ? " burst" : "",
+              e->attr & L2ERRATTR_VALINFO ? "" : " (not latched)");
+       pr_err("  data %08x_%08x syndrome %02x ECC %02x\n",
+              e->capt_hi, e->capt_lo,
+              (unsigned int)FIELD_GET(L2CAPTECC_ECCSYND, e->capt_ecc),
+              (unsigned int)FIELD_GET(L2CAPTECC_ECCCHKSUM, e->capt_ecc));
+}
+EXPORT_SYMBOL_GPL(mpc7448_l2_err_print);
+
+/* Return the number of L2 machine checks on this CPU since the last call */
+unsigned int mpc7448_l2_mce_take(void)
+{
+       return local_xchg(this_cpu_ptr(&mpc7448_l2_mce_count), 0);
+}
+EXPORT_SYMBOL_GPL(mpc7448_l2_mce_take);
+
+int machine_check_7448(struct pt_regs *regs)
+{
+       struct mpc7448_l2_err e;
+       bool l2 = (regs->msr & SRR1_MCE_MSS) &&
+                 (mfspr(SPRN_MSSSR0) & (MSSSR0_L2TAG | MSSSR0_L2DAT));
+
+       machine_check_745x(regs);
+
+       if (l2) {
+               mpc7448_l2_err_capture(&e);
+               mpc7448_l2_err_print(&e);
+               local_inc(this_cpu_ptr(&mpc7448_l2_mce_count));
+       }
+
+       /* Never recoverable: the CPU clears SRR1[RI] for L2 errors. */
+       return 0;
+}

-- 
2.56.1


Reply via email to