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