PM: introduce hibernation and suspend notifiers (b10d9117) · Commits · e / devices / android_kernel_xiaomi_markw

Documentation/power/notifiers.txt

0 → 100644

+50 −0

Original line number	Original line	Diff line number	Diff line
			Suspend notifiers
			(C) 2007 Rafael J. Wysocki <rjw@sisk.pl>, GPL

			There are some operations that device drivers may want to carry out in their
			.suspend() routines, but shouldn't, because they can cause the hibernation or
			suspend to fail. For example, a driver may want to allocate a substantial amount
			of memory (like 50 MB) in .suspend(), but that shouldn't be done after the
			swsusp's memory shrinker has run.

			Also, there may be some operations, that subsystems want to carry out before a
			hibernation/suspend or after a restore/resume, requiring the system to be fully
			functional, so the drivers' .suspend() and .resume() routines are not suitable
			for this purpose. For example, device drivers may want to upload firmware to
			their devices after a restore from a hibernation image, but they cannot do it by
			calling request_firmware() from their .resume() routines (user land processes
			are frozen at this point). The solution may be to load the firmware into
			memory before processes are frozen and upload it from there in the .resume()
			routine. Of course, a hibernation notifier may be used for this purpose.

			The subsystems that have such needs can register suspend notifiers that will be
			called upon the following events by the suspend core:

			PM_HIBERNATION_PREPARE The system is going to hibernate or suspend, tasks will
			be frozen immediately.

			PM_POST_HIBERNATION The system memory state has been restored from a
			hibernation image or an error occured during the
			hibernation. Device drivers' .resume() callbacks have
			been executed and tasks have been thawed.

			PM_SUSPEND_PREPARE The system is preparing for a suspend.

			PM_POST_SUSPEND The system has just resumed or an error occured during
			the suspend. Device drivers' .resume() callbacks have
			been executed and tasks have been thawed.

			It is generally assumed that whatever the notifiers do for
			PM_HIBERNATION_PREPARE, should be undone for PM_POST_HIBERNATION. Analogously,
			operations performed for PM_SUSPEND_PREPARE should be reversed for
			PM_POST_SUSPEND. Additionally, all of the notifiers are called for
			PM_POST_HIBERNATION if one of them fails for PM_HIBERNATION_PREPARE, and
			all of the notifiers are called for PM_POST_SUSPEND if one of them fails for
			PM_SUSPEND_PREPARE.

			The hibernation and suspend notifiers are called with pm_mutex held. They are
			defined in the usual way, but their last argument is meaningless (it is always
			NULL). To register and/or unregister a suspend notifier use the functions
			register_pm_notifier() and unregister_pm_notifier(), respectively, defined in
			include/linux/suspend.h . If you don't need to unregister the notifier, you can
			also use the pm_notifier() macro defined in include/linux/suspend.h .

include/linux/notifier.h

+6 −0

Original line number	Original line	Diff line number	Diff line
	@@ -212,5 +212,11 @@ extern int __srcu_notifier_call_chain(struct srcu_notifier_head *nh,
	#define CPU_DEAD_FROZEN (CPU_DEAD \| CPU_TASKS_FROZEN)		#define CPU_DEAD_FROZEN (CPU_DEAD \| CPU_TASKS_FROZEN)
	#define CPU_DYING_FROZEN (CPU_DYING \| CPU_TASKS_FROZEN)		#define CPU_DYING_FROZEN (CPU_DYING \| CPU_TASKS_FROZEN)

			/* Hibernation and suspend events */
			#define PM_HIBERNATION_PREPARE 0x0001 /* Going to hibernate */
			#define PM_POST_HIBERNATION 0x0002 /* Hibernation finished */
			#define PM_SUSPEND_PREPARE 0x0003 /* Going to suspend the system */
			#define PM_POST_SUSPEND 0x0004 /* Suspend finished */

	#endif /* __KERNEL__ */		#endif /* __KERNEL__ */
	#endif /* _LINUX_NOTIFIER_H */		#endif /* _LINUX_NOTIFIER_H */

include/linux/suspend.h

+43 −5

Original line number	Original line	Diff line number	Diff line
	@@ -54,7 +54,8 @@ struct hibernation_ops {
	void (*restore_cleanup)(void);		void (*restore_cleanup)(void);
	};		};

	#if defined(CONFIG_PM) && defined(CONFIG_SOFTWARE_SUSPEND)		#ifdef CONFIG_PM
			#ifdef CONFIG_SOFTWARE_SUSPEND
	/* kernel/power/snapshot.c */		/* kernel/power/snapshot.c */
	extern void __register_nosave_region(unsigned long b, unsigned long e, int km);		extern void __register_nosave_region(unsigned long b, unsigned long e, int km);
	static inline void register_nosave_region(unsigned long b, unsigned long e)		static inline void register_nosave_region(unsigned long b, unsigned long e)
	@@ -72,16 +73,14 @@ extern unsigned long get_safe_page(gfp_t gfp_mask);

	extern void hibernation_set_ops(struct hibernation_ops *ops);		extern void hibernation_set_ops(struct hibernation_ops *ops);
	extern int hibernate(void);		extern int hibernate(void);
	#else		#else /* CONFIG_SOFTWARE_SUSPEND */
	static inline void register_nosave_region(unsigned long b, unsigned long e) {}
	static inline void register_nosave_region_late(unsigned long b, unsigned long e) {}
	static inline int swsusp_page_is_forbidden(struct page *p) { return 0; }		static inline int swsusp_page_is_forbidden(struct page *p) { return 0; }
	static inline void swsusp_set_page_free(struct page *p) {}		static inline void swsusp_set_page_free(struct page *p) {}
	static inline void swsusp_unset_page_free(struct page *p) {}		static inline void swsusp_unset_page_free(struct page *p) {}

	static inline void hibernation_set_ops(struct hibernation_ops *ops) {}		static inline void hibernation_set_ops(struct hibernation_ops *ops) {}
	static inline int hibernate(void) { return -ENOSYS; }		static inline int hibernate(void) { return -ENOSYS; }
	#endif /* defined(CONFIG_PM) && defined(CONFIG_SOFTWARE_SUSPEND) */		#endif /* CONFIG_SOFTWARE_SUSPEND */

	void save_processor_state(void);		void save_processor_state(void);
	void restore_processor_state(void);		void restore_processor_state(void);
	@@ -89,4 +88,43 @@ struct saved_context;
	void __save_processor_state(struct saved_context *ctxt);		void __save_processor_state(struct saved_context *ctxt);
	void __restore_processor_state(struct saved_context *ctxt);		void __restore_processor_state(struct saved_context *ctxt);

			/* kernel/power/main.c */
			extern struct blocking_notifier_head pm_chain_head;

			static inline int register_pm_notifier(struct notifier_block *nb)
			{
			return blocking_notifier_chain_register(&pm_chain_head, nb);
			}

			static inline int unregister_pm_notifier(struct notifier_block *nb)
			{
			return blocking_notifier_chain_unregister(&pm_chain_head, nb);
			}

			#define pm_notifier(fn, pri) { \
			static struct notifier_block fn##_nb = \
			{ .notifier_call = fn, .priority = pri }; \
			register_pm_notifier(&fn##_nb); \
			}
			#else /* CONFIG_PM */

			static inline int register_pm_notifier(struct notifier_block *nb)
			{
			return 0;
			}

			static inline int unregister_pm_notifier(struct notifier_block *nb)
			{
			return 0;
			}

			#define pm_notifier(fn, pri) do { (void)(fn); } while (0)
			#endif /* CONFIG_PM */

			#if !defined CONFIG_SOFTWARE_SUSPEND \|\| !defined(CONFIG_PM)
			static inline void register_nosave_region(unsigned long b, unsigned long e)
			{
			}
			#endif

	#endif /* _LINUX_SWSUSP_H */		#endif /* _LINUX_SWSUSP_H */

