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 /*
  67  * sys-off handler API.
  68  */
  69
  70 /*
  71  * Standard sys-off priority levels. Users are expected to set priorities
  72  * relative to the standard levels.
  73  *
  74  * SYS_OFF_PRIO_PLATFORM:       Use this for platform-level handlers.
  75  *
  76  * SYS_OFF_PRIO_LOW:            Use this for handler of last resort.
  77  *
  78  * SYS_OFF_PRIO_DEFAULT:        Use this for normal handlers.
  79  *
  80  * SYS_OFF_PRIO_HIGH:           Use this for higher priority handlers.
  81  *
  82  * SYS_OFF_PRIO_FIRMWARE:       Use this if handler uses firmware call.
  83  */
  84 #define SYS_OFF_PRIO_PLATFORM           -256
  85 #define SYS_OFF_PRIO_LOW                -128
  86 #define SYS_OFF_PRIO_DEFAULT            0
  87 #define SYS_OFF_PRIO_HIGH               192
  88 #define SYS_OFF_PRIO_FIRMWARE           224
  89
  90 enum sys_off_mode {
  91         /**
  92          * @SYS_OFF_MODE_POWER_OFF_PREPARE:
  93          *
  94          * Handlers prepare system to be powered off. Handlers are
  95          * allowed to sleep.
  96          */
  97         SYS_OFF_MODE_POWER_OFF_PREPARE,
  98
  99         /**
 100          * @SYS_OFF_MODE_POWER_OFF:
 101          *
 102          * Handlers power-off system. Handlers are disallowed to sleep.
 103          */
 104         SYS_OFF_MODE_POWER_OFF,
 105
 106         /**
 107          * @SYS_OFF_MODE_RESTART:
 108          *
 109          * Handlers restart system. Handlers are disallowed to sleep.
 110          */
 111         SYS_OFF_MODE_RESTART,
 112 };
 113
 114 /**
 115  * struct sys_off_data - sys-off callback argument
 116  *
 117  * @mode: Mode ID. Currently used only by the sys-off restart mode,
 118  *        see enum reboot_mode for the available modes.
 119  * @cb_data: User's callback data.
 120  * @cmd: Command string. Currently used only by the sys-off restart mode,
 121  *       NULL otherwise.
 122  */
 123 struct sys_off_data {
 124         int mode;
 125         void *cb_data;
 126         const char *cmd;
 127 };
 128
 129 struct sys_off_handler *
 130 register_sys_off_handler(enum sys_off_mode mode,
 131                          int priority,
 132                          int (*callback)(struct sys_off_data *data),
 133                          void *cb_data);
 134 void unregister_sys_off_handler(struct sys_off_handler *handler);
 135
 136 int devm_register_sys_off_handler(struct device *dev,
 137                                   enum sys_off_mode mode,
 138                                   int priority,
 139                                   int (*callback)(struct sys_off_data *data),
 140                                   void *cb_data);
 141
 142 /*
 143  * Architecture independent implemenations of sys_reboot commands.
 144  */
 145
 146 extern void kernel_restart_prepare(char *cmd);
 147 extern void kernel_restart(char *cmd);
 148 extern void kernel_halt(void);
 149 extern void kernel_power_off(void);
 150
 151 extern int C_A_D; /* for sysctl */
 152 void ctrl_alt_del(void);
 153
 154 #define POWEROFF_CMD_PATH_LEN   256
 155 extern char poweroff_cmd[POWEROFF_CMD_PATH_LEN];
 156
 157 extern void orderly_poweroff(bool force);
 158 extern void orderly_reboot(void);
 159 void hw_protection_shutdown(const char *reason, int ms_until_forced);
 160
 161 /*
 162  * Emergency restart, callable from an interrupt handler.
 163  */
 164
 165 extern void emergency_restart(void);
 166 #include <asm/emergency-restart.h>
 167
 168 #endif /* _LINUX_REBOOT_H */