1 /* SPDX-License-Identifier: GPL-2.0 */ 2 #ifndef _LINUX_REBOOT_H 3 #define _LINUX_REBOOT_H 4 5 6 #include <linux/notifier.h> 7 #include <uapi/linux/reboot.h> 8 9 struct device; 10 struct sys_off_handler; 11 12 #define SYS_DOWN 0x0001 /* Notify of system down */ 13 #define SYS_RESTART SYS_DOWN 14 #define SYS_HALT 0x0002 /* Notify of system halt */ 15 #define SYS_POWER_OFF 0x0003 /* Notify of system power off */ 16 17 enum reboot_mode { 18 REBOOT_UNDEFINED = -1, 19 REBOOT_COLD = 0, 20 REBOOT_WARM, 21 REBOOT_HARD, 22 REBOOT_SOFT, 23 REBOOT_GPIO, 24 }; 25 extern enum reboot_mode reboot_mode; 26 extern enum reboot_mode panic_reboot_mode; 27 28 enum reboot_type { 29 BOOT_TRIPLE = 't', 30 BOOT_KBD = 'k', 31 BOOT_BIOS = 'b', 32 BOOT_ACPI = 'a', 33 BOOT_EFI = 'e', 34 BOOT_CF9_FORCE = 'p', 35 BOOT_CF9_SAFE = 'q', 36 }; 37 extern enum reboot_type reboot_type; 38 39 extern int reboot_default; 40 extern int reboot_cpu; 41 extern int reboot_force; 42 43 44 extern int register_reboot_notifier(struct notifier_block *); 45 extern int unregister_reboot_notifier(struct notifier_block *); 46 47 extern int devm_register_reboot_notifier(struct device *, struct notifier_block *); 48 49 extern int register_restart_handler(struct notifier_block *); 50 extern int unregister_restart_handler(struct notifier_block *); 51 extern void do_kernel_restart(char *cmd); 52 53 /* 54 * Architecture-specific implementations of sys_reboot commands. 55 */ 56 57 extern void migrate_to_reboot_cpu(void); 58 extern void machine_restart(char *cmd); 59 extern void machine_halt(void); 60 extern void machine_power_off(void); 61 62 extern void machine_shutdown(void); 63 struct pt_regs; 64 extern void machine_crash_shutdown(struct pt_regs *); 65 66 void do_kernel_power_off(void); 67 68 /* 69 * sys-off handler API. 70 */ 71 72 /* 73 * Standard sys-off priority levels. Users are expected to set priorities 74 * relative to the standard levels. 75 * 76 * SYS_OFF_PRIO_PLATFORM: Use this for platform-level handlers. 77 * 78 * SYS_OFF_PRIO_LOW: Use this for handler of last resort. 79 * 80 * SYS_OFF_PRIO_DEFAULT: Use this for normal handlers. 81 * 82 * SYS_OFF_PRIO_HIGH: Use this for higher priority handlers. 83 * 84 * SYS_OFF_PRIO_FIRMWARE: Use this if handler uses firmware call. 85 */ 86 #define SYS_OFF_PRIO_PLATFORM -256 87 #define SYS_OFF_PRIO_LOW -128 88 #define SYS_OFF_PRIO_DEFAULT 0 89 #define SYS_OFF_PRIO_HIGH 192 90 #define SYS_OFF_PRIO_FIRMWARE 224 91 92 enum sys_off_mode { 93 /** 94 * @SYS_OFF_MODE_POWER_OFF_PREPARE: 95 * 96 * Handlers prepare system to be powered off. Handlers are 97 * allowed to sleep. 98 */ 99 SYS_OFF_MODE_POWER_OFF_PREPARE, 100 101 /** 102 * @SYS_OFF_MODE_POWER_OFF: 103 * 104 * Handlers power-off system. Handlers are disallowed to sleep. 105 */ 106 SYS_OFF_MODE_POWER_OFF, 107 108 /** 109 * @SYS_OFF_MODE_RESTART_PREPARE: 110 * 111 * Handlers prepare system to be restarted. Handlers are 112 * allowed to sleep. 113 */ 114 SYS_OFF_MODE_RESTART_PREPARE, 115 116 /** 117 * @SYS_OFF_MODE_RESTART: 118 * 119 * Handlers restart system. Handlers are disallowed to sleep. 120 */ 121 SYS_OFF_MODE_RESTART, 122 }; 123 124 /** 125 * struct sys_off_data - sys-off callback argument 126 * 127 * @mode: Mode ID. Currently used only by the sys-off restart mode, 128 * see enum reboot_mode for the available modes. 129 * @cb_data: User's callback data. 130 * @cmd: Command string. Currently used only by the sys-off restart mode, 131 * NULL otherwise. 132 * @dev: Device of the sys-off handler. Only if known (devm_register_*), 133 * NULL otherwise. 134 */ 135 struct sys_off_data { 136 int mode; 137 void *cb_data; 138 const char *cmd; 139 struct device *dev; 140 }; 141 142 struct sys_off_handler * 143 register_sys_off_handler(enum sys_off_mode mode, 144 int priority, 145 int (*callback)(struct sys_off_data *data), 146 void *cb_data); 147 void unregister_sys_off_handler(struct sys_off_handler *handler); 148 149 int devm_register_sys_off_handler(struct device *dev, 150 enum sys_off_mode mode, 151 int priority, 152 int (*callback)(struct sys_off_data *data), 153 void *cb_data); 154 155 int devm_register_power_off_handler(struct device *dev, 156 int (*callback)(struct sys_off_data *data), 157 void *cb_data); 158 159 int devm_register_restart_handler(struct device *dev, 160 int (*callback)(struct sys_off_data *data), 161 void *cb_data); 162 163 int register_platform_power_off(void (*power_off)(void)); 164 void unregister_platform_power_off(void (*power_off)(void)); 165 166 /* 167 * Architecture independent implemenations of sys_reboot commands. 168 */ 169 170 extern void kernel_restart_prepare(char *cmd); 171 extern void kernel_restart(char *cmd); 172 extern void kernel_halt(void); 173 extern void kernel_power_off(void); 174 extern bool kernel_can_power_off(void); 175 176 void ctrl_alt_del(void); 177 178 extern void orderly_poweroff(bool force); 179 extern void orderly_reboot(void); 180 void __hw_protection_shutdown(const char *reason, int ms_until_forced, bool shutdown); 181 182 static inline void hw_protection_reboot(const char *reason, int ms_until_forced) 183 { 184 __hw_protection_shutdown(reason, ms_until_forced, false); 185 } 186 187 static inline void hw_protection_shutdown(const char *reason, int ms_until_forced) 188 { 189 __hw_protection_shutdown(reason, ms_until_forced, true); 190 } 191 192 /* 193 * Emergency restart, callable from an interrupt handler. 194 */ 195 196 extern void emergency_restart(void); 197 #include <asm/emergency-restart.h> 198 199 #endif /* _LINUX_REBOOT_H */ 200