Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 40dc166c authored by Rafael J. Wysocki's avatar Rafael J. Wysocki
Browse files

PM / Core: Introduce struct syscore_ops for core subsystems PM 



Some subsystems need to carry out suspend/resume and shutdown
operations with one CPU on-line and interrupts disabled.  The only
way to register such operations is to define a sysdev class and
a sysdev specifically for this purpose which is cumbersome and
inefficient.  Moreover, the arguments taken by sysdev suspend,
resume and shutdown callbacks are practically never necessary.

For this reason, introduce a simpler interface allowing subsystems
to register operations to be executed very late during system suspend
and shutdown and very early during resume in the form of
strcut syscore_ops objects.

Signed-off-by: default avatarRafael J. Wysocki <rjw@sisk.pl>
Acked-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent f9b9e806

drivers/base/Makefile

+1 −1
Original line number Diff line number Diff line 
# Makefile for the Linux device tree



obj-y			:= core.o sys.o bus.o dd.o \

obj-y			:= core.o sys.o bus.o dd.o syscore.o \

			   driver.o class.o platform.o \

			   cpu.o firmware.o init.o map.o devres.o \

			   attribute_container.o transport_class.o

drivers/base/syscore.c

0 → 100644
+117 −0
Original line number Diff line number Diff line 
/*

 *  syscore.c - Execution of system core operations.

 *

 *  Copyright (C) 2011 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.

 *

 *  This file is released under the GPLv2.

 */



#include <linux/syscore_ops.h>

#include <linux/mutex.h>

#include <linux/module.h>



static LIST_HEAD(syscore_ops_list);

static DEFINE_MUTEX(syscore_ops_lock);



/**

 * register_syscore_ops - Register a set of system core operations.

 * @ops: System core operations to register.

 */

void register_syscore_ops(struct syscore_ops *ops)

{

	mutex_lock(&syscore_ops_lock);

	list_add_tail(&ops->node, &syscore_ops_list);

	mutex_unlock(&syscore_ops_lock);

}

EXPORT_SYMBOL_GPL(register_syscore_ops);



/**

 * unregister_syscore_ops - Unregister a set of system core operations.

 * @ops: System core operations to unregister.

 */

void unregister_syscore_ops(struct syscore_ops *ops)

{

	mutex_lock(&syscore_ops_lock);

	list_del(&ops->node);

	mutex_unlock(&syscore_ops_lock);

}

EXPORT_SYMBOL_GPL(unregister_syscore_ops);



#ifdef CONFIG_PM_SLEEP

/**

 * syscore_suspend - Execute all the registered system core suspend callbacks.

 *

 * This function is executed with one CPU on-line and disabled interrupts.

 */

int syscore_suspend(void)

{

	struct syscore_ops *ops;

	int ret = 0;



	WARN_ONCE(!irqs_disabled(),

		"Interrupts enabled before system core suspend.\n");



	list_for_each_entry_reverse(ops, &syscore_ops_list, node)

		if (ops->suspend) {

			if (initcall_debug)

				pr_info("PM: Calling %pF\n", ops->suspend);

			ret = ops->suspend();

			if (ret)

				goto err_out;

			WARN_ONCE(!irqs_disabled(),

				"Interrupts enabled after %pF\n", ops->suspend);

		}



	return 0;



 err_out:

	pr_err("PM: System core suspend callback %pF failed.\n", ops->suspend);



	list_for_each_entry_continue(ops, &syscore_ops_list, node)

		if (ops->resume)

			ops->resume();



	return ret;

}



/**

 * syscore_resume - Execute all the registered system core resume callbacks.

 *

 * This function is executed with one CPU on-line and disabled interrupts.

 */

void syscore_resume(void)

{

	struct syscore_ops *ops;



	WARN_ONCE(!irqs_disabled(),

		"Interrupts enabled before system core resume.\n");



	list_for_each_entry(ops, &syscore_ops_list, node)

		if (ops->resume) {

			if (initcall_debug)

				pr_info("PM: Calling %pF\n", ops->resume);

			ops->resume();

			WARN_ONCE(!irqs_disabled(),

				"Interrupts enabled after %pF\n", ops->resume);

		}

}

