| Message ID | 201106200002.19377.rjw@sisk.pl (mailing list archive) |
|---|---|
| State | Not Applicable |
| Headers | show |
"Rafael J. Wysocki" <rjw@sisk.pl> writes: > From: Rafael J. Wysocki <rjw@sisk.pl> > > Introduce common headers, helper functions and callbacks allowing > platforms to use simple generic power domains for runtime power > management. > > Introduce struct generic_pm_domain to be used for representing > power domains that each contain a number of devices and may be > parent domains or subdomains with respect to other power domains. > Among other things, this structure includes callbacks to be > provided by platforms for performing specific tasks related to > power management (i.e. ->stop_device() may disable a device's > clocks, while ->start_device() may enable them, ->power_off() is > supposed to remove power from the entire power domain > and ->power_on() is supposed to restore it). > > Introduce functions that can be used as power domain runtime PM > callbacks, pm_genpd_runtime_suspend() and pm_genpd_runtime_resume(), > as well as helper functions for the initialization of a power > domain represented by a struct generic_power_domain object, > adding a device to or removing a device from it and adding or > removing subdomains. > > Introduce configuration option CONFIG_PM_GENERIC_DOMAINS to be > selected by the platforms that want to use the new code. > > Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl> > Acked-by: Greg Kroah-Hartman <gregkh@suse.de> > --- > > Hi, > > I this version of the patch I made the following modifications: > > * Removed the change adding platform_data to struct dev_pm_domain, > because that field is not going to be necessary in the near future. > > * Moved the code calling drv->pm->runtime_suspend(dev) to a separate > function that returns immediately if dle->need_restore is set for the > given device (meaning that drv->pm->runtime_suspend(dev) has already > been called for it and the corresponding ->runtime_resume() hasn't). > This fixes a bug where drv->pm->runtime_suspend() could be called for > a device whose state hasn't been restored after power cycling its > PM domain. > > * Made pm_genpd_add_device() return error code on an attempt to add a device > do a PM domain whose power_is_off is set (that complemets the previous > modification). > > * Makde the .power_on() and .power_off() generic PM domain callbacks take > (struct generic_pm_domain *) arguments instead of (struct dev_pm_domain *). > > Thanks, > Rafael There's a guiding assumption in this generic PM domain layer that the runtime PM callbacks need only be called if power to the underlying PM domain is actually being cut. As a result, devices no longer have a callback called for other low-power states where the power may not actually be cut (a.k.a low-power with memory & logic retention.) However, there are devices (at least on OMAP, but I presume on all SoCs) where the driver will need to do other "stuff" for *all* low-power transitions, not just the power-off ones (e.g. device specific idle mode registers, clearing device-specific events/state that prevent low power transitions, etc.) Because of this, I don't currently see how to use these generic PM domains on devices with multiple power states since the runtime PM callbacks are only called for a subset of the power states. I haven't given this too much thought yet (especially the system PM aspects), but in order for generic PM domains to be more broadly useful for runtime PM, I'm starting to think that this series should add another set of callbacks: .power_off, .power_on or something similar. The .runtime_suspend/.runtime_resume callbacks would then be used for all power states and the .power_off/.power_on callbacks used only when power is actually cut. [...] > Index: linux-2.6/drivers/base/power/domain.c > =================================================================== > --- /dev/null > +++ linux-2.6/drivers/base/power/domain.c > @@ -0,0 +1,490 @@ > +/* > + * drivers/base/power/domain.c - Common code related to device power domains. > + * > + * Copyright (C) 2011 Rafael J. Wysocki <rjw@sisk.pl>, Renesas Electronics Corp. > + * > + * This file is released under the GPLv2. > + */ > + > +#include <linux/init.h> > +#include <linux/kernel.h> > +#include <linux/io.h> > +#include <linux/pm_runtime.h> > +#include <linux/pm_domain.h> > +#include <linux/slab.h> > +#include <linux/err.h> > + > +#ifdef CONFIG_PM_RUNTIME > + > +static void genpd_sd_counter_dec(struct generic_pm_domain *genpd) > +{ > + if (!WARN_ON(genpd->sd_count == 0)) > + genpd->sd_count--; > +} > + > +/** > + * __pm_genpd_save_device - Save the pre-suspend state of a device. > + * @dle: Device list entry of the device to save the state of. > + * @genpd: PM domain the device belongs to. > + */ > +static int __pm_genpd_save_device(struct dev_list_entry *dle, > + struct generic_pm_domain *genpd) > +{ > + struct device *dev = dle->dev; > + struct device_driver *drv = dev->driver; > + int ret = 0; > + > + if (dle->need_restore) > + return 0; > + > + if (genpd->start_device) > + genpd->start_device(dev); > + > + if (drv && drv->pm && drv->pm->runtime_suspend) The start/stop device calls should probably be included inside this 'if' since there's no reason to restart and re-stop the device if there is no callback to be run. Some drivers have alterntive ways of saving context (shadow registers, manual save/restore per-xfer, etc.) and thus have no callbacks for context save/restore. > + ret = drv->pm->runtime_suspend(dev); > + > + if (genpd->stop_device) > + genpd->stop_device(dev); > + > + if (!ret) > + dle->need_restore = true; > + > + return ret; > +} > + > +/** > + * __pm_genpd_restore_device - Restore the pre-suspend state of a device. > + * @dle: Device list entry of the device to restore the state of. > + * @genpd: PM domain the device belongs to. > + */ > +static void __pm_genpd_restore_device(struct dev_list_entry *dle, > + struct generic_pm_domain *genpd) > +{ > + struct device *dev = dle->dev; > + struct device_driver *drv = dev->driver; > + > + if (!dle->need_restore) > + return; > + > + if (genpd->start_device) > + genpd->start_device(dev); > + > + if (drv && drv->pm && drv->pm->runtime_resume) Similar to the 'save' case, the start/stop device calls should also be included inside this 'if'. > + drv->pm->runtime_resume(dev); > + > + if (genpd->stop_device) > + genpd->stop_device(dev); > + > + dle->need_restore = false; > +} Kevin -- To unsubscribe from this list: send the line "unsubscribe linux-sh" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On Tuesday, June 21, 2011, Kevin Hilman wrote: > "Rafael J. Wysocki" <rjw@sisk.pl> writes: > > > From: Rafael J. Wysocki <rjw@sisk.pl> > > > > Introduce common headers, helper functions and callbacks allowing > > platforms to use simple generic power domains for runtime power > > management. > > > > Introduce struct generic_pm_domain to be used for representing > > power domains that each contain a number of devices and may be > > parent domains or subdomains with respect to other power domains. > > Among other things, this structure includes callbacks to be > > provided by platforms for performing specific tasks related to > > power management (i.e. ->stop_device() may disable a device's > > clocks, while ->start_device() may enable them, ->power_off() is > > supposed to remove power from the entire power domain > > and ->power_on() is supposed to restore it). > > > > Introduce functions that can be used as power domain runtime PM > > callbacks, pm_genpd_runtime_suspend() and pm_genpd_runtime_resume(), > > as well as helper functions for the initialization of a power > > domain represented by a struct generic_power_domain object, > > adding a device to or removing a device from it and adding or > > removing subdomains. > > > > Introduce configuration option CONFIG_PM_GENERIC_DOMAINS to be > > selected by the platforms that want to use the new code. > > > > Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl> > > Acked-by: Greg Kroah-Hartman <gregkh@suse.de> > > --- > > > > Hi, > > > > I this version of the patch I made the following modifications: > > > > * Removed the change adding platform_data to struct dev_pm_domain, > > because that field is not going to be necessary in the near future. > > > > * Moved the code calling drv->pm->runtime_suspend(dev) to a separate > > function that returns immediately if dle->need_restore is set for the > > given device (meaning that drv->pm->runtime_suspend(dev) has already > > been called for it and the corresponding ->runtime_resume() hasn't). > > This fixes a bug where drv->pm->runtime_suspend() could be called for > > a device whose state hasn't been restored after power cycling its > > PM domain. > > > > * Made pm_genpd_add_device() return error code on an attempt to add a device > > do a PM domain whose power_is_off is set (that complemets the previous > > modification). > > > > * Makde the .power_on() and .power_off() generic PM domain callbacks take > > (struct generic_pm_domain *) arguments instead of (struct dev_pm_domain *). > > > > Thanks, > > Rafael > > There's a guiding assumption in this generic PM domain layer that the > runtime PM callbacks need only be called if power to the underlying PM > domain is actually being cut. As a result, devices no longer have a > callback called for other low-power states where the power may not > actually be cut (a.k.a low-power with memory & logic retention.) > > However, there are devices (at least on OMAP, but I presume on all SoCs) > where the driver will need to do other "stuff" for *all* low-power > transitions, not just the power-off ones (e.g. device specific idle mode > registers, clearing device-specific events/state that prevent low power > transitions, etc.) > > Because of this, I don't currently see how to use these generic PM > domains on devices with multiple power states since the runtime PM > callbacks are only called for a subset of the power states. > > I haven't given this too much thought yet (especially the system PM > aspects), but in order for generic PM domains to be more broadly useful > for runtime PM, I'm starting to think that this series should add > another set of callbacks: .power_off, .power_on or something similar. > The .runtime_suspend/.runtime_resume callbacks would then be used for > all power states and the .power_off/.power_on callbacks used only when > power is actually cut. Well, I _really_ would like to avoid adding more callbacks to struct dev_pm_ops, if that's what you mean, because we already seem to have problems with managing the existing ones. Also, IMO, you can always map every system with more power states to the model where there are only "device active" (runtime PM RPM_ACTIVE) "device stopped" (runtime PM RPM_SUSPENDED, need not save state) and "device power off" (runtime PM RPM_SUSPENDED, must save state) "software" states represented here. If anything more fine grained is necessary or useful, I'd say you need a more complicated model, but I'd prefer to avoid further complications in this patchset. > [...] > > > Index: linux-2.6/drivers/base/power/domain.c > > =================================================================== > > --- /dev/null > > +++ linux-2.6/drivers/base/power/domain.c > > @@ -0,0 +1,490 @@ > > +/* > > + * drivers/base/power/domain.c - Common code related to device power domains. > > + * > > + * Copyright (C) 2011 Rafael J. Wysocki <rjw@sisk.pl>, Renesas Electronics Corp. > > + * > > + * This file is released under the GPLv2. > > + */ > > + > > +#include <linux/init.h> > > +#include <linux/kernel.h> > > +#include <linux/io.h> > > +#include <linux/pm_runtime.h> > > +#include <linux/pm_domain.h> > > +#include <linux/slab.h> > > +#include <linux/err.h> > > + > > +#ifdef CONFIG_PM_RUNTIME > > + > > +static void genpd_sd_counter_dec(struct generic_pm_domain *genpd) > > +{ > > + if (!WARN_ON(genpd->sd_count == 0)) > > + genpd->sd_count--; > > +} > > + > > +/** > > + * __pm_genpd_save_device - Save the pre-suspend state of a device. > > + * @dle: Device list entry of the device to save the state of. > > + * @genpd: PM domain the device belongs to. > > + */ > > +static int __pm_genpd_save_device(struct dev_list_entry *dle, > > + struct generic_pm_domain *genpd) > > +{ > > + struct device *dev = dle->dev; > > + struct device_driver *drv = dev->driver; > > + int ret = 0; > > + > > + if (dle->need_restore) > > + return 0; > > + > > + if (genpd->start_device) > > + genpd->start_device(dev); > > + > > + if (drv && drv->pm && drv->pm->runtime_suspend) > > The start/stop device calls should probably be included inside this 'if' > since there's no reason to restart and re-stop the device if there is no > callback to be run. That's a good point, I'll do that. > Some drivers have alterntive ways of saving context (shadow registers, > manual save/restore per-xfer, etc.) and thus have no callbacks for > context save/restore. > > > + ret = drv->pm->runtime_suspend(dev); > > + > > + if (genpd->stop_device) > > + genpd->stop_device(dev); > > + > > + if (!ret) > > + dle->need_restore = true; > > + > > + return ret; > > +} > > + > > +/** > > + * __pm_genpd_restore_device - Restore the pre-suspend state of a device. > > + * @dle: Device list entry of the device to restore the state of. > > + * @genpd: PM domain the device belongs to. > > + */ > > +static void __pm_genpd_restore_device(struct dev_list_entry *dle, > > + struct generic_pm_domain *genpd) > > +{ > > + struct device *dev = dle->dev; > > + struct device_driver *drv = dev->driver; > > + > > + if (!dle->need_restore) > > + return; > > + > > + if (genpd->start_device) > > + genpd->start_device(dev); > > + > > + if (drv && drv->pm && drv->pm->runtime_resume) > > Similar to the 'save' case, the start/stop device calls should also be > included inside this 'if'. Agreed. > > + drv->pm->runtime_resume(dev); > > + > > + if (genpd->stop_device) > > + genpd->stop_device(dev); > > + > > + dle->need_restore = false; > > +} Thanks for the comments, I'm going to implement your suggestions. Take care, Rafael -- To unsubscribe from this list: send the line "unsubscribe linux-sh" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
"Rafael J. Wysocki" <rjw@sisk.pl> writes: > On Tuesday, June 21, 2011, Kevin Hilman wrote: >> "Rafael J. Wysocki" <rjw@sisk.pl> writes: [...] >> >> There's a guiding assumption in this generic PM domain layer that the >> runtime PM callbacks need only be called if power to the underlying PM >> domain is actually being cut. As a result, devices no longer have a >> callback called for other low-power states where the power may not >> actually be cut (a.k.a low-power with memory & logic retention.) >> >> However, there are devices (at least on OMAP, but I presume on all SoCs) >> where the driver will need to do other "stuff" for *all* low-power >> transitions, not just the power-off ones (e.g. device specific idle mode >> registers, clearing device-specific events/state that prevent low power >> transitions, etc.) >> >> Because of this, I don't currently see how to use these generic PM >> domains on devices with multiple power states since the runtime PM >> callbacks are only called for a subset of the power states. >> >> I haven't given this too much thought yet (especially the system PM >> aspects), but in order for generic PM domains to be more broadly useful >> for runtime PM, I'm starting to think that this series should add >> another set of callbacks: .power_off, .power_on or something similar. >> The .runtime_suspend/.runtime_resume callbacks would then be used for >> all power states and the .power_off/.power_on callbacks used only when >> power is actually cut. > > Well, I _really_ would like to avoid adding more callbacks to struct > dev_pm_ops, if that's what you mean, because we already seem to have > problems with managing the existing ones. I agree, I don't really want to see more callbacks either. > Also, IMO, you can always map every system with more power states to the > model where there are only "device active" (runtime PM RPM_ACTIVE) "device > stopped" (runtime PM RPM_SUSPENDED, need not save state) and "device > power off" (runtime PM RPM_SUSPENDED, must save state) "software" states > represented here. Yes, but note that you list 2 RPM_SUSPENDED states, but there is only one .runtime_suspend callback, so the driver is only be notified of one of the them. More specifically, the problem is that using generic PM domains, there are no callbacks to the driver for "device stopped", since the driver's .runtime_suspend() is not called until "device power off." What I tried to say in my initial reply is that many devices actually have device specific stuff to do in preparation for "device stopped", or the hardware will not actually reach the targetted power state. Without a callback, no device-specific preparation for "device stopped" can be done. thinking out loud: hmm..., the more I think of this, maybe we should actually be using RPM_IDLE to represent your definition of "device stopped." > If anything more fine grained is necessary or useful, I'd say you need > a more complicated model, but I'd prefer to avoid further > complications in this patchset. Unfortunately, PM on embedded devices is very fine grained and very complicated. Kevin -- To unsubscribe from this list: send the line "unsubscribe linux-sh" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On Wednesday, June 22, 2011, Kevin Hilman wrote: > "Rafael J. Wysocki" <rjw@sisk.pl> writes: > > > On Tuesday, June 21, 2011, Kevin Hilman wrote: > >> "Rafael J. Wysocki" <rjw@sisk.pl> writes: > > [...] > > >> > >> There's a guiding assumption in this generic PM domain layer that the > >> runtime PM callbacks need only be called if power to the underlying PM > >> domain is actually being cut. As a result, devices no longer have a > >> callback called for other low-power states where the power may not > >> actually be cut (a.k.a low-power with memory & logic retention.) > >> > >> However, there are devices (at least on OMAP, but I presume on all SoCs) > >> where the driver will need to do other "stuff" for *all* low-power > >> transitions, not just the power-off ones (e.g. device specific idle mode > >> registers, clearing device-specific events/state that prevent low power > >> transitions, etc.) > >> > >> Because of this, I don't currently see how to use these generic PM > >> domains on devices with multiple power states since the runtime PM > >> callbacks are only called for a subset of the power states. > >> > >> I haven't given this too much thought yet (especially the system PM > >> aspects), but in order for generic PM domains to be more broadly useful > >> for runtime PM, I'm starting to think that this series should add > >> another set of callbacks: .power_off, .power_on or something similar. > >> The .runtime_suspend/.runtime_resume callbacks would then be used for > >> all power states and the .power_off/.power_on callbacks used only when > >> power is actually cut. > > > > Well, I _really_ would like to avoid adding more callbacks to struct > > dev_pm_ops, if that's what you mean, because we already seem to have > > problems with managing the existing ones. > > I agree, I don't really want to see more callbacks either. > > > Also, IMO, you can always map every system with more power states to the > > model where there are only "device active" (runtime PM RPM_ACTIVE) "device > > stopped" (runtime PM RPM_SUSPENDED, need not save state) and "device > > power off" (runtime PM RPM_SUSPENDED, must save state) "software" states > > represented here. > > Yes, but note that you list 2 RPM_SUSPENDED states, but there is only > one .runtime_suspend callback, so the driver is only be notified of one > of the them. That's correct. > More specifically, the problem is that using generic PM domains, there > are no callbacks to the driver for "device stopped", since the driver's > .runtime_suspend() is not called until "device power off." Yes, it is, because that is not necessary for the first user (the shmobile domain added by [8/8]). However, I have a plan to add such a mechanism using the subsys_data field from struct dev_pm_info (it's only used for the clocks management right now, but it's going to see more usage anyway :-)). > What I tried to say in my initial reply is that many devices actually > have device specific stuff to do in preparation for "device stopped", or > the hardware will not actually reach the targetted power state. Without > a callback, no device-specific preparation for "device stopped" can be > done. > > thinking out loud: hmm..., the more I think of this, maybe we should > actually be using RPM_IDLE to represent your definition of "device > stopped." I don't think that will work as expected. > > If anything more fine grained is necessary or useful, I'd say you need > > a more complicated model, but I'd prefer to avoid further > > complications in this patchset. > > Unfortunately, PM on embedded devices is very fine grained and very > complicated. Which hopefully doesn't mean the code has to cover all of the possible complications from the start. :-) Thanks, Rafael -- To unsubscribe from this list: send the line "unsubscribe linux-sh" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Index: linux-2.6/include/linux/pm_domain.h =================================================================== --- /dev/null +++ linux-2.6/include/linux/pm_domain.h @@ -0,0 +1,78 @@ +/* + * pm_domain.h - Definitions and headers related to device power domains. + * + * Copyright (C) 2011 Rafael J. Wysocki <rjw@sisk.pl>, Renesas Electronics Corp. + * + * This file is released under the GPLv2. + */ + +#ifndef _LINUX_PM_DOMAIN_H +#define _LINUX_PM_DOMAIN_H + +#include <linux/device.h> + +struct dev_power_governor { + bool (*power_down_ok)(struct dev_pm_domain *domain); +}; + +struct generic_pm_domain { + struct dev_pm_domain domain; /* PM domain operations */ + struct list_head sd_node; /* Node in the parent's subdomain list */ + struct generic_pm_domain *parent; /* Parent PM domain */ + struct list_head sd_list; /* List of dubdomains */ + struct list_head dev_list; /* List of devices */ + struct mutex lock; + struct dev_power_governor *gov; + struct work_struct power_off_work; + unsigned int in_progress; /* Number of devices being suspended now */ + unsigned int sd_count; /* Number of subdomains with power "on" */ + bool power_is_off; /* Whether or not power has been removed */ + int (*power_off)(struct generic_pm_domain *domain); + int (*power_on)(struct generic_pm_domain *domain); + int (*start_device)(struct device *dev); + int (*stop_device)(struct device *dev); +}; + +struct dev_list_entry { + struct list_head node; + struct device *dev; + bool need_restore; +}; + +#ifdef CONFIG_PM_GENERIC_DOMAINS +extern int pm_genpd_add_device(struct generic_pm_domain *genpd, + struct device *dev); +extern int pm_genpd_remove_device(struct generic_pm_domain *genpd, + struct device *dev); +extern int pm_genpd_add_subdomain(struct generic_pm_domain *genpd, + struct generic_pm_domain *new_subdomain); +extern int pm_genpd_remove_subdomain(struct generic_pm_domain *genpd, + struct generic_pm_domain *target); +extern void pm_genpd_init(struct generic_pm_domain *genpd, + struct dev_power_governor *gov, bool is_off); +#else +static inline int pm_genpd_add_device(struct generic_pm_domain *genpd, + struct device *dev) +{ + return -ENOSYS; +} +static inline int pm_genpd_remove_device(struct generic_pm_domain *genpd, + struct device *dev) +{ + return -ENOSYS; +} +static inline int pm_genpd_add_subdomain(struct generic_pm_domain *genpd, + struct generic_pm_domain *new_sd) +{ + return -ENOSYS; +} +static inline int pm_genpd_remove_subdomain(struct generic_pm_domain *genpd, + struct generic_pm_domain *target) +{ + return -ENOSYS; +} +static inline void pm_genpd_init(struct generic_pm_domain *genpd, + struct dev_power_governor *gov, bool is_off) {} +#endif + +#endif /* _LINUX_PM_DOMAIN_H */ Index: linux-2.6/drivers/base/power/Makefile =================================================================== --- linux-2.6.orig/drivers/base/power/Makefile +++ linux-2.6/drivers/base/power/Makefile @@ -3,6 +3,7 @@ obj-$(CONFIG_PM_SLEEP) += main.o wakeup. obj-$(CONFIG_PM_RUNTIME) += runtime.o obj-$(CONFIG_PM_TRACE_RTC) += trace.o obj-$(CONFIG_PM_OPP) += opp.o +obj-$(CONFIG_PM_GENERIC_DOMAINS) += domain.o obj-$(CONFIG_HAVE_CLK) += clock_ops.o ccflags-$(CONFIG_DEBUG_DRIVER) := -DDEBUG \ No newline at end of file Index: linux-2.6/drivers/base/power/domain.c =================================================================== --- /dev/null +++ linux-2.6/drivers/base/power/domain.c @@ -0,0 +1,490 @@ +/* + * drivers/base/power/domain.c - Common code related to device power domains. + * + * Copyright (C) 2011 Rafael J. Wysocki <rjw@sisk.pl>, Renesas Electronics Corp. + * + * This file is released under the GPLv2. + */ + +#include <linux/init.h> +#include <linux/kernel.h> +#include <linux/io.h> +#include <linux/pm_runtime.h> +#include <linux/pm_domain.h> +#include <linux/slab.h> +#include <linux/err.h> + +#ifdef CONFIG_PM_RUNTIME + +static void genpd_sd_counter_dec(struct generic_pm_domain *genpd) +{ + if (!WARN_ON(genpd->sd_count == 0)) + genpd->sd_count--; +} + +/** + * __pm_genpd_save_device - Save the pre-suspend state of a device. + * @dle: Device list entry of the device to save the state of. + * @genpd: PM domain the device belongs to. + */ +static int __pm_genpd_save_device(struct dev_list_entry *dle, + struct generic_pm_domain *genpd) +{ + struct device *dev = dle->dev; + struct device_driver *drv = dev->driver; + int ret = 0; + + if (dle->need_restore) + return 0; + + if (genpd->start_device) + genpd->start_device(dev); + + if (drv && drv->pm && drv->pm->runtime_suspend) + ret = drv->pm->runtime_suspend(dev); + + if (genpd->stop_device) + genpd->stop_device(dev); + + if (!ret) + dle->need_restore = true; + + return ret; +} + +/** + * __pm_genpd_restore_device - Restore the pre-suspend state of a device. + * @dle: Device list entry of the device to restore the state of. + * @genpd: PM domain the device belongs to. + */ +static void __pm_genpd_restore_device(struct dev_list_entry *dle, + struct generic_pm_domain *genpd) +{ + struct device *dev = dle->dev; + struct device_driver *drv = dev->driver; + + if (!dle->need_restore) + return; + + if (genpd->start_device) + genpd->start_device(dev); + + if (drv && drv->pm && drv->pm->runtime_resume) + drv->pm->runtime_resume(dev); + + if (genpd->stop_device) + genpd->stop_device(dev); + + dle->need_restore = false; +} + +/** + * pm_genpd_poweroff - Remove power from a given PM domain. + * @genpd: PM domain to power down. + * + * If all of the @genpd's devices have been suspended and all of its subdomains + * have been powered down, run the runtime suspend callbacks provided by all of + * the @genpd's devices' drivers and remove power from @genpd. + */ +static int pm_genpd_poweroff(struct generic_pm_domain *genpd) +{ + struct generic_pm_domain *parent; + struct dev_list_entry *dle; + unsigned int not_suspended; + int ret; + + if (genpd->power_is_off) + return 0; + + if (genpd->sd_count > 0) + return -EBUSY; + + not_suspended = 0; + list_for_each_entry(dle, &genpd->dev_list, node) + if (dle->dev->driver && !pm_runtime_suspended(dle->dev)) + not_suspended++; + + if (not_suspended > genpd->in_progress) + return -EBUSY; + + if (genpd->gov && genpd->gov->power_down_ok) { + if (!genpd->gov->power_down_ok(&genpd->domain)) + return -EAGAIN; + } + + list_for_each_entry_reverse(dle, &genpd->dev_list, node) { + ret = __pm_genpd_save_device(dle, genpd); + if (ret) + goto err_dev; + } + + if (genpd->power_off) + genpd->power_off(genpd); + + genpd->power_is_off = true; + + parent = genpd->parent; + if (parent) { + genpd_sd_counter_dec(parent); + if (parent->sd_count == 0) + queue_work(pm_wq, &parent->power_off_work); + } + + return 0; + + err_dev: + list_for_each_entry_continue(dle, &genpd->dev_list, node) + __pm_genpd_restore_device(dle, genpd); + + return ret; +} + +/** + * genpd_power_off_work_fn - Power off PM domain whose subdomain count is 0. + * @work: Work structure used for scheduling the execution of this function. + */ +static void genpd_power_off_work_fn(struct work_struct *work) +{ + struct generic_pm_domain *genpd; + + genpd = container_of(work, struct generic_pm_domain, power_off_work); + + if (genpd->parent) + mutex_lock(&genpd->parent->lock); + mutex_lock(&genpd->lock); + pm_genpd_poweroff(genpd); + mutex_unlock(&genpd->lock); + if (genpd->parent) + mutex_unlock(&genpd->parent->lock); +} + +/** + * pm_genpd_runtime_suspend - Suspend a device belonging to I/O PM domain. + * @dev: Device to suspend. + * + * Carry out a runtime suspend of a device under the assumption that its + * pm_domain field points to the domain member of an object of type + * struct generic_pm_domain representing a PM domain consisting of I/O devices. + */ +static int pm_genpd_runtime_suspend(struct device *dev) +{ + struct generic_pm_domain *genpd; + + dev_dbg(dev, "%s()\n", __func__); + + if (IS_ERR_OR_NULL(dev->pm_domain)) + return -EINVAL; + + genpd = container_of(dev->pm_domain, struct generic_pm_domain, domain); + + if (genpd->parent) + mutex_lock(&genpd->parent->lock); + mutex_lock(&genpd->lock); + + if (genpd->stop_device) { + int ret = genpd->stop_device(dev); + if (ret) + goto out; + } + genpd->in_progress++; + pm_genpd_poweroff(genpd); + genpd->in_progress--; + + out: + mutex_unlock(&genpd->lock); + if (genpd->parent) + mutex_unlock(&genpd->parent->lock); + + return 0; +} + +/** + * pm_genpd_poweron - Restore power to a given PM domain and its parents. + * @genpd: PM domain to power up. + * + * Restore power to @genpd and all of its parents so that it is possible to + * resume a device belonging to it. + */ +static int pm_genpd_poweron(struct generic_pm_domain *genpd) +{ + int ret = 0; + + start: + if (genpd->parent) + mutex_lock(&genpd->parent->lock); + mutex_lock(&genpd->lock); + + if (!genpd->power_is_off) + goto out; + + if (genpd->parent && genpd->parent->power_is_off) { + mutex_unlock(&genpd->lock); + mutex_unlock(&genpd->parent->lock); + + ret = pm_genpd_poweron(genpd->parent); + if (ret) + return ret; + + goto start; + } + + if (genpd->power_on) { + int ret = genpd->power_on(genpd); + if (ret) + goto out; + } + + genpd->power_is_off = false; + if (genpd->parent) + genpd->parent->sd_count++; + + out: + mutex_unlock(&genpd->lock); + if (genpd->parent) + mutex_unlock(&genpd->parent->lock); + + return ret; +} + +/** + * pm_genpd_runtime_resume - Resume a device belonging to I/O PM domain. + * @dev: Device to resume. + * + * Carry out a runtime resume of a device under the assumption that its + * pm_domain field points to the domain member of an object of type + * struct generic_pm_domain representing a PM domain consisting of I/O devices. + */ +static int pm_genpd_runtime_resume(struct device *dev) +{ + struct generic_pm_domain *genpd; + struct dev_list_entry *dle; + int ret; + + dev_dbg(dev, "%s()\n", __func__); + + if (IS_ERR_OR_NULL(dev->pm_domain)) + return -EINVAL; + + genpd = container_of(dev->pm_domain, struct generic_pm_domain, domain); + + ret = pm_genpd_poweron(genpd); + if (ret) + return ret; + + mutex_lock(&genpd->lock); + + list_for_each_entry(dle, &genpd->dev_list, node) { + if (dle->dev == dev) { + __pm_genpd_restore_device(dle, genpd); + break; + } + } + + if (genpd->start_device) + genpd->start_device(dev); + + mutex_unlock(&genpd->lock); + + return 0; +} + +#else + +#define pm_genpd_runtime_suspend NULL +#define pm_genpd_runtime_resume NULL + +#endif /* CONFIG_PM_RUNTIME */ + +/** + * pm_genpd_add_device - Add a device to an I/O PM domain. + * @genpd: PM domain to add the device to. + * @dev: Device to be added. + */ +int pm_genpd_add_device(struct generic_pm_domain *genpd, struct device *dev) +{ + struct dev_list_entry *dle; + int ret = 0; + + dev_dbg(dev, "%s()\n", __func__); + + if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(dev)) + return -EINVAL; + + mutex_lock(&genpd->lock); + + if (genpd->power_is_off) { + ret = -EINVAL; + goto out; + } + + list_for_each_entry(dle, &genpd->dev_list, node) + if (dle->dev == dev) { + ret = -EINVAL; + goto out; + } + + dle = kzalloc(sizeof(*dle), GFP_KERNEL); + if (!dle) { + ret = -ENOMEM; + goto out; + } + + dle->dev = dev; + dle->need_restore = false; + list_add_tail(&dle->node, &genpd->dev_list); + + spin_lock_irq(&dev->power.lock); + dev->pm_domain = &genpd->domain; + spin_unlock_irq(&dev->power.lock); + + out: + mutex_unlock(&genpd->lock); + + return ret; +} + +/** + * pm_genpd_remove_device - Remove a device from an I/O PM domain. + * @genpd: PM domain to remove the device from. + * @dev: Device to be removed. + */ +int pm_genpd_remove_device(struct generic_pm_domain *genpd, + struct device *dev) +{ + struct dev_list_entry *dle; + int ret = -EINVAL; + + dev_dbg(dev, "%s()\n", __func__); + + if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(dev)) + return -EINVAL; + + mutex_lock(&genpd->lock); + + list_for_each_entry(dle, &genpd->dev_list, node) { + if (dle->dev != dev) + continue; + + spin_lock_irq(&dev->power.lock); + dev->pm_domain = NULL; + spin_unlock_irq(&dev->power.lock); + + list_del(&dle->node); + kfree(dle); + + ret = 0; + break; + } + + mutex_unlock(&genpd->lock); + + return ret; +} + +/** + * pm_genpd_add_subdomain - Add a subdomain to an I/O PM domain. + * @genpd: Master PM domain to add the subdomain to. + * @new_subdomain: Subdomain to be added. + */ +int pm_genpd_add_subdomain(struct generic_pm_domain *genpd, + struct generic_pm_domain *new_subdomain) +{ + struct generic_pm_domain *subdomain; + int ret = 0; + + if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(new_subdomain)) + return -EINVAL; + + mutex_lock(&genpd->lock); + + if (genpd->power_is_off && !new_subdomain->power_is_off) { + ret = -EINVAL; + goto out; + } + + list_for_each_entry(subdomain, &genpd->sd_list, sd_node) { + if (subdomain == new_subdomain) { + ret = -EINVAL; + goto out; + } + } + + mutex_lock(&new_subdomain->lock); + + list_add_tail(&new_subdomain->sd_node, &genpd->sd_list); + new_subdomain->parent = genpd; + if (!subdomain->power_is_off) + genpd->sd_count++; + + mutex_unlock(&new_subdomain->lock); + + out: + mutex_unlock(&genpd->lock); + + return ret; +} + +/** + * pm_genpd_remove_subdomain - Remove a subdomain from an I/O PM domain. + * @genpd: Master PM domain to remove the subdomain from. + * @target: Subdomain to be removed. + */ +int pm_genpd_remove_subdomain(struct generic_pm_domain *genpd, + struct generic_pm_domain *target) +{ + struct generic_pm_domain *subdomain; + int ret = -EINVAL; + + if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(target)) + return -EINVAL; + + mutex_lock(&genpd->lock); + + list_for_each_entry(subdomain, &genpd->sd_list, sd_node) { + if (subdomain != target) + continue; + + mutex_lock(&subdomain->lock); + + list_del(&subdomain->sd_node); + subdomain->parent = NULL; + if (!subdomain->power_is_off) + genpd_sd_counter_dec(genpd); + + mutex_unlock(&subdomain->lock); + + ret = 0; + break; + } + + mutex_unlock(&genpd->lock); + + return ret; +} + +/** + * pm_genpd_init - Initialize a generic I/O PM domain object. + * @genpd: PM domain object to initialize. + * @gov: PM domain governor to associate with the domain (may be NULL). + * @is_off: Initial value of the domain's power_is_off field. + */ +void pm_genpd_init(struct generic_pm_domain *genpd, + struct dev_power_governor *gov, bool is_off) +{ + if (IS_ERR_OR_NULL(genpd)) + return; + + INIT_LIST_HEAD(&genpd->sd_node); + genpd->parent = NULL; + INIT_LIST_HEAD(&genpd->dev_list); + INIT_LIST_HEAD(&genpd->sd_list); + mutex_init(&genpd->lock); + genpd->gov = gov; + INIT_WORK(&genpd->power_off_work, genpd_power_off_work_fn); + genpd->in_progress = 0; + genpd->sd_count = 0; + genpd->power_is_off = is_off; + genpd->domain.ops.runtime_suspend = pm_genpd_runtime_suspend; + genpd->domain.ops.runtime_resume = pm_genpd_runtime_resume; + genpd->domain.ops.runtime_idle = pm_generic_runtime_idle; +} Index: linux-2.6/kernel/power/Kconfig =================================================================== --- linux-2.6.orig/kernel/power/Kconfig +++ linux-2.6/kernel/power/Kconfig @@ -227,3 +227,7 @@ config PM_OPP config PM_RUNTIME_CLK def_bool y depends on PM_RUNTIME && HAVE_CLK + +config PM_GENERIC_DOMAINS + bool + depends on PM