powerpc/book3s: Recover from MC in sapphire on SCOM read via MMIO.

Detect and recover from machine check when inside opal on a special
scom load instructions. On specific SCOM read via MMIO we may get a machine
check exception with SRR0 pointing inside opal. To recover from MC
in this scenario, get a recovery instruction address and return to it from
MC.

OPAL will export the machine check recoverable ranges through
device tree node mcheck-recoverable-ranges under ibm,opal:

# hexdump /proc/device-tree/ibm,opal/mcheck-recoverable-ranges
0000000 0000 0000 3000 2804 0000 000c 0000 0000
0000010 3000 2814 0000 0000 3000 27f0 0000 000c
0000020 0000 0000 3000 2814 xxxx xxxx xxxx xxxx
0000030 llll llll yyyy yyyy yyyy yyyy
...
...
#

where:
	xxxx xxxx xxxx xxxx = Starting instruction address
	llll llll           = Length of the address range.
	yyyy yyyy yyyy yyyy = recovery address

Each recoverable address range entry is (start address, len,
recovery address), 2 cells each for start and recovery address, 1 cell for
len, totalling 5 cells per entry. During kernel boot time, build up the
recovery table with the list of recovery ranges from device-tree node which
will be used during machine check exception to recover from MMIO SCOM UE.

Signed-off-by: Mahesh Salgaonkar <mahesh@linux.vnet.ibm.com>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>

2 files changed, 98 insertions, 3 deletions

diff --git a/arch/powerpc/platforms/powernv/opal.c b/arch/powerpc/platforms/powernv/opal.c
index 65499adaecff..d5f11d689d6c 100644
--- a/arch/powerpc/platforms/powernv/opal.c
+++ b/arch/powerpc/platforms/powernv/opal.c
@@ -21,6 +21,7 @@
 #include <linux/sched.h>
 #include <linux/kobject.h>
 #include <linux/delay.h>
+#include <linux/memblock.h>
 #include <asm/opal.h>
 #include <asm/firmware.h>
 #include <asm/mce.h>
@@ -33,8 +34,18 @@ struct kobject *opal_kobj;
 struct opal {
         u64 base;
         u64 entry;
+        u64 size;
 } opal;
 
+struct mcheck_recoverable_range {
+        u64 start_addr;
+        u64 end_addr;
+        u64 recover_addr;
+};
+
+static struct mcheck_recoverable_range *mc_recoverable_range;
+static int mc_recoverable_range_len;
+
 static struct device_node *opal_node;
 static DEFINE_SPINLOCK(opal_write_lock);
 extern u64 opal_mc_secondary_handler[];
