PM / Runtime: Add no_callbacks flag

Some devices, such as USB interfaces, cannot be power-managed
independently of their parents, i.e., they cannot be put in low power
while the parent remains at full power.  This patch (as1425) creates a
new "no_callbacks" flag, which tells the PM core not to invoke the
runtime-PM callback routines for the such devices but instead to
assume that the callbacks always succeed.  In addition, the
non-debugging runtime-PM sysfs attributes for the devices are removed,
since they are pretty much meaningless.

The advantage of this scheme comes not so much from avoiding the
callbacks themselves, but rather from the fact that without the need
for a process context in which to run the callbacks, more work can be
done in interrupt context.

Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>

3 files changed, 103 insertions, 8 deletions

diff --git a/drivers/base/power/power.h b/drivers/base/power/power.h
index 8b2745c69e2a..698dde742587 100644
--- a/drivers/base/power/power.h
+++ b/drivers/base/power/power.h
@@ -60,6 +60,7 @@ static inline void device_pm_move_last(struct device *dev) {}
 
 extern int dpm_sysfs_add(struct device *);
 extern void dpm_sysfs_remove(struct device *);
+extern void rpm_sysfs_remove(struct device *);
 
 #else /* CONFIG_PM */
 
diff --git a/drivers/base/power/runtime.c b/drivers/base/power/runtime.c
index ed227b7c1bb5..5bd4daa93ef1 100644
--- a/drivers/base/power/runtime.c
+++ b/drivers/base/power/runtime.c
@@ -10,8 +10,10 @@
 #include <linux/sched.h>
 #include <linux/pm_runtime.h>
 #include <linux/jiffies.h>
+#include "power.h"
 
 static int rpm_resume(struct device *dev, int rpmflags);
+static int rpm_suspend(struct device *dev, int rpmflags);
 
 /**
  * update_pm_runtime_accounting - Update the time accounting of power states
@@ -148,6 +150,12 @@ static int rpm_idle(struct device *dev, int rpmflags)
         /* Pending requests need to be canceled. */
         dev->power.request = RPM_REQ_NONE;
 
+        if (dev->power.no_callbacks) {
+                /* Assume ->runtime_idle() callback would have suspended. */
+                retval = rpm_suspend(dev, rpmflags);
+                goto out;
+        }
+
         /* Carry out an asynchronous or a synchronous idle notification. */
         if (rpmflags & RPM_ASYNC) {
                 dev->power.request = RPM_REQ_IDLE;
@@ -254,6 +262,10 @@ static int rpm_suspend(struct device *dev, int rpmflags)
                 goto repeat;
         }
 
+        dev->power.deferred_resume = false;
+        if (dev->power.no_callbacks)
+                goto no_callback;       /* Assume success. */
+
         /* Carry out an asynchronous or a synchronous suspend. */
         if (rpmflags & RPM_ASYNC) {
                 dev->power.request = RPM_REQ_SUSPEND;
@@ -265,7 +277,6 @@ static int rpm_suspend(struct device *dev, int rpmflags)
         }
 
         __update_runtime_status(dev, RPM_SUSPENDING);
-        dev->power.deferred_resume = false;
 
         if (dev->bus && dev->bus->pm && dev->bus->pm->runtime_suspend) {
                 spin_unlock_irq(&dev->power.lock);
@@ -305,6 +316,7 @@ static int rpm_suspend(struct device *dev, int rpmflags)
                         pm_runtime_cancel_pending(dev);
                 }
         } else {
+ no_callback:
                 __update_runtime_status(dev, RPM_SUSPENDED);
                 pm_runtime_deactivate_timer(dev);
 
@@ -409,6 +421,23 @@ static int rpm_resume(struct device *dev, int rpmflags)
                 goto repeat;
         }
 
+        /*
+         * See if we can skip waking up the parent.  This is safe only if
+         * power.no_callbacks is set, because otherwise we don't know whether
+         * the resume will actually succeed.
+         */
+        if (dev->power.no_callbacks && !parent && dev->parent) {
+                spin_lock(&dev->parent->power.lock);
+                if (dev->parent->power.disable_depth > 0
+                    || dev->parent->power.ignore_children
+                    || dev->parent->power.runtime_status == RPM_ACTIVE) {
+                        atomic_inc(&dev->parent->power.child_count);
+                        spin_unlock(&dev->parent->power.lock);
+                        goto no_callback;       /* Assume success. */
+                }
+                spin_unlock(&dev->parent->power.lock);
+        }
+
         /* Carry out an asynchronous or a synchronous resume. */
         if (rpmflags & RPM_ASYNC) {
                 dev->power.request = RPM_REQ_RESUME;
@@ -449,6 +478,9 @@ static int rpm_resume(struct device *dev, int rpmflags)
                 goto repeat;
         }
 
