1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * Copyright (C) 2019 FORTH-ICS/CARV
  4 *  Nick Kossifidis <mick@ics.forth.gr>
  5 */
  6
  7#include <linux/kexec.h>
  8#include <asm/kexec.h>		/* For riscv_kexec_* symbol defines */
  9#include <linux/smp.h>		/* For smp_send_stop () */
 10#include <asm/cacheflush.h>	/* For local_flush_icache_all() */
 11#include <asm/barrier.h>	/* For smp_wmb() */
 12#include <asm/page.h>		/* For PAGE_MASK */
 13#include <linux/libfdt.h>	/* For fdt_check_header() */
 14#include <asm/set_memory.h>	/* For set_memory_x() */
 15#include <linux/compiler.h>	/* For unreachable() */
 16#include <linux/cpu.h>		/* For cpu_down() */
 17#include <linux/reboot.h>
 18
 19/*
 20 * kexec_image_info - Print received image details
 21 */
 22static void
 23kexec_image_info(const struct kimage *image)
 24{
 25	unsigned long i;
 26
 27	pr_debug("Kexec image info:\n");
 28	pr_debug("\ttype:        %d\n", image->type);
 29	pr_debug("\tstart:       %lx\n", image->start);
 30	pr_debug("\thead:        %lx\n", image->head);
 31	pr_debug("\tnr_segments: %lu\n", image->nr_segments);
 32
 33	for (i = 0; i < image->nr_segments; i++) {
 34		pr_debug("\t    segment[%lu]: %016lx - %016lx", i,
 35			image->segment[i].mem,
 36			image->segment[i].mem + image->segment[i].memsz);
 37		pr_debug("\t\t0x%lx bytes, %lu pages\n",
 38			(unsigned long) image->segment[i].memsz,
 39			(unsigned long) image->segment[i].memsz /  PAGE_SIZE);
 40	}
 41}
 42
 43/*
 44 * machine_kexec_prepare - Initialize kexec
 45 *
 46 * This function is called from do_kexec_load, when the user has
 47 * provided us with an image to be loaded. Its goal is to validate
 48 * the image and prepare the control code buffer as needed.
 49 * Note that kimage_alloc_init has already been called and the
 50 * control buffer has already been allocated.
 51 */
 52int
 53machine_kexec_prepare(struct kimage *image)
 54{
 55	struct kimage_arch *internal = &image->arch;
 56	struct fdt_header fdt = {0};
 57	void *control_code_buffer = NULL;
 58	unsigned int control_code_buffer_sz = 0;
 59	int i = 0;
 60
 61	kexec_image_info(image);
 62
 63	/* Find the Flattened Device Tree and save its physical address */
 64	for (i = 0; i < image->nr_segments; i++) {
 65		if (image->segment[i].memsz <= sizeof(fdt))
 66			continue;
 67
 68		if (copy_from_user(&fdt, image->segment[i].buf, sizeof(fdt)))
 69			continue;
 70
 71		if (fdt_check_header(&fdt))
 72			continue;
 73
 74		internal->fdt_addr = (unsigned long) image->segment[i].mem;
 75		break;
 76	}
 77
 78	if (!internal->fdt_addr) {
 79		pr_err("Device tree not included in the provided image\n");
 80		return -EINVAL;
 81	}
 82
 83	/* Copy the assembler code for relocation to the control page */
 84	if (image->type != KEXEC_TYPE_CRASH) {
 85		control_code_buffer = page_address(image->control_code_page);
 86		control_code_buffer_sz = page_size(image->control_code_page);
 87
 88		if (unlikely(riscv_kexec_relocate_size > control_code_buffer_sz)) {
 89			pr_err("Relocation code doesn't fit within a control page\n");
 90			return -EINVAL;
 91		}
 92
 93		memcpy(control_code_buffer, riscv_kexec_relocate,
 94			riscv_kexec_relocate_size);
 95
 96		/* Mark the control page executable */
 97		set_memory_x((unsigned long) control_code_buffer, 1);
 98	}
 99
100	return 0;
101}
102
103
104/*
105 * machine_kexec_cleanup - Cleanup any leftovers from
106 *			   machine_kexec_prepare
107 *
108 * This function is called by kimage_free to handle any arch-specific
109 * allocations done on machine_kexec_prepare. Since we didn't do any
110 * allocations there, this is just an empty function. Note that the
111 * control buffer is freed by kimage_free.
112 */
113void
114machine_kexec_cleanup(struct kimage *image)
115{
116}
117
118
119/*
120 * machine_shutdown - Prepare for a kexec reboot
121 *
122 * This function is called by kernel_kexec just before machine_kexec
123 * below. Its goal is to prepare the rest of the system (the other
124 * harts and possibly devices etc) for a kexec reboot.
125 */
126void machine_shutdown(void)
127{
128	/*
129	 * No more interrupts on this hart
130	 * until we are back up.
131	 */
132	local_irq_disable();
133
134#if defined(CONFIG_HOTPLUG_CPU)
135	smp_shutdown_nonboot_cpus(smp_processor_id());
136#endif
137}
138
139/*
140 * machine_crash_shutdown - Prepare to kexec after a kernel crash
141 *
142 * This function is called by crash_kexec just before machine_kexec
143 * below and its goal is similar to machine_shutdown, but in case of
144 * a kernel crash. Since we don't handle such cases yet, this function
145 * is empty.
146 */
147void
148machine_crash_shutdown(struct pt_regs *regs)
149{
150	crash_save_cpu(regs, smp_processor_id());
151	machine_shutdown();
152	pr_info("Starting crashdump kernel...\n");
153}
154
155/*
156 * machine_kexec - Jump to the loaded kimage
157 *
158 * This function is called by kernel_kexec which is called by the
159 * reboot system call when the reboot cmd is LINUX_REBOOT_CMD_KEXEC,
160 * or by crash_kernel which is called by the kernel's arch-specific
161 * trap handler in case of a kernel panic. It's the final stage of
162 * the kexec process where the pre-loaded kimage is ready to be
163 * executed. We assume at this point that all other harts are
164 * suspended and this hart will be the new boot hart.
165 */
166void __noreturn
167machine_kexec(struct kimage *image)
168{
169	struct kimage_arch *internal = &image->arch;
170	unsigned long jump_addr = (unsigned long) image->start;
171	unsigned long first_ind_entry = (unsigned long) &image->head;
172	unsigned long this_hart_id = raw_smp_processor_id();
173	unsigned long fdt_addr = internal->fdt_addr;
174	void *control_code_buffer = page_address(image->control_code_page);
175	riscv_kexec_method kexec_method = NULL;
176
177	if (image->type != KEXEC_TYPE_CRASH)
178		kexec_method = control_code_buffer;
179	else
180		kexec_method = (riscv_kexec_method) &riscv_kexec_norelocate;
181
182	pr_notice("Will call new kernel at %08lx from hart id %lx\n",
183		  jump_addr, this_hart_id);
184	pr_notice("FDT image at %08lx\n", fdt_addr);
185
186	/* Make sure the relocation code is visible to the hart */
187	local_flush_icache_all();
188
189	/* Jump to the relocation code */
190	pr_notice("Bye...\n");
191	kexec_method(first_ind_entry, jump_addr, fdt_addr,
192		     this_hart_id, kernel_map.va_pa_offset);
193	unreachable();
194}