1 files changed, 125 insertions, 41 deletions

diff --git a/drivers/base/power/domain_governor.c b/drivers/base/power/domain_governor.c
index 66a265bf5867..28dee3053f1f 100644
--- a/drivers/base/power/domain_governor.c
+++ b/drivers/base/power/domain_governor.c
@@ -14,6 +14,31 @@
 
 #ifdef CONFIG_PM_RUNTIME
 
+static int dev_update_qos_constraint(struct device *dev, void *data)
+{
+        s64 *constraint_ns_p = data;
+        s32 constraint_ns = -1;
+
+        if (dev->power.subsys_data && dev->power.subsys_data->domain_data)
+                constraint_ns = dev_gpd_data(dev)->td.effective_constraint_ns;
+
+        if (constraint_ns < 0) {
+                constraint_ns = dev_pm_qos_read_value(dev);
+                constraint_ns *= NSEC_PER_USEC;
+        }
+        if (constraint_ns == 0)
+                return 0;
+
+        /*
+         * constraint_ns cannot be negative here, because the device has been
+         * suspended.
+         */
+        if (constraint_ns < *constraint_ns_p || *constraint_ns_p == 0)
+                *constraint_ns_p = constraint_ns;
+
+        return 0;
+}
+
 /**
  * default_stop_ok - Default PM domain governor routine for stopping devices.
  * @dev: Device to check.
@@ -21,14 +46,52 @@
 bool default_stop_ok(struct device *dev)
 {
         struct gpd_timing_data *td = &dev_gpd_data(dev)->td;
+        unsigned long flags;
+        s64 constraint_ns;
 
         dev_dbg(dev, "%s()\n", __func__);
 
-        if (dev->power.max_time_suspended_ns < 0 || td->break_even_ns == 0)
-                return true;
+        spin_lock_irqsave(&dev->power.lock, flags);
+
+        if (!td->constraint_changed) {
+                bool ret = td->cached_stop_ok;
 
-        return td->stop_latency_ns + td->start_latency_ns < td->break_even_ns
-                && td->break_even_ns < dev->power.max_time_suspended_ns;
+                spin_unlock_irqrestore(&dev->power.lock, flags);
+                return ret;
+        }
+        td->constraint_changed = false;
+        td->cached_stop_ok = false;
+        td->effective_constraint_ns = -1;
+        constraint_ns = __dev_pm_qos_read_value(dev);
+
+        spin_unlock_irqrestore(&dev->power.lock, flags);
+
+        if (constraint_ns < 0)
+                return false;
+
+        constraint_ns *= NSEC_PER_USEC;
+        /*
+         * We can walk the children without any additional locking, because
+         * they all have been suspended at this point and their
+         * effective_constraint_ns fields won't be modified in parallel with us.
+         */
+        if (!dev->power.ignore_children)
+                device_for_each_child(dev, &constraint_ns,
+                                      dev_update_qos_constraint);
+
+        if (constraint_ns > 0) {
+                constraint_ns -= td->start_latency_ns;
+                if (constraint_ns == 0)
+                        return false;
+        }
+        td->effective_constraint_ns = constraint_ns;
+        td->cached_stop_ok = constraint_ns > td->stop_latency_ns ||
+                                constraint_ns == 0;
+        /*
+         * The children have been suspended already, so we don't need to take
+         * their stop latencies into account here.
+         */
+        return td->cached_stop_ok;
 }
 
 /**
@@ -42,9 +105,27 @@ static bool default_power_down_ok(struct dev_pm_domain *pd)
         struct generic_pm_domain *genpd = pd_to_genpd(pd);
         struct gpd_link *link;
         struct pm_domain_data *pdd;
-        s64 min_dev_off_time_ns;
+        s64 min_off_time_ns;
         s64 off_on_time_ns;
-        ktime_t time_now = ktime_get();
+
+        if (genpd->max_off_time_changed) {
+                struct gpd_link *link;
+
+                /*
+                 * We have to invalidate the cached results for the masters, so
+                 * use the observation that default_power_down_ok() is not
+                 * going to be called for any master until this instance
+                 * returns.
+                 */
+                list_for_each_entry(link, &genpd->slave_links, slave_node)
+                        link->master->max_off_time_changed = true;
+
+                genpd->max_off_time_changed = false;
+                genpd->cached_power_down_ok = false;
+                genpd->max_off_time_ns = -1;
+        } else {
+                return genpd->cached_power_down_ok;
+        }
 
         off_on_time_ns = genpd->power_off_latency_ns +
                                 genpd->power_on_latency_ns;