+        if (dev->power.no_callbacks)
+                goto no_callback;       /* Assume success. */
+
         __update_runtime_status(dev, RPM_RESUMING);
 
         if (dev->bus && dev->bus->pm && dev->bus->pm->runtime_resume) {
@@ -482,6 +514,7 @@ static int rpm_resume(struct device *dev, int rpmflags)
                 __update_runtime_status(dev, RPM_SUSPENDED);
                 pm_runtime_cancel_pending(dev);
         } else {
+ no_callback:
                 __update_runtime_status(dev, RPM_ACTIVE);
                 if (parent)
                         atomic_inc(&parent->power.child_count);
@@ -955,6 +988,25 @@ void pm_runtime_allow(struct device *dev)
 EXPORT_SYMBOL_GPL(pm_runtime_allow);
 
 /**
+ * pm_runtime_no_callbacks - Ignore run-time PM callbacks for a device.
+ * @dev: Device to handle.
+ *
+ * Set the power.no_callbacks flag, which tells the PM core that this
+ * device is power-managed through its parent and has no run-time PM
+ * callbacks of its own.  The run-time sysfs attributes will be removed.
+ *
+ */
+void pm_runtime_no_callbacks(struct device *dev)
+{
+        spin_lock_irq(&dev->power.lock);
+        dev->power.no_callbacks = 1;
+        spin_unlock_irq(&dev->power.lock);
+        if (device_is_registered(dev))
+                rpm_sysfs_remove(dev);
+}
+EXPORT_SYMBOL_GPL(pm_runtime_no_callbacks);
+
+/**
  * pm_runtime_init - Initialize run-time PM fields in given device object.
  * @dev: Device object to initialize.
  */
diff --git a/drivers/base/power/sysfs.c b/drivers/base/power/sysfs.c
index 8859780817e1..b5708c47ce2d 100644
--- a/drivers/base/power/sysfs.c
+++ b/drivers/base/power/sysfs.c
@@ -81,6 +81,9 @@
 static const char enabled[] = "enabled";
 static const char disabled[] = "disabled";
 
+const char power_group_name[] = "power";
+EXPORT_SYMBOL_GPL(power_group_name);
+
 #ifdef CONFIG_PM_RUNTIME
 static const char ctrl_auto[] = "auto";
 static const char ctrl_on[] = "on";
@@ -390,12 +393,6 @@ static DEVICE_ATTR(async, 0644, async_show, async_store);
 #endif /* CONFIG_PM_ADVANCED_DEBUG */
 
 static struct attribute * power_attrs[] = {
-#ifdef CONFIG_PM_RUNTIME
-        &dev_attr_control.attr,
-        &dev_attr_runtime_status.attr,
-        &dev_attr_runtime_suspended_time.attr,
-        &dev_attr_runtime_active_time.attr,
-#endif
         &dev_attr_wakeup.attr,
 #ifdef CONFIG_PM_SLEEP
         &dev_attr_wakeup_count.attr,
@@ -409,6 +406,7 @@ static struct attribute * power_attrs[] = {
 #ifdef CONFIG_PM_ADVANCED_DEBUG
         &dev_attr_async.attr,
 #ifdef CONFIG_PM_RUNTIME
+        &dev_attr_runtime_status.attr,
         &dev_attr_runtime_usage.attr,
         &dev_attr_runtime_active_kids.attr,
         &dev_attr_runtime_enabled.attr,
@@ -417,10 +415,52 @@ static struct attribute * power_attrs[] = {
         NULL,
 };
 static struct attribute_group pm_attr_group = {
-        .name   = "power",
+        .name   = power_group_name,
         .attrs  = power_attrs,
 };
 
+#ifdef CONFIG_PM_RUNTIME
+
+static struct attribute *runtime_attrs[] = {
+#ifndef CONFIG_PM_ADVANCED_DEBUG
+        &dev_attr_runtime_status.attr,
+#endif
+        &dev_attr_control.attr,
+        &dev_attr_runtime_suspended_time.attr,
+        &dev_attr_runtime_active_time.attr,
+        NULL,
+};
+static struct attribute_group pm_runtime_attr_group = {
+        .name   = power_group_name,
+        .attrs  = runtime_attrs,
+};
+
+int dpm_sysfs_add(struct device *dev)
+{
+        int rc;
+
+        rc = sysfs_create_group(&dev->kobj, &pm_attr_group);
+        if (rc == 0 && !dev->power.no_callbacks) {
+                rc = sysfs_merge_group(&dev->kobj, &pm_runtime_attr_group);
+                if (rc)
+                        sysfs_remove_group(&dev->kobj, &pm_attr_group);
+        }
+        return rc;
+}
+
+void rpm_sysfs_remove(struct device *dev)
+{
+        sysfs_unmerge_group(&dev->kobj, &pm_runtime_attr_group);
+}
+
+void dpm_sysfs_remove(struct device *dev)
+{
+        rpm_sysfs_remove(dev);
+        sysfs_remove_group(&dev->kobj, &pm_attr_group);
+}
+
+#else /* CONFIG_PM_RUNTIME */
+
 int dpm_sysfs_add(struct device * dev)
 {
         return sysfs_create_group(&dev->kobj, &pm_attr_group);
@@ -430,3 +470,5 @@ void dpm_sysfs_remove(struct device * dev)
 {
         sysfs_remove_group(&dev->kobj, &pm_attr_group);
 }
+
+#endif