#endif /* CONFIG_PM_SLEEP */



/**

 * syscore_shutdown - Execute all the registered system core shutdown callbacks.

 */

void syscore_shutdown(void)

{

	struct syscore_ops *ops;



	mutex_lock(&syscore_ops_lock);



	list_for_each_entry_reverse(ops, &syscore_ops_list, node)

		if (ops->shutdown) {

			if (initcall_debug)

				pr_info("PM: Calling %pF\n", ops->shutdown);

			ops->shutdown();

		}



	mutex_unlock(&syscore_ops_lock);

}

include/linux/syscore_ops.h

0 → 100644
+29 −0
Original line number Diff line number Diff line 
/*

 *  syscore_ops.h - System core operations.

 *

 *  Copyright (C) 2011 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.

 *

 *  This file is released under the GPLv2.

 */



#ifndef _LINUX_SYSCORE_OPS_H

#define _LINUX_SYSCORE_OPS_H



#include <linux/list.h>



struct syscore_ops {

	struct list_head node;

	int (*suspend)(void);

	void (*resume)(void);

	void (*shutdown)(void);

};



extern void register_syscore_ops(struct syscore_ops *ops);

extern void unregister_syscore_ops(struct syscore_ops *ops);

#ifdef CONFIG_PM_SLEEP

extern int syscore_suspend(void);

extern void syscore_resume(void);

#endif

extern void syscore_shutdown(void);



#endif

kernel/power/hibernate.c

+9 −0
Original line number Diff line number Diff line
@@ -23,6 +23,7 @@ 
#include <linux/cpu.h>

#include <linux/freezer.h>

#include <linux/gfp.h>

#include <linux/syscore_ops.h>

#include <scsi/scsi_scan.h>

#include <asm/suspend.h>
@@ -272,6 +273,8 @@ static int create_image(int platform_mode) 
	local_irq_disable();



	error = sysdev_suspend(PMSG_FREEZE);

	if (!error)

		error = syscore_suspend();

	if (error) {

		printk(KERN_ERR "PM: Some system devices failed to power down, "

			"aborting hibernation\n");
@@ -295,6 +298,7 @@ static int create_image(int platform_mode) 
	}



 Power_up:

	syscore_resume();

	sysdev_resume();

	/* NOTE:  dpm_resume_noirq() is just a resume() for devices

	 * that suspended with irqs off ... no overall powerup.
@@ -403,6 +407,8 @@ static int resume_target_kernel(bool platform_mode) 
	local_irq_disable();



	error = sysdev_suspend(PMSG_QUIESCE);

	if (!error)

		error = syscore_suspend();

	if (error)

		goto Enable_irqs;
@@ -429,6 +435,7 @@ static int resume_target_kernel(bool platform_mode) 
	restore_processor_state();

	touch_softlockup_watchdog();



	syscore_resume();

	sysdev_resume();



 Enable_irqs:
@@ -516,6 +523,7 @@ int hibernation_platform_enter(void) 


	local_irq_disable();

	sysdev_suspend(PMSG_HIBERNATE);

	syscore_suspend();

	if (pm_wakeup_pending()) {

		error = -EAGAIN;

		goto Power_up;
@@ -526,6 +534,7 @@ int hibernation_platform_enter(void) 
	while (1);



 Power_up:

	syscore_resume();

	sysdev_resume();

	local_irq_enable();

	enable_nonboot_cpus();

kernel/power/suspend.c

+4 −0
Original line number Diff line number Diff line
@@ -22,6 +22,7 @@ 
#include <linux/mm.h>

#include <linux/slab.h>

#include <linux/suspend.h>

#include <linux/syscore_ops.h>

#include <trace/events/power.h>



#include "power.h"
@@ -163,11 +164,14 @@ static int suspend_enter(suspend_state_t state) 
	BUG_ON(!irqs_disabled());



	error = sysdev_suspend(PMSG_SUSPEND);

	if (!error)

		error = syscore_suspend();

	if (!error) {

		if (!(suspend_test(TEST_CORE) || pm_wakeup_pending())) {

			error = suspend_ops->enter(state);

			events_check_enabled = false;

		}

		syscore_resume();

		sysdev_resume();

	}