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:
 110          *
 111          * Handlers restart system. Handlers are disallowed to sleep.
 112          */
 113         SYS_OFF_MODE_RESTART,
 114 };
 115
 116 /**
 117  * struct sys_off_data - sys-off callback argument
 118  *
 119  * @mode: Mode ID. Currently used only by the sys-off restart mode,
 120  *        see enum reboot_mode for the available modes.
 121  * @cb_data: User's callback data.
 122  * @cmd: Command string. Currently used only by the sys-off restart mode,
 123  *       NULL otherwise.
 124  */
 125 struct sys_off_data {
 126         int mode;
 127         void *cb_data;
 128         const char *cmd;
 129 };
 130
 131 struct sys_off_handler *
 132 register_sys_off_handler(enum sys_off_mode mode,
 133                          int priority,
 134                          int (*callback)(struct sys_off_data *data),
 135                          void *cb_data);
 136 void unregister_sys_off_handler(struct sys_off_handler *handler);
 137
 138 int devm_register_sys_off_handler(struct device *dev,
 139                                   enum sys_off_mode mode,
 140                                   int priority,
 141                                   int (*callback)(struct sys_off_data *data),
 142                                   void *cb_data);
 143
 144 int devm_register_power_off_handler(struct device *dev,
 145                                     int (*callback)(struct sys_off_data *data),
 146                                     void *cb_data);
 147
 148 int devm_register_restart_handler(struct device *dev,
 149                                   int (*callback)(struct sys_off_data *data),
 150                                   void *cb_data);
 151
 152 int register_platform_power_off(void (*power_off)(void));
 153 void unregister_platform_power_off(void (*power_off)(void));
 154
 155 /*
 156  * Architecture independent implemenations of sys_reboot commands.
 157  */
 158
 159 extern void kernel_restart_prepare(char *cmd);
 160 extern void kernel_restart(char *cmd);
 161 extern void kernel_halt(void);
 162 extern void kernel_power_off(void);
 163 extern bool kernel_can_power_off(void);
 164
 165 void ctrl_alt_del(void);
 166
 167 extern void orderly_poweroff(bool force);
 168 extern void orderly_reboot(void);
 169 void hw_protection_shutdown(const char *reason, int ms_until_forced);
 170
 171 /*
 172  * Emergency restart, callable from an interrupt handler.
 173  */
 174
 175 extern void emergency_restart(void);
 176 #include <asm/emergency-restart.h>
 177
 178 #endif /* _LINUX_REBOOT_H */