include/linux/reboot.h

   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 */