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

Commit 290c7487 authored by Rafael J. Wysocki's avatar Rafael J. Wysocki
Browse files

Merge branch 'power-domains' into for-linus 

* power-domains:
  PM: Fix build issue in clock_ops.c for CONFIG_PM_RUNTIME unset
  PM: Revert "driver core: platform_bus: allow runtime override of dev_pm_ops"
  OMAP1 / PM: Use generic clock manipulation routines for runtime PM
  PM / Runtime: Generic clock manipulation rountines for runtime PM (v6)
  PM / Runtime: Add subsystem data field to struct dev_pm_info
  OMAP2+ / PM: move runtime PM implementation to use device power domains
  PM / Platform: Use generic runtime PM callbacks directly
  shmobile: Use power domains for platform runtime PM
  PM: Export platform bus type's default PM callbacks
  PM: Make power domain callbacks take precedence over subsystem ones
parents 2d2a9163 72874daa

arch/arm/mach-omap1/pm_bus.c

+22 −47
Original line number Diff line number Diff line
@@ -24,75 +24,50 @@ 
#ifdef CONFIG_PM_RUNTIME

static int omap1_pm_runtime_suspend(struct device *dev)

{

	struct clk *iclk, *fclk;

	int ret = 0;

	int ret;



	dev_dbg(dev, "%s\n", __func__);



	ret = pm_generic_runtime_suspend(dev);

	if (ret)

		return ret;



	fclk = clk_get(dev, "fck");

	if (!IS_ERR(fclk)) {

		clk_disable(fclk);

		clk_put(fclk);

	}



	iclk = clk_get(dev, "ick");

	if (!IS_ERR(iclk)) {

		clk_disable(iclk);

		clk_put(iclk);

	ret = pm_runtime_clk_suspend(dev);

	if (ret) {

		pm_generic_runtime_resume(dev);

		return ret;

	}



	return 0;

};

}



static int omap1_pm_runtime_resume(struct device *dev)