kernel/power/disk.c

+12 −4

Original line number	Original line	Diff line number	Diff line
	@@ -281,9 +281,16 @@ int hibernate(void)
	{		{
	int error;		int error;

			mutex_lock(&pm_mutex);
	/* The snapshot device should not be opened while we're running */		/* The snapshot device should not be opened while we're running */
	if (!atomic_add_unless(&snapshot_device_available, -1, 0))		if (!atomic_add_unless(&snapshot_device_available, -1, 0)) {
	return -EBUSY;		error = -EBUSY;
			goto Unlock;
			}

			error = pm_notifier_call_chain(PM_HIBERNATION_PREPARE);
			if (error)
			goto Exit;

	/* Allocate memory management structures */		/* Allocate memory management structures */
	error = create_basic_memory_bitmaps();		error = create_basic_memory_bitmaps();
	@@ -294,7 +301,6 @@ int hibernate(void)
	if (error)		if (error)
	goto Finish;		goto Finish;

	mutex_lock(&pm_mutex);
	if (hibernation_mode == HIBERNATION_TESTPROC) {		if (hibernation_mode == HIBERNATION_TESTPROC) {
	printk("swsusp debug: Waiting for 5 seconds.\n");		printk("swsusp debug: Waiting for 5 seconds.\n");
	mdelay(5000);		mdelay(5000);
	@@ -316,12 +322,14 @@ int hibernate(void)
	swsusp_free();		swsusp_free();
	}		}
	Thaw:		Thaw:
	mutex_unlock(&pm_mutex);
	unprepare_processes();		unprepare_processes();
	Finish:		Finish:
	free_basic_memory_bitmaps();		free_basic_memory_bitmaps();
	Exit:		Exit:
			pm_notifier_call_chain(PM_POST_HIBERNATION);
	atomic_inc(&snapshot_device_available);		atomic_inc(&snapshot_device_available);
			Unlock:
			mutex_unlock(&pm_mutex);
	return error;		return error;
	}		}

kernel/power/main.c

+9 −0

Original line number	Original line	Diff line number	Diff line
	@@ -23,6 +23,8 @@

	#include "power.h"		#include "power.h"

			BLOCKING_NOTIFIER_HEAD(pm_chain_head);

	/This is just an arbitrary number /		/This is just an arbitrary number /
	#define FREE_PAGE_NUMBER (100)		#define FREE_PAGE_NUMBER (100)

	@@ -78,6 +80,10 @@ static int suspend_prepare(suspend_state_t state)
	if (!pm_ops \|\| !pm_ops->enter)		if (!pm_ops \|\| !pm_ops->enter)
	return -EPERM;		return -EPERM;

			error = pm_notifier_call_chain(PM_SUSPEND_PREPARE);
			if (error)
			goto Finish;

	pm_prepare_console();		pm_prepare_console();

	if (freeze_processes()) {		if (freeze_processes()) {
	@@ -125,6 +131,8 @@ static int suspend_prepare(suspend_state_t state)
	Thaw:		Thaw:
	thaw_processes();		thaw_processes();
	pm_restore_console();		pm_restore_console();
			Finish:
			pm_notifier_call_chain(PM_POST_SUSPEND);
	return error;		return error;
	}		}

	@@ -176,6 +184,7 @@ static void suspend_finish(suspend_state_t state)
	resume_console();		resume_console();
	thaw_processes();		thaw_processes();
	pm_restore_console();		pm_restore_console();
			pm_notifier_call_chain(PM_POST_SUSPEND);
	}		}