@@ -49,25 +60,29 @@ static atomic_t opal_notifier_hold = ATOMIC_INIT(0);
 int __init early_init_dt_scan_opal(unsigned long node,
                                    const char *uname, int depth, void *data)
 {
-        const void *basep, *entryp;
-        unsigned long basesz, entrysz;
+        const void *basep, *entryp, *sizep;
+        unsigned long basesz, entrysz, runtimesz;
 
         if (depth != 1 || strcmp(uname, "ibm,opal") != 0)
                 return 0;
 
         basep  = of_get_flat_dt_prop(node, "opal-base-address", &basesz);
         entryp = of_get_flat_dt_prop(node, "opal-entry-address", &entrysz);
+        sizep = of_get_flat_dt_prop(node, "opal-runtime-size", &runtimesz);
 
-        if (!basep || !entryp)
+        if (!basep || !entryp || !sizep)
                 return 1;
 
         opal.base = of_read_number(basep, basesz/4);
         opal.entry = of_read_number(entryp, entrysz/4);
+        opal.size = of_read_number(sizep, runtimesz/4);
 
         pr_debug("OPAL Base  = 0x%llx (basep=%p basesz=%ld)\n",
                  opal.base, basep, basesz);
         pr_debug("OPAL Entry = 0x%llx (entryp=%p basesz=%ld)\n",
                  opal.entry, entryp, entrysz);
+        pr_debug("OPAL Entry = 0x%llx (sizep=%p runtimesz=%ld)\n",
+                 opal.size, sizep, runtimesz);
 
         powerpc_firmware_features |= FW_FEATURE_OPAL;
         if (of_flat_dt_is_compatible(node, "ibm,opal-v3")) {
@@ -84,6 +99,53 @@ int __init early_init_dt_scan_opal(unsigned long node,
         return 1;
 }
 
+int __init early_init_dt_scan_recoverable_ranges(unsigned long node,
+                                   const char *uname, int depth, void *data)
+{
+        unsigned long i, size;
+        const __be32 *prop;
+
+        if (depth != 1 || strcmp(uname, "ibm,opal") != 0)
+                return 0;
+
+        prop = of_get_flat_dt_prop(node, "mcheck-recoverable-ranges", &size);
+
+        if (!prop)
+                return 1;
+
+        pr_debug("Found machine check recoverable ranges.\n");
+
+        /*
+         * Allocate a buffer to hold the MC recoverable ranges. We would be
+         * accessing them in real mode, hence it needs to be within
+         * RMO region.
+         */
+        mc_recoverable_range =__va(memblock_alloc_base(size, __alignof__(u64),
+                                                        ppc64_rma_size));
+        memset(mc_recoverable_range, 0, size);
+
+        /*
+         * Each recoverable address entry is an (start address,len,
+         * recover address) pair, * 2 cells each, totalling 4 cells per entry.
+         */
+        for (i = 0; i < size / (sizeof(*prop) * 5); i++) {
+                mc_recoverable_range[i].start_addr =
+                                        of_read_number(prop + (i * 5) + 0, 2);
+                mc_recoverable_range[i].end_addr =
+                                        mc_recoverable_range[i].start_addr +
+                                        of_read_number(prop + (i * 5) + 2, 1);
+                mc_recoverable_range[i].recover_addr =
+                                        of_read_number(prop + (i * 5) + 3, 2);
+
+                pr_debug("Machine check recoverable range: %llx..%llx: %llx\n",
+                                mc_recoverable_range[i].start_addr,
+                                mc_recoverable_range[i].end_addr,
+                                mc_recoverable_range[i].recover_addr);
+        }
+        mc_recoverable_range_len = i;
+        return 1;
+}
+
 static int __init opal_register_exception_handlers(void)
 {
 #ifdef __BIG_ENDIAN__
@@ -401,6 +463,38 @@ int opal_machine_check(struct pt_regs *regs)
         return 0;
 }
 
+static uint64_t find_recovery_address(uint64_t nip)
+{
+        int i;
+
+        for (i = 0; i < mc_recoverable_range_len; i++)
+                if ((nip >= mc_recoverable_range[i].start_addr) &&
+                    (nip < mc_recoverable_range[i].end_addr))
+                    return mc_recoverable_range[i].recover_addr;
+        return 0;
+}
+
+bool opal_mce_check_early_recovery(struct pt_regs *regs)
+{
+        uint64_t recover_addr = 0;
+
+        if (!opal.base || !opal.size)
+                goto out;
+
+        if ((regs->nip >= opal.base) &&
+                        (regs->nip <= (opal.base + opal.size)))
+                recover_addr = find_recovery_address(regs->nip);
+
+        /*
+         * Setup regs->nip to rfi into fixup address.
+         */
+        if (recover_addr)
+                regs->nip = recover_addr;
+
+out:
+        return !!recover_addr;
+}
+
 static irqreturn_t opal_interrupt(int irq, void *data)
 {
         __be64 events;
diff --git a/arch/powerpc/platforms/powernv/setup.c b/arch/powerpc/platforms/powernv/setup.c
index 110f4fbd319f..2d8084565676 100644
--- a/arch/powerpc/platforms/powernv/setup.c
+++ b/arch/powerpc/platforms/powernv/setup.c
@@ -188,6 +188,7 @@ static void __init pnv_setup_machdep_opal(void)
         ppc_md.power_off = pnv_power_off;
         ppc_md.halt = pnv_halt;
         ppc_md.machine_check_exception = opal_machine_check;
+        ppc_md.mce_check_early_recovery = opal_mce_check_early_recovery;
 }
 
 #ifdef CONFIG_PPC_POWERNV_RTAS