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#include <linux/interrupt.h>
 19#include <linux/irq.h>
 20
 21/*
 22 * machine_kexec_prepare - Initialize kexec
 23 *
 24 * This function is called from do_kexec_load, when the user has
 25 * provided us with an image to be loaded. Its goal is to validate
 26 * the image and prepare the control code buffer as needed.
 27 * Note that kimage_alloc_init has already been called and the
 28 * control buffer has already been allocated.
 29 */
 30int
 31machine_kexec_prepare(struct kimage *image)
 32{
 33	struct kimage_arch *internal = &image->arch;
 34	struct fdt_header fdt = {0};
 35	void *control_code_buffer = NULL;
 36	unsigned int control_code_buffer_sz = 0;
 37	int i = 0;
 38
 39	/* Find the Flattened Device Tree and save its physical address */
 40	for (i = 0; i < image->nr_segments; i++) {
 41		if (image->segment[i].memsz <= sizeof(fdt))
 42			continue;
 43
 44		if (image->file_mode)
 45			memcpy(&fdt, image->segment[i].buf, sizeof(fdt));
 46		else if (copy_from_user(&fdt, image->segment[i].buf, sizeof(fdt)))
 47			continue;
 48
 49		if (fdt_check_header(&fdt))
 50			continue;
 51
 52		internal->fdt_addr = (unsigned long) image->segment[i].mem;
 53		break;
 54	}
 55
 56	if (!internal->fdt_addr) {
 57		pr_err("Device tree not included in the provided image\n");
 58		return -EINVAL;
 59	}
 60
 61	/* Copy the assembler code for relocation to the control page */
 62	if (image->type != KEXEC_TYPE_CRASH) {
 63		control_code_buffer = page_address(image->control_code_page);
 64		control_code_buffer_sz = page_size(image->control_code_page);
 65
 66		if (unlikely(riscv_kexec_relocate_size > control_code_buffer_sz)) {
 67			pr_err("Relocation code doesn't fit within a control page\n");
 68			return -EINVAL;
 69		}
 70
 71		memcpy(control_code_buffer, riscv_kexec_relocate,
 72			riscv_kexec_relocate_size);
 73
 74		/* Mark the control page executable */
 75		set_memory_x((unsigned long) control_code_buffer, 1);
 76	}
 77
 78	return 0;
 79}
 80
 81
 82/*
 83 * machine_kexec_cleanup - Cleanup any leftovers from
 84 *			   machine_kexec_prepare
 85 *
 86 * This function is called by kimage_free to handle any arch-specific
 87 * allocations done on machine_kexec_prepare. Since we didn't do any
 88 * allocations there, this is just an empty function. Note that the
 89 * control buffer is freed by kimage_free.
 90 */
 91void
 92machine_kexec_cleanup(struct kimage *image)
 93{
 94}
 95
 96
 97/*
 98 * machine_shutdown - Prepare for a kexec reboot
 99 *
100 * This function is called by kernel_kexec just before machine_kexec
101 * below. Its goal is to prepare the rest of the system (the other
102 * harts and possibly devices etc) for a kexec reboot.
103 */
104void machine_shutdown(void)
105{
106	/*
107	 * No more interrupts on this hart
108	 * until we are back up.
109	 */
110	local_irq_disable();
111
112#if defined(CONFIG_HOTPLUG_CPU)
113	smp_shutdown_nonboot_cpus(smp_processor_id());
114#endif
115}
116
117static void machine_kexec_mask_interrupts(void)
118{
119	unsigned int i;
120	struct irq_desc *desc;
121
122	for_each_irq_desc(i, desc) {
123		struct irq_chip *chip;
124
125		chip = irq_desc_get_chip(desc);
126		if (!chip)
127			continue;
128
129		if (chip->irq_eoi && irqd_irq_inprogress(&desc->irq_data))
130			chip->irq_eoi(&desc->irq_data);
131
132		if (chip->irq_mask)
133			chip->irq_mask(&desc->irq_data);
134
135		if (chip->irq_disable && !irqd_irq_disabled(&desc->irq_data))
136			chip->irq_disable(&desc->irq_data);
137	}
138}
139
140/*
141 * machine_crash_shutdown - Prepare to kexec after a kernel crash
142 *
143 * This function is called by crash_kexec just before machine_kexec
144 * and its goal is to shutdown non-crashing cpus and save registers.
145 */
146void
147machine_crash_shutdown(struct pt_regs *regs)
148{
149	local_irq_disable();
150
151	/* shutdown non-crashing cpus */
152	crash_smp_send_stop();
153
154	crash_save_cpu(regs, smp_processor_id());
155	machine_kexec_mask_interrupts();
156
157	pr_info("Starting crashdump kernel...\n");
158}
159
160/*
161 * machine_kexec - Jump to the loaded kimage
162 *
163 * This function is called by kernel_kexec which is called by the
164 * reboot system call when the reboot cmd is LINUX_REBOOT_CMD_KEXEC,
165 * or by crash_kernel which is called by the kernel's arch-specific
166 * trap handler in case of a kernel panic. It's the final stage of
167 * the kexec process where the pre-loaded kimage is ready to be
168 * executed. We assume at this point that all other harts are
169 * suspended and this hart will be the new boot hart.
170 */
171void __noreturn
172machine_kexec(struct kimage *image)
173{
174	struct kimage_arch *internal = &image->arch;
175	unsigned long jump_addr = (unsigned long) image->start;
176	unsigned long first_ind_entry = (unsigned long) &image->head;
177	unsigned long this_cpu_id = __smp_processor_id();
178	unsigned long this_hart_id = cpuid_to_hartid_map(this_cpu_id);
179	unsigned long fdt_addr = internal->fdt_addr;
180	void *control_code_buffer = page_address(image->control_code_page);
181	riscv_kexec_method kexec_method = NULL;
182
183#ifdef CONFIG_SMP
184	WARN(smp_crash_stop_failed(),
185		"Some CPUs may be stale, kdump will be unreliable.\n");
186#endif
187
188	if (image->type != KEXEC_TYPE_CRASH)
189		kexec_method = control_code_buffer;
190	else
191		kexec_method = (riscv_kexec_method) &riscv_kexec_norelocate;
192
193	pr_notice("Will call new kernel at %08lx from hart id %lx\n",
194		  jump_addr, this_hart_id);
195	pr_notice("FDT image at %08lx\n", fdt_addr);
196
197	/* Make sure the relocation code is visible to the hart */
198	local_flush_icache_all();
199
200	/* Jump to the relocation code */
201	pr_notice("Bye...\n");
202	kexec_method(first_ind_entry, jump_addr, fdt_addr,
203		     this_hart_id, kernel_map.va_pa_offset);
204	unreachable();
205}