Michael Ellerman | 3d1229d | 2005-11-14 23:35:00 +1100 | [diff] [blame] | 1 | /* |
| 2 | * Code to handle transition of Linux booting another kernel. |
| 3 | * |
| 4 | * Copyright (C) 2002-2003 Eric Biederman <ebiederm@xmission.com> |
| 5 | * GameCube/ppc32 port Copyright (C) 2004 Albert Herranz |
| 6 | * Copyright (C) 2005 IBM Corporation. |
| 7 | * |
| 8 | * This source code is licensed under the GNU General Public License, |
| 9 | * Version 2. See the file COPYING for more details. |
| 10 | */ |
| 11 | |
| 12 | #include <linux/kexec.h> |
| 13 | #include <linux/reboot.h> |
| 14 | #include <linux/threads.h> |
Yinghai Lu | 95f72d1 | 2010-07-12 14:36:09 +1000 | [diff] [blame] | 15 | #include <linux/memblock.h> |
Dale Farnsworth | 2e8e4f5 | 2008-12-16 06:22:59 +0000 | [diff] [blame] | 16 | #include <linux/of.h> |
Matthew McClintock | c71635d | 2010-09-16 17:58:23 -0500 | [diff] [blame] | 17 | #include <linux/irq.h> |
Anton Blanchard | ac4414e4 | 2011-01-06 18:00:36 +0000 | [diff] [blame] | 18 | #include <linux/ftrace.h> |
Matthew McClintock | c71635d | 2010-09-16 17:58:23 -0500 | [diff] [blame] | 19 | |
Michael Ellerman | 3d1229d | 2005-11-14 23:35:00 +1100 | [diff] [blame] | 20 | #include <asm/machdep.h> |
Hari Bathini | 8ff8127 | 2013-11-15 23:01:32 +0530 | [diff] [blame] | 21 | #include <asm/pgalloc.h> |
David S. Miller | d9b2b2a | 2008-02-13 16:56:49 -0800 | [diff] [blame] | 22 | #include <asm/prom.h> |
Dale Farnsworth | 2e8e4f5 | 2008-12-16 06:22:59 +0000 | [diff] [blame] | 23 | #include <asm/sections.h> |
Michael Ellerman | 3d1229d | 2005-11-14 23:35:00 +1100 | [diff] [blame] | 24 | |
Matthew McClintock | c71635d | 2010-09-16 17:58:23 -0500 | [diff] [blame] | 25 | void machine_kexec_mask_interrupts(void) { |
| 26 | unsigned int i; |
Grant Likely | 4013369 | 2012-04-23 12:30:02 +0000 | [diff] [blame] | 27 | struct irq_desc *desc; |
Matthew McClintock | c71635d | 2010-09-16 17:58:23 -0500 | [diff] [blame] | 28 | |
Grant Likely | 4013369 | 2012-04-23 12:30:02 +0000 | [diff] [blame] | 29 | for_each_irq_desc(i, desc) { |
Lennert Buytenhek | e118028 | 2011-03-07 14:00:20 +0000 | [diff] [blame] | 30 | struct irq_chip *chip; |
Matthew McClintock | c71635d | 2010-09-16 17:58:23 -0500 | [diff] [blame] | 31 | |
Thomas Gleixner | ec775d0 | 2011-03-25 16:45:20 +0100 | [diff] [blame] | 32 | chip = irq_desc_get_chip(desc); |
Lennert Buytenhek | e118028 | 2011-03-07 14:00:20 +0000 | [diff] [blame] | 33 | if (!chip) |
| 34 | continue; |
Matthew McClintock | c71635d | 2010-09-16 17:58:23 -0500 | [diff] [blame] | 35 | |
Thomas Gleixner | 98488db | 2011-03-25 15:43:57 +0100 | [diff] [blame] | 36 | if (chip->irq_eoi && irqd_irq_inprogress(&desc->irq_data)) |
Lennert Buytenhek | e118028 | 2011-03-07 14:00:20 +0000 | [diff] [blame] | 37 | chip->irq_eoi(&desc->irq_data); |
Matthew McClintock | c71635d | 2010-09-16 17:58:23 -0500 | [diff] [blame] | 38 | |
Lennert Buytenhek | e118028 | 2011-03-07 14:00:20 +0000 | [diff] [blame] | 39 | if (chip->irq_mask) |
| 40 | chip->irq_mask(&desc->irq_data); |
| 41 | |
Thomas Gleixner | 98488db | 2011-03-25 15:43:57 +0100 | [diff] [blame] | 42 | if (chip->irq_disable && !irqd_irq_disabled(&desc->irq_data)) |
Lennert Buytenhek | e118028 | 2011-03-07 14:00:20 +0000 | [diff] [blame] | 43 | chip->irq_disable(&desc->irq_data); |
Matthew McClintock | c71635d | 2010-09-16 17:58:23 -0500 | [diff] [blame] | 44 | } |
| 45 | } |
| 46 | |
Michael Ellerman | 3d1229d | 2005-11-14 23:35:00 +1100 | [diff] [blame] | 47 | void machine_crash_shutdown(struct pt_regs *regs) |
| 48 | { |
Anton Blanchard | c1f784e | 2011-01-06 17:56:09 +0000 | [diff] [blame] | 49 | default_machine_crash_shutdown(regs); |
Michael Ellerman | 3d1229d | 2005-11-14 23:35:00 +1100 | [diff] [blame] | 50 | } |
| 51 | |
| 52 | /* |
| 53 | * Do what every setup is needed on image and the |
| 54 | * reboot code buffer to allow us to avoid allocations |
| 55 | * later. |
| 56 | */ |
| 57 | int machine_kexec_prepare(struct kimage *image) |
| 58 | { |
| 59 | if (ppc_md.machine_kexec_prepare) |
| 60 | return ppc_md.machine_kexec_prepare(image); |
Anton Vorontsov | 77733f8 | 2008-12-16 06:23:05 +0000 | [diff] [blame] | 61 | else |
| 62 | return default_machine_kexec_prepare(image); |
Michael Ellerman | 3d1229d | 2005-11-14 23:35:00 +1100 | [diff] [blame] | 63 | } |
| 64 | |
| 65 | void machine_kexec_cleanup(struct kimage *image) |
| 66 | { |
Michael Ellerman | 3d1229d | 2005-11-14 23:35:00 +1100 | [diff] [blame] | 67 | } |
| 68 | |
Neil Horman | 67238fb | 2010-07-13 03:46:09 +0000 | [diff] [blame] | 69 | void arch_crash_save_vmcoreinfo(void) |
| 70 | { |
| 71 | |
| 72 | #ifdef CONFIG_NEED_MULTIPLE_NODES |
| 73 | VMCOREINFO_SYMBOL(node_data); |
| 74 | VMCOREINFO_LENGTH(node_data, MAX_NUMNODES); |
| 75 | #endif |
| 76 | #ifndef CONFIG_NEED_MULTIPLE_NODES |
| 77 | VMCOREINFO_SYMBOL(contig_page_data); |
| 78 | #endif |
Hari Bathini | 8ff8127 | 2013-11-15 23:01:32 +0530 | [diff] [blame] | 79 | #if defined(CONFIG_PPC64) && defined(CONFIG_SPARSEMEM_VMEMMAP) |
| 80 | VMCOREINFO_SYMBOL(vmemmap_list); |
| 81 | VMCOREINFO_SYMBOL(mmu_vmemmap_psize); |
| 82 | VMCOREINFO_SYMBOL(mmu_psize_defs); |
| 83 | VMCOREINFO_STRUCT_SIZE(vmemmap_backing); |
| 84 | VMCOREINFO_OFFSET(vmemmap_backing, list); |
| 85 | VMCOREINFO_OFFSET(vmemmap_backing, phys); |
| 86 | VMCOREINFO_OFFSET(vmemmap_backing, virt_addr); |
| 87 | VMCOREINFO_STRUCT_SIZE(mmu_psize_def); |
| 88 | VMCOREINFO_OFFSET(mmu_psize_def, shift); |
| 89 | #endif |
Neil Horman | 67238fb | 2010-07-13 03:46:09 +0000 | [diff] [blame] | 90 | } |
| 91 | |
Michael Ellerman | 3d1229d | 2005-11-14 23:35:00 +1100 | [diff] [blame] | 92 | /* |
| 93 | * Do not allocate memory (or fail in any way) in machine_kexec(). |
| 94 | * We are past the point of no return, committed to rebooting now. |
| 95 | */ |
Huang Ying | 3ab8352 | 2008-07-25 19:45:07 -0700 | [diff] [blame] | 96 | void machine_kexec(struct kimage *image) |
Michael Ellerman | 3d1229d | 2005-11-14 23:35:00 +1100 | [diff] [blame] | 97 | { |
Anton Blanchard | ac4414e4 | 2011-01-06 18:00:36 +0000 | [diff] [blame] | 98 | int save_ftrace_enabled; |
| 99 | |
| 100 | save_ftrace_enabled = __ftrace_enabled_save(); |
| 101 | |
Anton Blanchard | 357574c | 2011-02-23 12:46:16 +0000 | [diff] [blame] | 102 | if (ppc_md.machine_kexec) |
| 103 | ppc_md.machine_kexec(image); |
| 104 | else |
| 105 | default_machine_kexec(image); |
Anton Vorontsov | 77733f8 | 2008-12-16 06:23:05 +0000 | [diff] [blame] | 106 | |
Anton Blanchard | ac4414e4 | 2011-01-06 18:00:36 +0000 | [diff] [blame] | 107 | __ftrace_enabled_restore(save_ftrace_enabled); |
| 108 | |
Anton Vorontsov | 77733f8 | 2008-12-16 06:23:05 +0000 | [diff] [blame] | 109 | /* Fall back to normal restart if we're still alive. */ |
| 110 | machine_restart(NULL); |
Michael Ellerman | 3d1229d | 2005-11-14 23:35:00 +1100 | [diff] [blame] | 111 | for(;;); |
| 112 | } |
Michael Ellerman | 47585d8 | 2006-07-05 14:39:42 +1000 | [diff] [blame] | 113 | |
Michael Ellerman | 47585d8 | 2006-07-05 14:39:42 +1000 | [diff] [blame] | 114 | void __init reserve_crashkernel(void) |
| 115 | { |
Bernhard Walle | edd8ce6 | 2007-10-18 23:41:01 -0700 | [diff] [blame] | 116 | unsigned long long crash_size, crash_base; |
| 117 | int ret; |
Michael Ellerman | 47585d8 | 2006-07-05 14:39:42 +1000 | [diff] [blame] | 118 | |
Bernhard Walle | edd8ce6 | 2007-10-18 23:41:01 -0700 | [diff] [blame] | 119 | /* use common parsing */ |
Yinghai Lu | 95f72d1 | 2010-07-12 14:36:09 +1000 | [diff] [blame] | 120 | ret = parse_crashkernel(boot_command_line, memblock_phys_mem_size(), |
Bernhard Walle | edd8ce6 | 2007-10-18 23:41:01 -0700 | [diff] [blame] | 121 | &crash_size, &crash_base); |
| 122 | if (ret == 0 && crash_size > 0) { |
Bernhard Walle | edd8ce6 | 2007-10-18 23:41:01 -0700 | [diff] [blame] | 123 | crashk_res.start = crash_base; |
Michael Ellerman | eabd909 | 2008-04-30 14:47:12 +1000 | [diff] [blame] | 124 | crashk_res.end = crash_base + crash_size - 1; |
Bernhard Walle | edd8ce6 | 2007-10-18 23:41:01 -0700 | [diff] [blame] | 125 | } |
| 126 | |
Michael Ellerman | eabd909 | 2008-04-30 14:47:12 +1000 | [diff] [blame] | 127 | if (crashk_res.end == crashk_res.start) { |
| 128 | crashk_res.start = crashk_res.end = 0; |
Michael Ellerman | 47585d8 | 2006-07-05 14:39:42 +1000 | [diff] [blame] | 129 | return; |
Michael Ellerman | eabd909 | 2008-04-30 14:47:12 +1000 | [diff] [blame] | 130 | } |
Michael Ellerman | 47585d8 | 2006-07-05 14:39:42 +1000 | [diff] [blame] | 131 | |
| 132 | /* We might have got these values via the command line or the |
| 133 | * device tree, either way sanitise them now. */ |
| 134 | |
Joe Perches | 28f65c11 | 2011-06-09 09:13:32 -0700 | [diff] [blame] | 135 | crash_size = resource_size(&crashk_res); |
Michael Ellerman | eabd909 | 2008-04-30 14:47:12 +1000 | [diff] [blame] | 136 | |
Suzuki Poulose | 0f890c8 | 2011-12-14 22:57:15 +0000 | [diff] [blame] | 137 | #ifndef CONFIG_NONSTATIC_KERNEL |
Michael Ellerman | 47585d8 | 2006-07-05 14:39:42 +1000 | [diff] [blame] | 138 | if (crashk_res.start != KDUMP_KERNELBASE) |
| 139 | printk("Crash kernel location must be 0x%x\n", |
| 140 | KDUMP_KERNELBASE); |
| 141 | |
| 142 | crashk_res.start = KDUMP_KERNELBASE; |
Milton Miller | 66c721e | 2009-01-02 10:46:15 +0000 | [diff] [blame] | 143 | #else |
| 144 | if (!crashk_res.start) { |
Anton Blanchard | 8aa6d35 | 2011-07-31 19:27:35 +0000 | [diff] [blame] | 145 | #ifdef CONFIG_PPC64 |
Milton Miller | 66c721e | 2009-01-02 10:46:15 +0000 | [diff] [blame] | 146 | /* |
Anton Blanchard | 8aa6d35 | 2011-07-31 19:27:35 +0000 | [diff] [blame] | 147 | * On 64bit we split the RMO in half but cap it at half of |
| 148 | * a small SLB (128MB) since the crash kernel needs to place |
| 149 | * itself and some stacks to be in the first segment. |
Milton Miller | 66c721e | 2009-01-02 10:46:15 +0000 | [diff] [blame] | 150 | */ |
Mahesh Salgaonkar | e641eb0 | 2013-12-09 15:33:39 +0530 | [diff] [blame] | 151 | crashk_res.start = min(0x8000000ULL, (ppc64_rma_size / 2)); |
Anton Blanchard | 8aa6d35 | 2011-07-31 19:27:35 +0000 | [diff] [blame] | 152 | #else |
Milton Miller | 66c721e | 2009-01-02 10:46:15 +0000 | [diff] [blame] | 153 | crashk_res.start = KDUMP_KERNELBASE; |
Anton Blanchard | 8aa6d35 | 2011-07-31 19:27:35 +0000 | [diff] [blame] | 154 | #endif |
Milton Miller | 66c721e | 2009-01-02 10:46:15 +0000 | [diff] [blame] | 155 | } |
| 156 | |
| 157 | crash_base = PAGE_ALIGN(crashk_res.start); |
| 158 | if (crash_base != crashk_res.start) { |
| 159 | printk("Crash kernel base must be aligned to 0x%lx\n", |
| 160 | PAGE_SIZE); |
| 161 | crashk_res.start = crash_base; |
| 162 | } |
| 163 | |
Mohan Kumar M | 54622f1 | 2008-10-21 17:38:10 +0000 | [diff] [blame] | 164 | #endif |
Bernhard Walle | edd8ce6 | 2007-10-18 23:41:01 -0700 | [diff] [blame] | 165 | crash_size = PAGE_ALIGN(crash_size); |
| 166 | crashk_res.end = crashk_res.start + crash_size - 1; |
Michael Ellerman | 47585d8 | 2006-07-05 14:39:42 +1000 | [diff] [blame] | 167 | |
Milton Miller | 66c721e | 2009-01-02 10:46:15 +0000 | [diff] [blame] | 168 | /* The crash region must not overlap the current kernel */ |
| 169 | if (overlaps_crashkernel(__pa(_stext), _end - _stext)) { |
| 170 | printk(KERN_WARNING |
| 171 | "Crash kernel can not overlap current kernel\n"); |
| 172 | crashk_res.start = crashk_res.end = 0; |
| 173 | return; |
| 174 | } |
| 175 | |
Michael Ellerman | 47585d8 | 2006-07-05 14:39:42 +1000 | [diff] [blame] | 176 | /* Crash kernel trumps memory limit */ |
| 177 | if (memory_limit && memory_limit <= crashk_res.end) { |
| 178 | memory_limit = crashk_res.end + 1; |
Becky Bruce | 49a8496 | 2009-05-08 12:19:27 +0000 | [diff] [blame] | 179 | printk("Adjusted memory limit for crashkernel, now 0x%llx\n", |
Suzuki Poulose | a84fcd4 | 2012-08-21 01:42:33 +0000 | [diff] [blame] | 180 | memory_limit); |
Michael Ellerman | 47585d8 | 2006-07-05 14:39:42 +1000 | [diff] [blame] | 181 | } |
| 182 | |
Bernhard Walle | edd8ce6 | 2007-10-18 23:41:01 -0700 | [diff] [blame] | 183 | printk(KERN_INFO "Reserving %ldMB of memory at %ldMB " |
| 184 | "for crashkernel (System RAM: %ldMB)\n", |
| 185 | (unsigned long)(crash_size >> 20), |
| 186 | (unsigned long)(crashk_res.start >> 20), |
Yinghai Lu | 95f72d1 | 2010-07-12 14:36:09 +1000 | [diff] [blame] | 187 | (unsigned long)(memblock_phys_mem_size() >> 20)); |
Bernhard Walle | edd8ce6 | 2007-10-18 23:41:01 -0700 | [diff] [blame] | 188 | |
Hari Bathini | 5735af3 | 2018-06-28 10:49:56 +0530 | [diff] [blame] | 189 | if (!memblock_is_region_memory(crashk_res.start, crash_size) || |
| 190 | memblock_reserve(crashk_res.start, crash_size)) { |
| 191 | pr_err("Failed to reserve memory for crashkernel!\n"); |
| 192 | crashk_res.start = crashk_res.end = 0; |
| 193 | return; |
| 194 | } |
Michael Ellerman | 47585d8 | 2006-07-05 14:39:42 +1000 | [diff] [blame] | 195 | } |
| 196 | |
| 197 | int overlaps_crashkernel(unsigned long start, unsigned long size) |
| 198 | { |
| 199 | return (start + size) > crashk_res.start && start <= crashk_res.end; |
| 200 | } |
Dale Farnsworth | 2e8e4f5 | 2008-12-16 06:22:59 +0000 | [diff] [blame] | 201 | |
| 202 | /* Values we need to export to the second kernel via the device tree. */ |
Matthew McClintock | bbc8e30 | 2010-07-21 11:14:54 +0000 | [diff] [blame] | 203 | static phys_addr_t kernel_end; |
Anton Blanchard | ea961a8 | 2014-01-22 08:40:28 +1100 | [diff] [blame] | 204 | static phys_addr_t crashk_base; |
Matthew McClintock | bbc8e30 | 2010-07-21 11:14:54 +0000 | [diff] [blame] | 205 | static phys_addr_t crashk_size; |
Anton Blanchard | ea961a8 | 2014-01-22 08:40:28 +1100 | [diff] [blame] | 206 | static unsigned long long mem_limit; |
Dale Farnsworth | 2e8e4f5 | 2008-12-16 06:22:59 +0000 | [diff] [blame] | 207 | |
| 208 | static struct property kernel_end_prop = { |
| 209 | .name = "linux,kernel-end", |
Matthew McClintock | bbc8e30 | 2010-07-21 11:14:54 +0000 | [diff] [blame] | 210 | .length = sizeof(phys_addr_t), |
Dale Farnsworth | 2e8e4f5 | 2008-12-16 06:22:59 +0000 | [diff] [blame] | 211 | .value = &kernel_end, |
| 212 | }; |
| 213 | |
Dale Farnsworth | 6f29c32 | 2008-12-17 10:09:06 +0000 | [diff] [blame] | 214 | static struct property crashk_base_prop = { |
| 215 | .name = "linux,crashkernel-base", |
Matthew McClintock | bbc8e30 | 2010-07-21 11:14:54 +0000 | [diff] [blame] | 216 | .length = sizeof(phys_addr_t), |
Anton Blanchard | ea961a8 | 2014-01-22 08:40:28 +1100 | [diff] [blame] | 217 | .value = &crashk_base |
Dale Farnsworth | 6f29c32 | 2008-12-17 10:09:06 +0000 | [diff] [blame] | 218 | }; |
| 219 | |
| 220 | static struct property crashk_size_prop = { |
| 221 | .name = "linux,crashkernel-size", |
Matthew McClintock | bbc8e30 | 2010-07-21 11:14:54 +0000 | [diff] [blame] | 222 | .length = sizeof(phys_addr_t), |
Dale Farnsworth | 6f29c32 | 2008-12-17 10:09:06 +0000 | [diff] [blame] | 223 | .value = &crashk_size, |
| 224 | }; |
| 225 | |
Suzuki Poulose | 4bc77a5 | 2012-08-21 01:42:43 +0000 | [diff] [blame] | 226 | static struct property memory_limit_prop = { |
| 227 | .name = "linux,memory-limit", |
| 228 | .length = sizeof(unsigned long long), |
Anton Blanchard | ea961a8 | 2014-01-22 08:40:28 +1100 | [diff] [blame] | 229 | .value = &mem_limit, |
Suzuki Poulose | 4bc77a5 | 2012-08-21 01:42:43 +0000 | [diff] [blame] | 230 | }; |
| 231 | |
Anton Blanchard | ea961a8 | 2014-01-22 08:40:28 +1100 | [diff] [blame] | 232 | #define cpu_to_be_ulong __PASTE(cpu_to_be, BITS_PER_LONG) |
| 233 | |
Dale Farnsworth | 6f29c32 | 2008-12-17 10:09:06 +0000 | [diff] [blame] | 234 | static void __init export_crashk_values(struct device_node *node) |
| 235 | { |
Dale Farnsworth | 6f29c32 | 2008-12-17 10:09:06 +0000 | [diff] [blame] | 236 | /* There might be existing crash kernel properties, but we can't |
| 237 | * be sure what's in them, so remove them. */ |
Suraj Jitindar Singh | 925e2d1 | 2016-04-28 15:34:55 +1000 | [diff] [blame] | 238 | of_remove_property(node, of_find_property(node, |
| 239 | "linux,crashkernel-base", NULL)); |
| 240 | of_remove_property(node, of_find_property(node, |
| 241 | "linux,crashkernel-size", NULL)); |
Dale Farnsworth | 6f29c32 | 2008-12-17 10:09:06 +0000 | [diff] [blame] | 242 | |
| 243 | if (crashk_res.start != 0) { |
Anton Blanchard | ea961a8 | 2014-01-22 08:40:28 +1100 | [diff] [blame] | 244 | crashk_base = cpu_to_be_ulong(crashk_res.start), |
Nathan Fontenot | 79d1c71 | 2012-10-02 16:58:46 +0000 | [diff] [blame] | 245 | of_add_property(node, &crashk_base_prop); |
Anton Blanchard | ea961a8 | 2014-01-22 08:40:28 +1100 | [diff] [blame] | 246 | crashk_size = cpu_to_be_ulong(resource_size(&crashk_res)); |
Nathan Fontenot | 79d1c71 | 2012-10-02 16:58:46 +0000 | [diff] [blame] | 247 | of_add_property(node, &crashk_size_prop); |
Dale Farnsworth | 6f29c32 | 2008-12-17 10:09:06 +0000 | [diff] [blame] | 248 | } |
Suzuki Poulose | 4bc77a5 | 2012-08-21 01:42:43 +0000 | [diff] [blame] | 249 | |
| 250 | /* |
| 251 | * memory_limit is required by the kexec-tools to limit the |
| 252 | * crash regions to the actual memory used. |
| 253 | */ |
Anton Blanchard | ea961a8 | 2014-01-22 08:40:28 +1100 | [diff] [blame] | 254 | mem_limit = cpu_to_be_ulong(memory_limit); |
Nathan Fontenot | 79d1c71 | 2012-10-02 16:58:46 +0000 | [diff] [blame] | 255 | of_update_property(node, &memory_limit_prop); |
Dale Farnsworth | 6f29c32 | 2008-12-17 10:09:06 +0000 | [diff] [blame] | 256 | } |
| 257 | |
Dale Farnsworth | 2e8e4f5 | 2008-12-16 06:22:59 +0000 | [diff] [blame] | 258 | static int __init kexec_setup(void) |
| 259 | { |
| 260 | struct device_node *node; |
Dale Farnsworth | 2e8e4f5 | 2008-12-16 06:22:59 +0000 | [diff] [blame] | 261 | |
| 262 | node = of_find_node_by_path("/chosen"); |
| 263 | if (!node) |
| 264 | return -ENOENT; |
| 265 | |
| 266 | /* remove any stale properties so ours can be found */ |
Suraj Jitindar Singh | 925e2d1 | 2016-04-28 15:34:55 +1000 | [diff] [blame] | 267 | of_remove_property(node, of_find_property(node, kernel_end_prop.name, NULL)); |
Dale Farnsworth | 2e8e4f5 | 2008-12-16 06:22:59 +0000 | [diff] [blame] | 268 | |
| 269 | /* information needed by userspace when using default_machine_kexec */ |
Anton Blanchard | ea961a8 | 2014-01-22 08:40:28 +1100 | [diff] [blame] | 270 | kernel_end = cpu_to_be_ulong(__pa(_end)); |
Nathan Fontenot | 79d1c71 | 2012-10-02 16:58:46 +0000 | [diff] [blame] | 271 | of_add_property(node, &kernel_end_prop); |
Dale Farnsworth | 2e8e4f5 | 2008-12-16 06:22:59 +0000 | [diff] [blame] | 272 | |
Dale Farnsworth | 6f29c32 | 2008-12-17 10:09:06 +0000 | [diff] [blame] | 273 | export_crashk_values(node); |
| 274 | |
Dale Farnsworth | 2e8e4f5 | 2008-12-16 06:22:59 +0000 | [diff] [blame] | 275 | of_node_put(node); |
| 276 | return 0; |
| 277 | } |
| 278 | late_initcall(kexec_setup); |