MIPS: Octeon: Add kexec and kdump support

[ralf@linux-mips.org: Original patch by Maxim Uvarov <muvarov@gmail.com>
with plenty of further shining, polishing, debugging and testing by me.]

Signed-off-by: Maxim Uvarov <muvarov@gmail.com>
Cc: linux-mips@linux-mips.org
Cc: kexec@lists.infradead.org
Cc: horms@verge.net.au
Patchwork: https://patchwork.linux-mips.org/patch/1026/
Signed-off-by: Ralf Baechle <ralf@linux-mips.org>

6 files changed, 335 insertions, 9 deletions

diff --git a/arch/mips/Makefile b/arch/mips/Makefile
index 654b1ad39f0..033395ec82f 100644
--- a/arch/mips/Makefile
+++ b/arch/mips/Makefile
@@ -192,6 +192,10 @@ endif
 #
 include $(srctree)/arch/mips/Kbuild.platforms
 
+ifdef CONFIG_PHYSICAL_START
+load-y                                  = $(CONFIG_PHYSICAL_START)
+endif
+
 cflags-y                        += -I$(srctree)/arch/mips/include/asm/mach-generic
 drivers-$(CONFIG_PCI)           += arch/mips/pci/
 
diff --git a/arch/mips/cavium-octeon/executive/cvmx-bootmem.c b/arch/mips/cavium-octeon/executive/cvmx-bootmem.c
index fdf5f19bfdb..6d5ddbc112c 100644
--- a/arch/mips/cavium-octeon/executive/cvmx-bootmem.c
+++ b/arch/mips/cavium-octeon/executive/cvmx-bootmem.c
@@ -688,3 +688,8 @@ int64_t cvmx_bootmem_phy_named_block_alloc(uint64_t size, uint64_t min_addr,
                 cvmx_spinlock_unlock((cvmx_spinlock_t *)&(cvmx_bootmem_desc->lock));
         return addr_allocated;
 }
+
+struct cvmx_bootmem_desc *cvmx_bootmem_get_desc(void)
+{
+        return cvmx_bootmem_desc;
+}
diff --git a/arch/mips/cavium-octeon/setup.c b/arch/mips/cavium-octeon/setup.c
index 67aa3b942f0..7c2b7aab77b 100644
--- a/arch/mips/cavium-octeon/setup.c
+++ b/arch/mips/cavium-octeon/setup.c
@@ -25,6 +25,7 @@
 #include <linux/serial_8250.h>
 #include <linux/of_fdt.h>
 #include <linux/libfdt.h>
+#include <linux/kexec.h>
 
 #include <asm/processor.h>
 #include <asm/reboot.h>
@@ -58,11 +59,208 @@ struct octeon_boot_descriptor *octeon_boot_desc_ptr;
 struct cvmx_bootinfo *octeon_bootinfo;
 EXPORT_SYMBOL(octeon_bootinfo);
 