{

	struct clk *iclk, *fclk;



	dev_dbg(dev, "%s\n", __func__);



	iclk = clk_get(dev, "ick");

	if (!IS_ERR(iclk)) {

		clk_enable(iclk);

		clk_put(iclk);

	pm_runtime_clk_resume(dev);

	return pm_generic_runtime_resume(dev);

}



	fclk = clk_get(dev, "fck");

	if (!IS_ERR(fclk)) {

		clk_enable(fclk);

		clk_put(fclk);

	}

static struct dev_power_domain default_power_domain = {

	.ops = {

		.runtime_suspend = omap1_pm_runtime_suspend,

		.runtime_resume = omap1_pm_runtime_resume,

		USE_PLATFORM_PM_SLEEP_OPS

	},

};



	return pm_generic_runtime_resume(dev);

static struct pm_clk_notifier_block platform_bus_notifier = {

	.pwr_domain = &default_power_domain,

	.con_ids = { "ick", "fck", NULL, },

};



static int __init omap1_pm_runtime_init(void)

{

	const struct dev_pm_ops *pm;

	struct dev_pm_ops *omap_pm;



	if (!cpu_class_is_omap1())

		return -ENODEV;



	pm = platform_bus_get_pm_ops();

	if (!pm) {

		pr_err("%s: unable to get dev_pm_ops from platform_bus\n",

			__func__);

		return -ENODEV;

	}



	omap_pm = kmemdup(pm, sizeof(struct dev_pm_ops), GFP_KERNEL);

	if (!omap_pm) {

		pr_err("%s: unable to alloc memory for new dev_pm_ops\n",

			__func__);

		return -ENOMEM;

	}



	omap_pm->runtime_suspend = omap1_pm_runtime_suspend;

	omap_pm->runtime_resume = omap1_pm_runtime_resume;



	platform_bus_set_pm_ops(omap_pm);

	pm_runtime_clk_add_notifier(&platform_bus_type, &platform_bus_notifier);



	return 0;

}

arch/arm/mach-omap2/Makefile

+3 −3
Original line number Diff line number Diff line
@@ -59,10 +59,10 @@ endif 
# Power Management

ifeq ($(CONFIG_PM),y)

obj-$(CONFIG_ARCH_OMAP2)		+= pm24xx.o

obj-$(CONFIG_ARCH_OMAP2)		+= sleep24xx.o pm_bus.o

obj-$(CONFIG_ARCH_OMAP2)		+= sleep24xx.o

obj-$(CONFIG_ARCH_OMAP3)		+= pm34xx.o sleep34xx.o \

					   cpuidle34xx.o pm_bus.o

obj-$(CONFIG_ARCH_OMAP4)		+= pm44xx.o pm_bus.o

					   cpuidle34xx.o

obj-$(CONFIG_ARCH_OMAP4)		+= pm44xx.o

obj-$(CONFIG_PM_DEBUG)			+= pm-debug.o

obj-$(CONFIG_OMAP_SMARTREFLEX)          += sr_device.o smartreflex.o

obj-$(CONFIG_OMAP_SMARTREFLEX_CLASS3)	+= smartreflex-class3.o

arch/arm/mach-omap2/pm_bus.c

deleted100644 → 0
+0 −85
Original line number Diff line number Diff line 
/*

 * Runtime PM support code for OMAP

 *

 * Author: Kevin Hilman, Deep Root Systems, LLC

 *

 * Copyright (C) 2010 Texas Instruments, Inc.

 *

 * This file is licensed under the terms of the GNU General Public

 * License version 2. This program is licensed "as is" without any

 * warranty of any kind, whether express or implied.

 */

#include <linux/init.h>

#include <linux/kernel.h>

#include <linux/io.h>

#include <linux/pm_runtime.h>

#include <linux/platform_device.h>

#include <linux/mutex.h>



#include <plat/omap_device.h>

#include <plat/omap-pm.h>



#ifdef CONFIG_PM_RUNTIME

static int omap_pm_runtime_suspend(struct device *dev)

{

	struct platform_device *pdev = to_platform_device(dev);

	int r, ret = 0;



	dev_dbg(dev, "%s\n", __func__);



	ret = pm_generic_runtime_suspend(dev);



	if (!ret && dev->parent == &omap_device_parent) {

		r = omap_device_idle(pdev);

		WARN_ON(r);

	}



	return ret;

};



static int omap_pm_runtime_resume(struct device *dev)

{

	struct platform_device *pdev = to_platform_device(dev);

	int r;



	dev_dbg(dev, "%s\n", __func__);



	if (dev->parent == &omap_device_parent) {

		r = omap_device_enable(pdev);

		WARN_ON(r);

	}



	return pm_generic_runtime_resume(dev);

};

#else

#define omap_pm_runtime_suspend NULL

#define omap_pm_runtime_resume NULL

#endif /* CONFIG_PM_RUNTIME */



static int __init omap_pm_runtime_init(void)

{

	const struct dev_pm_ops *pm;

	struct dev_pm_ops *omap_pm;



	pm = platform_bus_get_pm_ops();

	if (!pm) {

		pr_err("%s: unable to get dev_pm_ops from platform_bus\n",

			__func__);

		return -ENODEV;

	}



	omap_pm = kmemdup(pm, sizeof(struct dev_pm_ops), GFP_KERNEL);

	if (!omap_pm) {

		pr_err("%s: unable to alloc memory for new dev_pm_ops\n",

			__func__);

		return -ENOMEM;

	}



	omap_pm->runtime_suspend = omap_pm_runtime_suspend;

	omap_pm->runtime_resume = omap_pm_runtime_resume;



	platform_bus_set_pm_ops(omap_pm);



	return 0;

}

core_initcall(omap_pm_runtime_init);

arch/arm/mach-shmobile/pm_runtime.c

+17 −128
Original line number Diff line number Diff line
@@ -18,152 +18,41 @@ 
#include <linux/clk.h>

#include <linux/sh_clk.h>

#include <linux/bitmap.h>

#include <linux/slab.h>



#ifdef CONFIG_PM_RUNTIME

#define BIT_ONCE 0

#define BIT_ACTIVE 1

#define BIT_CLK_ENABLED 2



struct pm_runtime_data {

	unsigned long flags;

	struct clk *clk;

};



static void __devres_release(struct device *dev, void *res)

{

	struct pm_runtime_data *prd = res;



	dev_dbg(dev, "__devres_release()\n");



	if (test_bit(BIT_CLK_ENABLED, &prd->flags))

		clk_disable(prd->clk);



	if (test_bit(BIT_ACTIVE, &prd->flags))

		clk_put(prd->clk);

}



static struct pm_runtime_data *__to_prd(struct device *dev)

{

	return devres_find(dev, __devres_release, NULL, NULL);

}



static void platform_pm_runtime_init(struct device *dev,

				     struct pm_runtime_data *prd)

{

	if (prd && !test_and_set_bit(BIT_ONCE, &prd->flags)) {

		prd->clk = clk_get(dev, NULL);

		if (!IS_ERR(prd->clk)) {

			set_bit(BIT_ACTIVE, &prd->flags);

			dev_info(dev, "clocks managed by runtime pm\n");

		}

	}

}



static void platform_pm_runtime_bug(struct device *dev,

				    struct pm_runtime_data *prd)

{

	if (prd && !test_and_set_bit(BIT_ONCE, &prd->flags))

		dev_err(dev, "runtime pm suspend before resume\n");

}



int platform_pm_runtime_suspend(struct device *dev)

{

	struct pm_runtime_data *prd = __to_prd(dev);



	dev_dbg(dev, "platform_pm_runtime_suspend()\n");



	platform_pm_runtime_bug(dev, prd);



	if (prd && test_bit(BIT_ACTIVE, &prd->flags)) {

		clk_disable(prd->clk);

		clear_bit(BIT_CLK_ENABLED, &prd->flags);

	}



	return 0;

}



int platform_pm_runtime_resume(struct device *dev)

{

	struct pm_runtime_data *prd = __to_prd(dev);



	dev_dbg(dev, "platform_pm_runtime_resume()\n");



	platform_pm_runtime_init(dev, prd);



	if (prd && test_bit(BIT_ACTIVE, &prd->flags)) {

		clk_enable(prd->clk);

		set_bit(BIT_CLK_ENABLED, &prd->flags);

	}



	return 0;

}



int platform_pm_runtime_idle(struct device *dev)

static int default_platform_runtime_idle(struct device *dev)

{

	/* suspend synchronously to disable clocks immediately */

	return pm_runtime_suspend(dev);

}



static int platform_bus_notify(struct notifier_block *nb,

			       unsigned long action, void *data)

{

	struct device *dev = data;

	struct pm_runtime_data *prd;



	dev_dbg(dev, "platform_bus_notify() %ld !\n", action);



	if (action == BUS_NOTIFY_BIND_DRIVER) {

		prd = devres_alloc(__devres_release, sizeof(*prd), GFP_KERNEL);

		if (prd)

			devres_add(dev, prd);

		else

			dev_err(dev, "unable to alloc memory for runtime pm\n");

	}



	return 0;

}



#else /* CONFIG_PM_RUNTIME */



static int platform_bus_notify(struct notifier_block *nb,

			       unsigned long action, void *data)

{

	struct device *dev = data;

	struct clk *clk;

static struct dev_power_domain default_power_domain = {

	.ops = {

		.runtime_suspend = pm_runtime_clk_suspend,

		.runtime_resume = pm_runtime_clk_resume,

		.runtime_idle = default_platform_runtime_idle,

		USE_PLATFORM_PM_SLEEP_OPS

	},

};



	dev_dbg(dev, "platform_bus_notify() %ld !\n", action);

#define DEFAULT_PWR_DOMAIN_PTR	(&default_power_domain)



	switch (action) {

	case BUS_NOTIFY_BIND_DRIVER:

		clk = clk_get(dev, NULL);

		if (!IS_ERR(clk)) {

			clk_enable(clk);

			clk_put(clk);

			dev_info(dev, "runtime pm disabled, clock forced on\n");

		}

		break;

	case BUS_NOTIFY_UNBOUND_DRIVER:

		clk = clk_get(dev, NULL);

		if (!IS_ERR(clk)) {

			clk_disable(clk);

			clk_put(clk);

			dev_info(dev, "runtime pm disabled, clock forced off\n");

		}

		break;

	}

#else



	return 0;

}

#define DEFAULT_PWR_DOMAIN_PTR	NULL



#endif /* CONFIG_PM_RUNTIME */



static struct notifier_block platform_bus_notifier = {

	.notifier_call = platform_bus_notify

static struct pm_clk_notifier_block platform_bus_notifier = {

	.pwr_domain = DEFAULT_PWR_DOMAIN_PTR,

	.con_ids = { NULL, },

};



static int __init sh_pm_runtime_init(void)

{

	bus_register_notifier(&platform_bus_type, &platform_bus_notifier);

	pm_runtime_clk_add_notifier(&platform_bus_type, &platform_bus_notifier);

	return 0;

}

core_initcall(sh_pm_runtime_init);

arch/arm/plat-omap/omap_device.c

+23 −0
Original line number Diff line number Diff line
@@ -536,6 +536,28 @@ int omap_early_device_register(struct omap_device *od) 
	return 0;

}



static int _od_runtime_suspend(struct device *dev)

{

	struct platform_device *pdev = to_platform_device(dev);



	return omap_device_idle(pdev);

}



static int _od_runtime_resume(struct device *dev)

{

	struct platform_device *pdev = to_platform_device(dev);



	return omap_device_enable(pdev);

}



static struct dev_power_domain omap_device_power_domain = {

	.ops = {

		.runtime_suspend = _od_runtime_suspend,

		.runtime_resume = _od_runtime_resume,

		USE_PLATFORM_PM_SLEEP_OPS

	}

};



/**

 * omap_device_register - register an omap_device with one omap_hwmod

 * @od: struct omap_device * to register
@@ -549,6 +571,7 @@ int omap_device_register(struct omap_device *od) 
	pr_debug("omap_device: %s: registering\n", od->pdev.name);



	od->pdev.dev.parent = &omap_device_parent;

	od->pdev.dev.pwr_domain = &omap_device_power_domain;

	return platform_device_register(&od->pdev);

}