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 */ 133 struct sys_off_data { 134 int mode; 135 void *cb_data; 136 const char *cmd; 137 }; 138 139 struct sys_off_handler * 140 register_sys_off_handler(enum sys_off_mode mode, 141 int priority, 142 int (*callback)(struct sys_off_data *data), 143 void *cb_data); 144 void unregister_sys_off_handler(struct sys_off_handler *handler); 145 146 int devm_register_sys_off_handler(struct device *dev, 147 enum sys_off_mode mode, 148 int priority, 149 int (*callback)(struct sys_off_data *data), 150 void *cb_data); 151 152 int devm_register_power_off_handler(struct device *dev, 153 int (*callback)(struct sys_off_data *data), 154 void *cb_data); 155 156 int devm_register_restart_handler(struct device *dev, 157 int (*callback)(struct sys_off_data *data), 158 void *cb_data); 159 160 int register_platform_power_off(void (*power_off)(void)); 161 void unregister_platform_power_off(void (*power_off)(void)); 162 163 /* 164 * Architecture independent implemenations of sys_reboot commands. 165 */ 166 167 extern void kernel_restart_prepare(char *cmd); 168 extern void kernel_restart(char *cmd); 169 extern void kernel_halt(void); 170 extern void kernel_power_off(void); 171 extern bool kernel_can_power_off(void); 172 173 void ctrl_alt_del(void); 174 175 extern void orderly_poweroff(bool force); 176 extern void orderly_reboot(void); 177 void hw_protection_shutdown(const char *reason, int ms_until_forced); 178 179 /* 180 * Emergency restart, callable from an interrupt handler. 181 */ 182 183 extern void emergency_restart(void); 184 #include <asm/emergency-restart.h> 185 186 #endif /* _LINUX_REBOOT_H */ 187