+static unsigned long long RESERVE_LOW_MEM = 0ull;
+#ifdef CONFIG_KEXEC
+#ifdef CONFIG_SMP
+/*
+ * Wait for relocation code is prepared and send
+ * secondary CPUs to spin until kernel is relocated.
+ */
+static void octeon_kexec_smp_down(void *ignored)
+{
+        int cpu = smp_processor_id();
+
+        local_irq_disable();
+        set_cpu_online(cpu, false);
+        while (!atomic_read(&kexec_ready_to_reboot))
+                cpu_relax();
+
+        asm volatile (
+        "       sync                                            \n"
+        "       synci   ($0)                                    \n");
+
+        relocated_kexec_smp_wait(NULL);
+}
+#endif
+
+#define OCTEON_DDR0_BASE    (0x0ULL)
+#define OCTEON_DDR0_SIZE    (0x010000000ULL)
+#define OCTEON_DDR1_BASE    (0x410000000ULL)
+#define OCTEON_DDR1_SIZE    (0x010000000ULL)
+#define OCTEON_DDR2_BASE    (0x020000000ULL)
+#define OCTEON_DDR2_SIZE    (0x3e0000000ULL)
+#define OCTEON_MAX_PHY_MEM_SIZE (16*1024*1024*1024ULL)
+
+static struct kimage *kimage_ptr;
+
+static void kexec_bootmem_init(uint64_t mem_size, uint32_t low_reserved_bytes)
+{
+        int64_t addr;
+        struct cvmx_bootmem_desc *bootmem_desc;
+
+        bootmem_desc = cvmx_bootmem_get_desc();
+
+        if (mem_size > OCTEON_MAX_PHY_MEM_SIZE) {
+                mem_size = OCTEON_MAX_PHY_MEM_SIZE;
+                pr_err("Error: requested memory too large,"
+                       "truncating to maximum size\n");
+        }
+
+        bootmem_desc->major_version = CVMX_BOOTMEM_DESC_MAJ_VER;
+        bootmem_desc->minor_version = CVMX_BOOTMEM_DESC_MIN_VER;
+
+        addr = (OCTEON_DDR0_BASE + RESERVE_LOW_MEM + low_reserved_bytes);
+        bootmem_desc->head_addr = 0;
+
+        if (mem_size <= OCTEON_DDR0_SIZE) {
+                __cvmx_bootmem_phy_free(addr,
+                                mem_size - RESERVE_LOW_MEM -
+                                low_reserved_bytes, 0);
+                return;
+        }
+
+        __cvmx_bootmem_phy_free(addr,
+                        OCTEON_DDR0_SIZE - RESERVE_LOW_MEM -
+                        low_reserved_bytes, 0);
+
+        mem_size -= OCTEON_DDR0_SIZE;
+
+        if (mem_size > OCTEON_DDR1_SIZE) {
+                __cvmx_bootmem_phy_free(OCTEON_DDR1_BASE, OCTEON_DDR1_SIZE, 0);
+                __cvmx_bootmem_phy_free(OCTEON_DDR2_BASE,
+                                mem_size - OCTEON_DDR1_SIZE, 0);
+        } else
+                __cvmx_bootmem_phy_free(OCTEON_DDR1_BASE, mem_size, 0);
+}
+
+static int octeon_kexec_prepare(struct kimage *image)
+{
+        int i;
+        char *bootloader = "kexec";
+
+        octeon_boot_desc_ptr->argc = 0;
+        for (i = 0; i < image->nr_segments; i++) {
+                if (!strncmp(bootloader, (char *)image->segment[i].buf,
+                                strlen(bootloader))) {
+                        /*
+                         * convert command line string to array
+                         * of parameters (as bootloader does).
+                         */
+                        int argc = 0, offt;
+                        char *str = (char *)image->segment[i].buf;
+                        char *ptr = strchr(str, ' ');
+                        while (ptr && (OCTEON_ARGV_MAX_ARGS > argc)) {
+                                *ptr = '\0';
+                                if (ptr[1] != ' ') {
+                                        offt = (int)(ptr - str + 1);
+                                        octeon_boot_desc_ptr->argv[argc] =
+                                                image->segment[i].mem + offt;
+                                        argc++;
+                                }
+                                ptr = strchr(ptr + 1, ' ');
+                        }
+                        octeon_boot_desc_ptr->argc = argc;
+                        break;
+                }
+        }
+
+        /*
+         * Information about segments will be needed during pre-boot memory
+         * initialization.
+         */
+        kimage_ptr = image;
+        return 0;
+}
+
+static void octeon_generic_shutdown(void)
+{
+        int cpu, i;
+        struct cvmx_bootmem_desc *bootmem_desc;
+        void *named_block_array_ptr;
+
+        bootmem_desc = cvmx_bootmem_get_desc();
+        named_block_array_ptr =
+                cvmx_phys_to_ptr(bootmem_desc->named_block_array_addr);
+
+#ifdef CONFIG_SMP
+        /* disable watchdogs */
+        for_each_online_cpu(cpu)
+                cvmx_write_csr(CVMX_CIU_WDOGX(cpu_logical_map(cpu)), 0);
+#else
+        cvmx_write_csr(CVMX_CIU_WDOGX(cvmx_get_core_num()), 0);
+#endif
+        if (kimage_ptr != kexec_crash_image) {
+                memset(named_block_array_ptr,
+                        0x0,
+                        CVMX_BOOTMEM_NUM_NAMED_BLOCKS *
+                        sizeof(struct cvmx_bootmem_named_block_desc));
+                /*
+                 * Mark all memory (except low 0x100000 bytes) as free.
+                 * It is the same thing that bootloader does.
+                 */
+                kexec_bootmem_init(octeon_bootinfo->dram_size*1024ULL*1024ULL,
+                                0x100000);
+                /*
+                 * Allocate all segments to avoid their corruption during boot.
+                 */
+                for (i = 0; i < kimage_ptr->nr_segments; i++)
+                        cvmx_bootmem_alloc_address(
+                                kimage_ptr->segment[i].memsz + 2*PAGE_SIZE,
+                                kimage_ptr->segment[i].mem - PAGE_SIZE,
+                                PAGE_SIZE);
+        } else {
+                /*
+                 * Do not mark all memory as free. Free only named sections
+                 * leaving the rest of memory unchanged.
+                 */
+                struct cvmx_bootmem_named_block_desc *ptr =
+                        (struct cvmx_bootmem_named_block_desc *)