1 #ifndef _LINUX_SUSPEND_H 2 #define _LINUX_SUSPEND_H 3 4 #include <linux/swap.h> 5 #include <linux/notifier.h> 6 #include <linux/init.h> 7 #include <linux/pm.h> 8 #include <linux/mm.h> 9 #include <linux/freezer.h> 10 #include <asm/errno.h> 11 12 #ifdef CONFIG_VT 13 extern void pm_set_vt_switch(int); 14 #else 15 static inline void pm_set_vt_switch(int do_switch) 16 { 17 } 18 #endif 19 20 #ifdef CONFIG_VT_CONSOLE_SLEEP 21 extern void pm_prepare_console(void); 22 extern void pm_restore_console(void); 23 #else 24 static inline void pm_prepare_console(void) 25 { 26 } 27 28 static inline void pm_restore_console(void) 29 { 30 } 31 #endif 32 33 typedef int __bitwise suspend_state_t; 34 35 #define PM_SUSPEND_ON ((__force suspend_state_t) 0) 36 #define PM_SUSPEND_FREEZE ((__force suspend_state_t) 1) 37 #define PM_SUSPEND_STANDBY ((__force suspend_state_t) 2) 38 #define PM_SUSPEND_MEM ((__force suspend_state_t) 3) 39 #define PM_SUSPEND_MIN PM_SUSPEND_FREEZE 40 #define PM_SUSPEND_MAX ((__force suspend_state_t) 4) 41 42 enum suspend_stat_step { 43 SUSPEND_FREEZE = 1, 44 SUSPEND_PREPARE, 45 SUSPEND_SUSPEND, 46 SUSPEND_SUSPEND_LATE, 47 SUSPEND_SUSPEND_NOIRQ, 48 SUSPEND_RESUME_NOIRQ, 49 SUSPEND_RESUME_EARLY, 50 SUSPEND_RESUME 51 }; 52 53 struct suspend_stats { 54 int success; 55 int fail; 56 int failed_freeze; 57 int failed_prepare; 58 int failed_suspend; 59 int failed_suspend_late; 60 int failed_suspend_noirq; 61 int failed_resume; 62 int failed_resume_early; 63 int failed_resume_noirq; 64 #define REC_FAILED_NUM 2 65 int last_failed_dev; 66 char failed_devs[REC_FAILED_NUM][40]; 67 int last_failed_errno; 68 int errno[REC_FAILED_NUM]; 69 int last_failed_step; 70 enum suspend_stat_step failed_steps[REC_FAILED_NUM]; 71 }; 72 73 extern struct suspend_stats suspend_stats; 74 75 static inline void dpm_save_failed_dev(const char *name) 76 { 77 strlcpy(suspend_stats.failed_devs[suspend_stats.last_failed_dev], 78 name, 79 sizeof(suspend_stats.failed_devs[0])); 80 suspend_stats.last_failed_dev++; 81 suspend_stats.last_failed_dev %= REC_FAILED_NUM; 82 } 83 84 static inline void dpm_save_failed_errno(int err) 85 { 86 suspend_stats.errno[suspend_stats.last_failed_errno] = err; 87 suspend_stats.last_failed_errno++; 88 suspend_stats.last_failed_errno %= REC_FAILED_NUM; 89 } 90 91 static inline void dpm_save_failed_step(enum suspend_stat_step step) 92 { 93 suspend_stats.failed_steps[suspend_stats.last_failed_step] = step; 94 suspend_stats.last_failed_step++; 95 suspend_stats.last_failed_step %= REC_FAILED_NUM; 96 } 97 98 /** 99 * struct platform_suspend_ops - Callbacks for managing platform dependent 100 * system sleep states. 101 * 102 * @valid: Callback to determine if given system sleep state is supported by 103 * the platform. 104 * Valid (ie. supported) states are advertised in /sys/power/state. Note 105 * that it still may be impossible to enter given system sleep state if the 106 * conditions aren't right. 107 * There is the %suspend_valid_only_mem function available that can be 108 * assigned to this if the platform only supports mem sleep. 109 * 110 * @begin: Initialise a transition to given system sleep state. 111 * @begin() is executed right prior to suspending devices. The information 112 * conveyed to the platform code by @begin() should be disregarded by it as 113 * soon as @end() is executed. If @begin() fails (ie. returns nonzero), 114 * @prepare(), @enter() and @finish() will not be called by the PM core. 115 * This callback is optional. However, if it is implemented, the argument 116 * passed to @enter() is redundant and should be ignored. 117 * 118 * @prepare: Prepare the platform for entering the system sleep state indicated 119 * by @begin(). 120 * @prepare() is called right after devices have been suspended (ie. the 121 * appropriate .suspend() method has been executed for each device) and 122 * before device drivers' late suspend callbacks are executed. It returns 123 * 0 on success or a negative error code otherwise, in which case the 124 * system cannot enter the desired sleep state (@prepare_late(), @enter(), 125 * and @wake() will not be called in that case). 126 * 127 * @prepare_late: Finish preparing the platform for entering the system sleep 128 * state indicated by @begin(). 129 * @prepare_late is called before disabling nonboot CPUs and after 130 * device drivers' late suspend callbacks have been executed. It returns 131 * 0 on success or a negative error code otherwise, in which case the 132 * system cannot enter the desired sleep state (@enter() will not be 133 * executed). 134 * 135 * @enter: Enter the system sleep state indicated by @begin() or represented by 136 * the argument if @begin() is not implemented. 137 * This callback is mandatory. It returns 0 on success or a negative 138 * error code otherwise, in which case the system cannot enter the desired 139 * sleep state. 140 * 141 * @wake: Called when the system has just left a sleep state, right after 142 * the nonboot CPUs have been enabled and before device drivers' early 143 * resume callbacks are executed. 144 * This callback is optional, but should be implemented by the platforms 145 * that implement @prepare_late(). If implemented, it is always called 146 * after @prepare_late and @enter(), even if one of them fails. 147 * 148 * @finish: Finish wake-up of the platform. 149 * @finish is called right prior to calling device drivers' regular suspend 150 * callbacks. 151 * This callback is optional, but should be implemented by the platforms 152 * that implement @prepare(). If implemented, it is always called after 153 * @enter() and @wake(), even if any of them fails. It is executed after 154 * a failing @prepare. 155 * 156 * @suspend_again: Returns whether the system should suspend again (true) or 157 * not (false). If the platform wants to poll sensors or execute some 158 * code during suspended without invoking userspace and most of devices, 159 * suspend_again callback is the place assuming that periodic-wakeup or 160 * alarm-wakeup is already setup. This allows to execute some codes while 161 * being kept suspended in the view of userland and devices. 162 * 163 * @end: Called by the PM core right after resuming devices, to indicate to 164 * the platform that the system has returned to the working state or 165 * the transition to the sleep state has been aborted. 166 * This callback is optional, but should be implemented by the platforms 167 * that implement @begin(). Accordingly, platforms implementing @begin() 168 * should also provide a @end() which cleans up transitions aborted before 169 * @enter(). 170 * 171 * @recover: Recover the platform from a suspend failure. 172 * Called by the PM core if the suspending of devices fails. 173 * This callback is optional and should only be implemented by platforms 174 * which require special recovery actions in that situation. 175 */ 176 struct platform_suspend_ops { 177 int (*valid)(suspend_state_t state); 178 int (*begin)(suspend_state_t state); 179 int (*prepare)(void); 180 int (*prepare_late)(void); 181 int (*enter)(suspend_state_t state); 182 void (*wake)(void); 183 void (*finish)(void); 184 bool (*suspend_again)(void); 185 void (*end)(void); 186 void (*recover)(void); 187 }; 188 189 struct platform_freeze_ops { 190 int (*begin)(void); 191 int (*prepare)(void); 192 void (*wake)(void); 193 void (*sync)(void); 194 void (*restore)(void); 195 void (*end)(void); 196 }; 197 198 #ifdef CONFIG_SUSPEND 199 /** 200 * suspend_set_ops - set platform dependent suspend operations 201 * @ops: The new suspend operations to set. 202 */ 203 extern void suspend_set_ops(const struct platform_suspend_ops *ops); 204 extern int suspend_valid_only_mem(suspend_state_t state); 205 206 extern unsigned int pm_suspend_global_flags; 207 208 #define PM_SUSPEND_FLAG_FW_SUSPEND (1 << 0) 209 #define PM_SUSPEND_FLAG_FW_RESUME (1 << 1) 210 211 static inline void pm_suspend_clear_flags(void) 212 { 213 pm_suspend_global_flags = 0; 214 } 215 216 static inline void pm_set_suspend_via_firmware(void) 217 { 218 pm_suspend_global_flags |= PM_SUSPEND_FLAG_FW_SUSPEND; 219 } 220 221 static inline void pm_set_resume_via_firmware(void) 222 { 223 pm_suspend_global_flags |= PM_SUSPEND_FLAG_FW_RESUME; 224 } 225 226 static inline bool pm_suspend_via_firmware(void) 227 { 228 return !!(pm_suspend_global_flags & PM_SUSPEND_FLAG_FW_SUSPEND); 229 } 230 231 static inline bool pm_resume_via_firmware(void) 232 { 233 return !!(pm_suspend_global_flags & PM_SUSPEND_FLAG_FW_RESUME); 234 } 235 236 /* Suspend-to-idle state machnine. */ 237 enum freeze_state { 238 FREEZE_STATE_NONE, /* Not suspended/suspending. */ 239 FREEZE_STATE_ENTER, /* Enter suspend-to-idle. */ 240 FREEZE_STATE_WAKE, /* Wake up from suspend-to-idle. */ 241 }; 242 243 extern enum freeze_state __read_mostly suspend_freeze_state; 244 245 static inline bool idle_should_freeze(void) 246 { 247 return unlikely(suspend_freeze_state == FREEZE_STATE_ENTER); 248 } 249 250 extern void __init pm_states_init(void); 251 extern void freeze_set_ops(const struct platform_freeze_ops *ops); 252 extern void freeze_wake(void); 253 254 /** 255 * arch_suspend_disable_irqs - disable IRQs for suspend 256 * 257 * Disables IRQs (in the default case). This is a weak symbol in the common 258 * code and thus allows architectures to override it if more needs to be 259 * done. Not called for suspend to disk. 260 */ 261 extern void arch_suspend_disable_irqs(void); 262 263 /** 264 * arch_suspend_enable_irqs - enable IRQs after suspend 265 * 266 * Enables IRQs (in the default case). This is a weak symbol in the common 267 * code and thus allows architectures to override it if more needs to be 268 * done. Not called for suspend to disk. 269 */ 270 extern void arch_suspend_enable_irqs(void); 271 272 extern int pm_suspend(suspend_state_t state); 273 #else /* !CONFIG_SUSPEND */ 274 #define suspend_valid_only_mem NULL 275 276 static inline void pm_suspend_clear_flags(void) {} 277 static inline void pm_set_suspend_via_firmware(void) {} 278 static inline void pm_set_resume_via_firmware(void) {} 279 static inline bool pm_suspend_via_firmware(void) { return false; } 280 static inline bool pm_resume_via_firmware(void) { return false; } 281 282 static inline void suspend_set_ops(const struct platform_suspend_ops *ops) {} 283 static inline int pm_suspend(suspend_state_t state) { return -ENOSYS; } 284 static inline bool idle_should_freeze(void) { return false; } 285 static inline void __init pm_states_init(void) {} 286 static inline void freeze_set_ops(const struct platform_freeze_ops *ops) {} 287 static inline void freeze_wake(void) {} 288 #endif /* !CONFIG_SUSPEND */ 289 290 /* struct pbe is used for creating lists of pages that should be restored 291 * atomically during the resume from disk, because the page frames they have 292 * occupied before the suspend are in use. 293 */ 294 struct pbe { 295 void *address; /* address of the copy */ 296 void *orig_address; /* original address of a page */ 297 struct pbe *next; 298 }; 299 300 /* mm/page_alloc.c */ 301 extern void mark_free_pages(struct zone *zone); 302 303 /** 304 * struct platform_hibernation_ops - hibernation platform support 305 * 306 * The methods in this structure allow a platform to carry out special 307 * operations required by it during a hibernation transition. 308 * 309 * All the methods below, except for @recover(), must be implemented. 310 * 311 * @begin: Tell the platform driver that we're starting hibernation. 312 * Called right after shrinking memory and before freezing devices. 313 * 314 * @end: Called by the PM core right after resuming devices, to indicate to 315 * the platform that the system has returned to the working state. 316 * 317 * @pre_snapshot: Prepare the platform for creating the hibernation image. 318 * Called right after devices have been frozen and before the nonboot 319 * CPUs are disabled (runs with IRQs on). 320 * 321 * @finish: Restore the previous state of the platform after the hibernation 322 * image has been created *or* put the platform into the normal operation 323 * mode after the hibernation (the same method is executed in both cases). 324 * Called right after the nonboot CPUs have been enabled and before 325 * thawing devices (runs with IRQs on). 326 * 327 * @prepare: Prepare the platform for entering the low power state. 328 * Called right after the hibernation image has been saved and before 329 * devices are prepared for entering the low power state. 330 * 331 * @enter: Put the system into the low power state after the hibernation image 332 * has been saved to disk. 333 * Called after the nonboot CPUs have been disabled and all of the low 334 * level devices have been shut down (runs with IRQs off). 335 * 336 * @leave: Perform the first stage of the cleanup after the system sleep state 337 * indicated by @set_target() has been left. 338 * Called right after the control has been passed from the boot kernel to 339 * the image kernel, before the nonboot CPUs are enabled and before devices 340 * are resumed. Executed with interrupts disabled. 341 * 342 * @pre_restore: Prepare system for the restoration from a hibernation image. 343 * Called right after devices have been frozen and before the nonboot 344 * CPUs are disabled (runs with IRQs on). 345 * 346 * @restore_cleanup: Clean up after a failing image restoration. 347 * Called right after the nonboot CPUs have been enabled and before 348 * thawing devices (runs with IRQs on). 349 * 350 * @recover: Recover the platform from a failure to suspend devices. 351 * Called by the PM core if the suspending of devices during hibernation 352 * fails. This callback is optional and should only be implemented by 353 * platforms which require special recovery actions in that situation. 354 */ 355 struct platform_hibernation_ops { 356 int (*begin)(void); 357 void (*end)(void); 358 int (*pre_snapshot)(void); 359 void (*finish)(void); 360 int (*prepare)(void); 361 int (*enter)(void); 362 void (*leave)(void); 363 int (*pre_restore)(void); 364 void (*restore_cleanup)(void); 365 void (*recover)(void); 366 }; 367 368 #ifdef CONFIG_HIBERNATION 369 /* kernel/power/snapshot.c */ 370 extern void __register_nosave_region(unsigned long b, unsigned long e, int km); 371 static inline void __init register_nosave_region(unsigned long b, unsigned long e) 372 { 373 __register_nosave_region(b, e, 0); 374 } 375 static inline void __init register_nosave_region_late(unsigned long b, unsigned long e) 376 { 377 __register_nosave_region(b, e, 1); 378 } 379 extern int swsusp_page_is_forbidden(struct page *); 380 extern void swsusp_set_page_free(struct page *); 381 extern void swsusp_unset_page_free(struct page *); 382 extern unsigned long get_safe_page(gfp_t gfp_mask); 383 384 extern void hibernation_set_ops(const struct platform_hibernation_ops *ops); 385 extern int hibernate(void); 386 extern bool system_entering_hibernation(void); 387 extern bool hibernation_available(void); 388 asmlinkage int swsusp_save(void); 389 extern struct pbe *restore_pblist; 390 #else /* CONFIG_HIBERNATION */ 391 static inline void register_nosave_region(unsigned long b, unsigned long e) {} 392 static inline void register_nosave_region_late(unsigned long b, unsigned long e) {} 393 static inline int swsusp_page_is_forbidden(struct page *p) { return 0; } 394 static inline void swsusp_set_page_free(struct page *p) {} 395 static inline void swsusp_unset_page_free(struct page *p) {} 396 397 static inline void hibernation_set_ops(const struct platform_hibernation_ops *ops) {} 398 static inline int hibernate(void) { return -ENOSYS; } 399 static inline bool system_entering_hibernation(void) { return false; } 400 static inline bool hibernation_available(void) { return false; } 401 #endif /* CONFIG_HIBERNATION */ 402 403 /* Hibernation and suspend events */ 404 #define PM_HIBERNATION_PREPARE 0x0001 /* Going to hibernate */ 405 #define PM_POST_HIBERNATION 0x0002 /* Hibernation finished */ 406 #define PM_SUSPEND_PREPARE 0x0003 /* Going to suspend the system */ 407 #define PM_POST_SUSPEND 0x0004 /* Suspend finished */ 408 #define PM_RESTORE_PREPARE 0x0005 /* Going to restore a saved image */ 409 #define PM_POST_RESTORE 0x0006 /* Restore failed */ 410 411 extern struct mutex pm_mutex; 412 413 #ifdef CONFIG_PM_SLEEP 414 void save_processor_state(void); 415 void restore_processor_state(void); 416 417 /* kernel/power/main.c */ 418 extern int register_pm_notifier(struct notifier_block *nb); 419 extern int unregister_pm_notifier(struct notifier_block *nb); 420 421 #define pm_notifier(fn, pri) { \ 422 static struct notifier_block fn##_nb = \ 423 { .notifier_call = fn, .priority = pri }; \ 424 register_pm_notifier(&fn##_nb); \ 425 } 426 427 /* drivers/base/power/wakeup.c */ 428 extern bool events_check_enabled; 429 extern unsigned int pm_wakeup_irq; 430 431 extern bool pm_wakeup_pending(void); 432 extern void pm_system_wakeup(void); 433 extern void pm_system_cancel_wakeup(void); 434 extern void pm_wakeup_clear(bool reset); 435 extern void pm_system_irq_wakeup(unsigned int irq_number); 436 extern bool pm_get_wakeup_count(unsigned int *count, bool block); 437 extern bool pm_save_wakeup_count(unsigned int count); 438 extern void pm_wakep_autosleep_enabled(bool set); 439 extern void pm_print_active_wakeup_sources(void); 440 441 static inline void lock_system_sleep(void) 442 { 443 current->flags |= PF_FREEZER_SKIP; 444 mutex_lock(&pm_mutex); 445 } 446 447 static inline void unlock_system_sleep(void) 448 { 449 /* 450 * Don't use freezer_count() because we don't want the call to 451 * try_to_freeze() here. 452 * 453 * Reason: 454 * Fundamentally, we just don't need it, because freezing condition 455 * doesn't come into effect until we release the pm_mutex lock, 456 * since the freezer always works with pm_mutex held. 457 * 458 * More importantly, in the case of hibernation, 459 * unlock_system_sleep() gets called in snapshot_read() and 460 * snapshot_write() when the freezing condition is still in effect. 461 * Which means, if we use try_to_freeze() here, it would make them 462 * enter the refrigerator, thus causing hibernation to lockup. 463 */ 464 current->flags &= ~PF_FREEZER_SKIP; 465 mutex_unlock(&pm_mutex); 466 } 467 468 #else /* !CONFIG_PM_SLEEP */ 469 470 static inline int register_pm_notifier(struct notifier_block *nb) 471 { 472 return 0; 473 } 474 475 static inline int unregister_pm_notifier(struct notifier_block *nb) 476 { 477 return 0; 478 } 479 480 #define pm_notifier(fn, pri) do { (void)(fn); } while (0) 481 482 static inline bool pm_wakeup_pending(void) { return false; } 483 static inline void pm_system_wakeup(void) {} 484 static inline void pm_wakeup_clear(bool reset) {} 485 static inline void pm_system_irq_wakeup(unsigned int irq_number) {} 486 487 static inline void lock_system_sleep(void) {} 488 static inline void unlock_system_sleep(void) {} 489 490 #endif /* !CONFIG_PM_SLEEP */ 491 492 #ifdef CONFIG_PM_SLEEP_DEBUG 493 extern bool pm_print_times_enabled; 494 #else 495 #define pm_print_times_enabled (false) 496 #endif 497 498 #ifdef CONFIG_PM_AUTOSLEEP 499 500 /* kernel/power/autosleep.c */ 501 void queue_up_suspend_work(void); 502 503 #else /* !CONFIG_PM_AUTOSLEEP */ 504 505 static inline void queue_up_suspend_work(void) {} 506 507 #endif /* !CONFIG_PM_AUTOSLEEP */ 508 509 #ifdef CONFIG_ARCH_SAVE_PAGE_KEYS 510 /* 511 * The ARCH_SAVE_PAGE_KEYS functions can be used by an architecture 512 * to save/restore additional information to/from the array of page 513 * frame numbers in the hibernation image. For s390 this is used to 514 * save and restore the storage key for each page that is included 515 * in the hibernation image. 516 */ 517 unsigned long page_key_additional_pages(unsigned long pages); 518 int page_key_alloc(unsigned long pages); 519 void page_key_free(void); 520 void page_key_read(unsigned long *pfn); 521 void page_key_memorize(unsigned long *pfn); 522 void page_key_write(void *address); 523 524 #else /* !CONFIG_ARCH_SAVE_PAGE_KEYS */ 525 526 static inline unsigned long page_key_additional_pages(unsigned long pages) 527 { 528 return 0; 529 } 530 531 static inline int page_key_alloc(unsigned long pages) 532 { 533 return 0; 534 } 535 536 static inline void page_key_free(void) {} 537 static inline void page_key_read(unsigned long *pfn) {} 538 static inline void page_key_memorize(unsigned long *pfn) {} 539 static inline void page_key_write(void *address) {} 540 541 #endif /* !CONFIG_ARCH_SAVE_PAGE_KEYS */ 542 543 #endif /* _LINUX_SUSPEND_H */ 544