@@ -61,6 +142,7 @@ static bool default_power_down_ok(struct dev_pm_domain *pd)
                                 to_gpd_data(pdd)->td.save_state_latency_ns;
         }
 
+        min_off_time_ns = -1;
         /*
          * Check if subdomains can be off for enough time.
          *
@@ -73,8 +155,6 @@ static bool default_power_down_ok(struct dev_pm_domain *pd)
                 if (sd_max_off_ns < 0)
                         continue;
 
-                sd_max_off_ns -= ktime_to_ns(ktime_sub(time_now,
-                                                       sd->power_off_time));
                 /*
                  * Check if the subdomain is allowed to be off long enough for
                  * the current domain to turn off and on (that's how much time
@@ -82,60 +162,64 @@ static bool default_power_down_ok(struct dev_pm_domain *pd)
                  */
                 if (sd_max_off_ns <= off_on_time_ns)
                         return false;
+
+                if (min_off_time_ns > sd_max_off_ns || min_off_time_ns < 0)
+                        min_off_time_ns = sd_max_off_ns;
         }
 
         /*
          * Check if the devices in the domain can be off enough time.
          */
-        min_dev_off_time_ns = -1;
         list_for_each_entry(pdd, &genpd->dev_list, list_node) {
                 struct gpd_timing_data *td;
-                struct device *dev = pdd->dev;
-                s64 dev_off_time_ns;
+                s64 constraint_ns;
 
-                if (!dev->driver || dev->power.max_time_suspended_ns < 0)
+                if (!pdd->dev->driver)
                         continue;
 
+                /*
+                 * Check if the device is allowed to be off long enough for the
+                 * domain to turn off and on (that's how much time it will
+                 * have to wait worst case).
+                 */
                 td = &to_gpd_data(pdd)->td;
-                dev_off_time_ns = dev->power.max_time_suspended_ns -
-                        (td->start_latency_ns + td->restore_state_latency_ns +
-                                ktime_to_ns(ktime_sub(time_now,
-                                                dev->power.suspend_time)));
-                if (dev_off_time_ns <= off_on_time_ns)
-                        return false;
-
-                if (min_dev_off_time_ns > dev_off_time_ns
-                    || min_dev_off_time_ns < 0)
-                        min_dev_off_time_ns = dev_off_time_ns;
-        }
+                constraint_ns = td->effective_constraint_ns;
+                /* default_stop_ok() need not be called before us. */
+                if (constraint_ns < 0) {
+                        constraint_ns = dev_pm_qos_read_value(pdd->dev);
+                        constraint_ns *= NSEC_PER_USEC;
+                }
+                if (constraint_ns == 0)
+                        continue;
 
-        if (min_dev_off_time_ns < 0) {
                 /*
-                 * There are no latency constraints, so the domain can spend
-                 * arbitrary time in the "off" state.
+                 * constraint_ns cannot be negative here, because the device has
+                 * been suspended.
                  */
-                genpd->max_off_time_ns = -1;
-                return true;
+                constraint_ns -= td->restore_state_latency_ns;
+                if (constraint_ns <= off_on_time_ns)
+                        return false;
+
+                if (min_off_time_ns > constraint_ns || min_off_time_ns < 0)
+                        min_off_time_ns = constraint_ns;
         }
 
+        genpd->cached_power_down_ok = true;
+
         /*
-         * The difference between the computed minimum delta and the time needed
-         * to turn the domain on is the maximum theoretical time this domain can
-         * spend in the "off" state.
+         * If the computed minimum device off time is negative, there are no
+         * latency constraints, so the domain can spend arbitrary time in the
+         * "off" state.
          */
-        min_dev_off_time_ns -= genpd->power_on_latency_ns;
+        if (min_off_time_ns < 0)
+                return true;
 
         /*
-         * If the difference between the computed minimum delta and the time
-         * needed to turn the domain off and back on on is smaller than the
-         * domain's power break even time, removing power from the domain is not
-         * worth it.
+         * The difference between the computed minimum subdomain or device off
+         * time and the time needed to turn the domain on is the maximum
+         * theoretical time this domain can spend in the "off" state.
          */
-        if (genpd->break_even_ns >
-            min_dev_off_time_ns - genpd->power_off_latency_ns)
-                return false;
-
-        genpd->max_off_time_ns = min_dev_off_time_ns;
+        genpd->max_off_time_ns = min_off_time_ns - genpd->power_on_latency_ns;
         return true;
 }