1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 1996-2000 Russell King - Converted to ARM. 4 * Original Copyright (C) 1995 Linus Torvalds 5 */ 6 #include <linux/cpu.h> 7 #include <linux/delay.h> 8 #include <linux/reboot.h> 9 10 #include <asm/cacheflush.h> 11 #include <asm/idmap.h> 12 #include <asm/virt.h> 13 14 #include "reboot.h" 15 16 typedef void (*phys_reset_t)(unsigned long, bool); 17 18 /* 19 * Function pointers to optional machine specific functions 20 */ 21 void (*pm_power_off)(void); 22 EXPORT_SYMBOL(pm_power_off); 23 24 /* 25 * A temporary stack to use for CPU reset. This is static so that we 26 * don't clobber it with the identity mapping. When running with this 27 * stack, any references to the current task *will not work* so you 28 * should really do as little as possible before jumping to your reset 29 * code. 30 */ 31 static u64 soft_restart_stack[16]; 32 33 static void __soft_restart(void *addr) 34 { 35 phys_reset_t phys_reset; 36 37 /* Take out a flat memory mapping. */ 38 setup_mm_for_reboot(); 39 40 /* Clean and invalidate caches */ 41 flush_cache_all(); 42 43 /* Turn off caching */ 44 cpu_proc_fin(); 45 46 /* Push out any further dirty data, and ensure cache is empty */ 47 flush_cache_all(); 48 49 /* Switch to the identity mapping. */ 50 phys_reset = (phys_reset_t)virt_to_idmap(cpu_reset); 51 52 /* original stub should be restored by kvm */ 53 phys_reset((unsigned long)addr, is_hyp_mode_available()); 54 55 /* Should never get here. */ 56 BUG(); 57 } 58 59 void _soft_restart(unsigned long addr, bool disable_l2) 60 { 61 u64 *stack = soft_restart_stack + ARRAY_SIZE(soft_restart_stack); 62 63 /* Disable interrupts first */ 64 raw_local_irq_disable(); 65 local_fiq_disable(); 66 67 /* Disable the L2 if we're the last man standing. */ 68 if (disable_l2) 69 outer_disable(); 70 71 /* Change to the new stack and continue with the reset. */ 72 call_with_stack(__soft_restart, (void *)addr, (void *)stack); 73 74 /* Should never get here. */ 75 BUG(); 76 } 77 78 void soft_restart(unsigned long addr) 79 { 80 _soft_restart(addr, num_online_cpus() == 1); 81 } 82 83 /* 84 * Called by kexec, immediately prior to machine_kexec(). 85 * 86 * This must completely disable all secondary CPUs; simply causing those CPUs 87 * to execute e.g. a RAM-based pin loop is not sufficient. This allows the 88 * kexec'd kernel to use any and all RAM as it sees fit, without having to 89 * avoid any code or data used by any SW CPU pin loop. The CPU hotplug 90 * functionality embodied in smp_shutdown_nonboot_cpus() to achieve this. 91 */ 92 void machine_shutdown(void) 93 { 94 smp_shutdown_nonboot_cpus(reboot_cpu); 95 } 96 97 /* 98 * Halting simply requires that the secondary CPUs stop performing any 99 * activity (executing tasks, handling interrupts). smp_send_stop() 100 * achieves this. 101 */ 102 void machine_halt(void) 103 { 104 local_irq_disable(); 105 smp_send_stop(); 106 while (1); 107 } 108 109 /* 110 * Power-off simply requires that the secondary CPUs stop performing any 111 * activity (executing tasks, handling interrupts). smp_send_stop() 112 * achieves this. When the system power is turned off, it will take all CPUs 113 * with it. 114 */ 115 void machine_power_off(void) 116 { 117 local_irq_disable(); 118 smp_send_stop(); 119 do_kernel_power_off(); 120 } 121 122 /* 123 * Restart requires that the secondary CPUs stop performing any activity 124 * while the primary CPU resets the system. Systems with a single CPU can 125 * use soft_restart() as their machine descriptor's .restart hook, since that 126 * will cause the only available CPU to reset. Systems with multiple CPUs must 127 * provide a HW restart implementation, to ensure that all CPUs reset at once. 128 * This is required so that any code running after reset on the primary CPU 129 * doesn't have to co-ordinate with other CPUs to ensure they aren't still 130 * executing pre-reset code, and using RAM that the primary CPU's code wishes 131 * to use. Implementing such co-ordination would be essentially impossible. 132 */ 133 void machine_restart(char *cmd) 134 { 135 local_irq_disable(); 136 smp_send_stop(); 137 138 do_kernel_restart(cmd); 139 140 /* Give a grace period for failure to restart of 1s */ 141 mdelay(1000); 142 143 /* Whoops - the platform was unable to reboot. Tell the user! */ 144 printk("Reboot failed -- System halted\n"); 145 while (1); 146 } 147