1 files changed, 536 insertions, 15 deletions

diff --git a/drivers/base/power/domain.c b/drivers/base/power/domain.c
index f14ba32818dc..33086e9afaf6 100644
--- a/drivers/base/power/domain.c
+++ b/drivers/base/power/domain.c
@@ -21,7 +21,7 @@ static struct generic_pm_domain *dev_to_genpd(struct device *dev)
         if (IS_ERR_OR_NULL(dev->pm_domain))
                 return ERR_PTR(-EINVAL);
 
-        return container_of(dev->pm_domain, struct generic_pm_domain, domain);
+        return pd_to_genpd(dev->pm_domain);
 }
 
 static void genpd_sd_counter_dec(struct generic_pm_domain *genpd)
@@ -46,7 +46,8 @@ static int pm_genpd_poweron(struct generic_pm_domain *genpd)
                 mutex_lock(&genpd->parent->lock);
         mutex_lock_nested(&genpd->lock, SINGLE_DEPTH_NESTING);
 
-        if (!genpd->power_is_off)
+        if (!genpd->power_is_off
+            || (genpd->prepared_count > 0 && genpd->suspend_power_off))
                 goto out;
 
         if (genpd->parent && genpd->parent->power_is_off) {
@@ -155,7 +156,7 @@ static int pm_genpd_poweroff(struct generic_pm_domain *genpd)
         unsigned int not_suspended;
         int ret;
 
-        if (genpd->power_is_off)
+        if (genpd->power_is_off || genpd->prepared_count > 0)
                 return 0;
 
         if (genpd->sd_count > 0)
@@ -260,6 +261,27 @@ static int pm_genpd_runtime_suspend(struct device *dev)
 }
 
 /**
+ * __pm_genpd_runtime_resume - Resume a device belonging to I/O PM domain.
+ * @dev: Device to resume.
+ * @genpd: PM domain the device belongs to.
+ */
+static void __pm_genpd_runtime_resume(struct device *dev,
+                                      struct generic_pm_domain *genpd)
+{
+        struct dev_list_entry *dle;
+
+        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);
+}
+
+/**
  * pm_genpd_runtime_resume - Resume a device belonging to I/O PM domain.
  * @dev: Device to resume.
  *
@@ -270,7 +292,6 @@ static int pm_genpd_runtime_suspend(struct device *dev)
 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__);
@@ -284,17 +305,7 @@ static int pm_genpd_runtime_resume(struct device *dev)
                 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);
-
+        __pm_genpd_runtime_resume(dev, genpd);
         mutex_unlock(&genpd->lock);
 
         return 0;
@@ -303,12 +314,493 @@ static int pm_genpd_runtime_resume(struct device *dev)
 #else
 
 static inline void genpd_power_off_work_fn(struct work_struct *work) {}
+static inline void __pm_genpd_runtime_resume(struct device *dev,
+                                             struct generic_pm_domain *genpd) {}
 
 #define pm_genpd_runtime_suspend        NULL
 #define pm_genpd_runtime_resume         NULL
 
 #endif /* CONFIG_PM_RUNTIME */
 
+#ifdef CONFIG_PM_SLEEP
+
+/**
+ * pm_genpd_sync_poweroff - Synchronously power off a PM domain and its parents.
+ * @genpd: PM domain to power off, if possible.
+ *
+ * Check if the given PM domain can be powered off (during system suspend or
+ * hibernation) and do that if so.  Also, in that case propagate to its parent.
+ *
+ * This function is only called in "noirq" stages of system power transitions,
+ * so it need not acquire locks (all of the "noirq" callbacks are executed
+ * sequentially, so it is guaranteed that it will never run twice in parallel).
+ */
+static void pm_genpd_sync_poweroff(struct generic_pm_domain *genpd)
+{
+        struct generic_pm_domain *parent = genpd->parent;
+
+        if (genpd->power_is_off)
+                return;
+
+        if (genpd->suspended_count != genpd->device_count || genpd->sd_count > 0)
+                return;
+
+        if (genpd->power_off)
+                genpd->power_off(genpd);
+
+        genpd->power_is_off = true;
+        if (parent) {
+                genpd_sd_counter_dec(parent);
+                pm_genpd_sync_poweroff(parent);
+        }
+}
+
+/**
+ * pm_genpd_prepare - Start power transition of a device in a PM domain.
+ * @dev: Device to start the transition of.
+ *
+ * Start a power transition of a device (during a system-wide power transition)
+ * 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_prepare(struct device *dev)
+{
+        struct generic_pm_domain *genpd;
+
+        dev_dbg(dev, "%s()\n", __func__);
+
+        genpd = dev_to_genpd(dev);
+        if (IS_ERR(genpd))
+                return -EINVAL;
+
+        mutex_lock(&genpd->lock);
+
+        if (genpd->prepared_count++ == 0)
+                genpd->suspend_power_off = genpd->power_is_off;
+
+        if (genpd->suspend_power_off) {
+                mutex_unlock(&genpd->lock);
+                return 0;
+        }
+
+        /*
+         * If the device is in the (runtime) "suspended" state, call
+         * .start_device() for it, if defined.
+         */
+        if (pm_runtime_suspended(dev))
+                __pm_genpd_runtime_resume(dev, genpd);
+
+        /*
+         * Do not check if runtime resume is pending at this point, because it
+         * has been taken care of already and if pm_genpd_poweron() ran at this
+         * point as a result of the check, it would deadlock.
+         */
+        __pm_runtime_disable(dev, false);
+
+        mutex_unlock(&genpd->lock);
+
+        return pm_generic_prepare(dev);
+}
+
+/**
+ * pm_genpd_suspend - Suspend a device belonging to an I/O PM domain.
+ * @dev: Device to suspend.
+ *
+ * Suspend 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_suspend(struct device *dev)
+{
+        struct generic_pm_domain *genpd;
+
+        dev_dbg(dev, "%s()\n", __func__);
+
+        genpd = dev_to_genpd(dev);
+        if (IS_ERR(genpd))
+                return -EINVAL;
+
+        return genpd->suspend_power_off ? 0 : pm_generic_suspend(dev);
+}
+
+/**
+ * pm_genpd_suspend_noirq - Late suspend of a device from an I/O PM domain.
+ * @dev: Device to suspend.
+ *
+ * Carry out a late 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_suspend_noirq(struct device *dev)
+{
+        struct generic_pm_domain *genpd;
+        int ret;
+
+        dev_dbg(dev, "%s()\n", __func__);
+
+        genpd = dev_to_genpd(dev);
+        if (IS_ERR(genpd))
+                return -EINVAL;
+
+        if (genpd->suspend_power_off)
+                return 0;
+
+        ret = pm_generic_suspend_noirq(dev);
+        if (ret)
+                return ret;
+
+        if (genpd->stop_device)
+                genpd->stop_device(dev);
+
+        /*
+         * Since all of the "noirq" callbacks are executed sequentially, it is
+         * guaranteed that this function will never run twice in parallel for
+         * the same PM domain, so it is not necessary to use locking here.
+         */
+        genpd->suspended_count++;
+        pm_genpd_sync_poweroff(genpd);
+
+        return 0;
+}
+
+/**
+ * pm_genpd_resume_noirq - Early resume of a device from an I/O power domain.
+ * @dev: Device to resume.
+ *
+ * Carry out an early 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 power domain consisting of I/O
+ * devices.
+ */
+static int pm_genpd_resume_noirq(struct device *dev)
+{
+        struct generic_pm_domain *genpd;
+
+        dev_dbg(dev, "%s()\n", __func__);
+
+        genpd = dev_to_genpd(dev);
+        if (IS_ERR(genpd))
+                return -EINVAL;
+
+        if (genpd->suspend_power_off)
+                return 0;
+
+        /*
+         * Since all of the "noirq" callbacks are executed sequentially, it is
+         * guaranteed that this function will never run twice in parallel for
+         * the same PM domain, so it is not necessary to use locking here.
+         */
+        pm_genpd_poweron(genpd);
+        genpd->suspended_count--;
+        if (genpd->start_device)
+                genpd->start_device(dev);
+
+        return pm_generic_resume_noirq(dev);
+}
+
+/**
+ * pm_genpd_resume - Resume a device belonging to an I/O power domain.
+ * @dev: Device to resume.
+ *
+ * Resume 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 power domain consisting of I/O devices.
+ */
+static int pm_genpd_resume(struct device *dev)
+{
+        struct generic_pm_domain *genpd;
+
+        dev_dbg(dev, "%s()\n", __func__);
+
+        genpd = dev_to_genpd(dev);
+        if (IS_ERR(genpd))
+                return -EINVAL;
+
+        return genpd->suspend_power_off ? 0 : pm_generic_resume(dev);
+}
+
+/**
+ * pm_genpd_freeze - Freeze a device belonging to an I/O power domain.
+ * @dev: Device to freeze.
+ *
+ * Freeze 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 power domain consisting of I/O devices.
+ */
+static int pm_genpd_freeze(struct device *dev)
+{
+        struct generic_pm_domain *genpd;
+
+        dev_dbg(dev, "%s()\n", __func__);
+
+        genpd = dev_to_genpd(dev);
+        if (IS_ERR(genpd))
+                return -EINVAL;
+
+        return genpd->suspend_power_off ? 0 : pm_generic_freeze(dev);
+}
+
+/**
+ * pm_genpd_freeze_noirq - Late freeze of a device from an I/O power domain.
+ * @dev: Device to freeze.
+ *
+ * Carry out a late freeze 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 power domain consisting of I/O
+ * devices.
+ */
+static int pm_genpd_freeze_noirq(struct device *dev)
+{
+        struct generic_pm_domain *genpd;
+        int ret;
+
+        dev_dbg(dev, "%s()\n", __func__);
+
+        genpd = dev_to_genpd(dev);
+        if (IS_ERR(genpd))
+                return -EINVAL;
+
+        if (genpd->suspend_power_off)
+                return 0;
+
+        ret = pm_generic_freeze_noirq(dev);
+        if (ret)
+                return ret;
+
+        if (genpd->stop_device)
+                genpd->stop_device(dev);
+
+        return 0;
+}
+
+/**
+ * pm_genpd_thaw_noirq - Early thaw of a device from an I/O power domain.
+ * @dev: Device to thaw.
+ *
+ * Carry out an early thaw 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 power domain consisting of I/O
+ * devices.
+ */
+static int pm_genpd_thaw_noirq(struct device *dev)
+{
+        struct generic_pm_domain *genpd;
+
+        dev_dbg(dev, "%s()\n", __func__);
+
+        genpd = dev_to_genpd(dev);
+        if (IS_ERR(genpd))
+                return -EINVAL;
+
+        if (genpd->suspend_power_off)
+                return 0;
+
+        if (genpd->start_device)
+                genpd->start_device(dev);
+
+        return pm_generic_thaw_noirq(dev);
+}
+
+/**
+ * pm_genpd_thaw - Thaw a device belonging to an I/O power domain.
+ * @dev: Device to thaw.
+ *
+ * Thaw 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 power domain consisting of I/O devices.
+ */
+static int pm_genpd_thaw(struct device *dev)
+{
+        struct generic_pm_domain *genpd;
+
+        dev_dbg(dev, "%s()\n", __func__);
+
+        genpd = dev_to_genpd(dev);
+        if (IS_ERR(genpd))
+                return -EINVAL;
+
+        return genpd->suspend_power_off ? 0 : pm_generic_thaw(dev);
+}
+
+/**
+ * pm_genpd_dev_poweroff - Power off a device belonging to an I/O PM domain.
+ * @dev: Device to suspend.
+ *
+ * Power off 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_dev_poweroff(struct device *dev)
+{
+        struct generic_pm_domain *genpd;
+
+        dev_dbg(dev, "%s()\n", __func__);
+
+        genpd = dev_to_genpd(dev);
+        if (IS_ERR(genpd))
+                return -EINVAL;
+
+        return genpd->suspend_power_off ? 0 : pm_generic_poweroff(dev);
+}
+
+/**
+ * pm_genpd_dev_poweroff_noirq - Late power off of a device from a PM domain.
+ * @dev: Device to suspend.
+ *
+ * Carry out a late powering off 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_dev_poweroff_noirq(struct device *dev)
+{
+        struct generic_pm_domain *genpd;
+        int ret;
+
+        dev_dbg(dev, "%s()\n", __func__);
+
+        genpd = dev_to_genpd(dev);
+        if (IS_ERR(genpd))
+                return -EINVAL;
+
+        if (genpd->suspend_power_off)
+                return 0;
+
+        ret = pm_generic_poweroff_noirq(dev);
+        if (ret)
+                return ret;
+
+        if (genpd->stop_device)
+                genpd->stop_device(dev);
+
+        /*
+         * Since all of the "noirq" callbacks are executed sequentially, it is
+         * guaranteed that this function will never run twice in parallel for
+         * the same PM domain, so it is not necessary to use locking here.
+         */
+        genpd->suspended_count++;
+        pm_genpd_sync_poweroff(genpd);
+
+        return 0;
+}
+
+/**
+ * pm_genpd_restore_noirq - Early restore of a device from an I/O power domain.
+ * @dev: Device to resume.
+ *
+ * Carry out an early restore 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 power domain consisting of I/O
+ * devices.
+ */
+static int pm_genpd_restore_noirq(struct device *dev)
+{
+        struct generic_pm_domain *genpd;
+
+        dev_dbg(dev, "%s()\n", __func__);
+
+        genpd = dev_to_genpd(dev);
+        if (IS_ERR(genpd))
+                return -EINVAL;
+
+        /*
+         * Since all of the "noirq" callbacks are executed sequentially, it is
+         * guaranteed that this function will never run twice in parallel for
+         * the same PM domain, so it is not necessary to use locking here.
+         */
+        genpd->power_is_off = true;
+        if (genpd->suspend_power_off) {
+                /*
+                 * The boot kernel might put the domain into the power on state,
+                 * so make sure it really is powered off.
+                 */
+                if (genpd->power_off)
+                        genpd->power_off(genpd);
+                return 0;
+        }
+
+        pm_genpd_poweron(genpd);
+        genpd->suspended_count--;
+        if (genpd->start_device)
+                genpd->start_device(dev);
+
+        return pm_generic_restore_noirq(dev);
+}
+
+/**
+ * pm_genpd_restore - Restore a device belonging to an I/O power domain.
+ * @dev: Device to resume.
+ *
+ * Restore 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 power domain consisting of I/O devices.
+ */
+static int pm_genpd_restore(struct device *dev)
+{
+        struct generic_pm_domain *genpd;
+
+        dev_dbg(dev, "%s()\n", __func__);
+
+        genpd = dev_to_genpd(dev);
+        if (IS_ERR(genpd))
+                return -EINVAL;
+
+        return genpd->suspend_power_off ? 0 : pm_generic_restore(dev);
+}
+
+/**
+ * pm_genpd_complete - Complete power transition of a device in a power domain.
+ * @dev: Device to complete the transition of.
+ *
+ * Complete a power transition of a device (during a system-wide power
+ * transition) under the assumption that its pm_domain field points to the
+ * domain member of an object of type struct generic_pm_domain representing
+ * a power domain consisting of I/O devices.
+ */
+static void pm_genpd_complete(struct device *dev)
+{
+        struct generic_pm_domain *genpd;
+        bool run_complete;
+
+        dev_dbg(dev, "%s()\n", __func__);
+
+        genpd = dev_to_genpd(dev);
+        if (IS_ERR(genpd))
+                return;
+
+        mutex_lock(&genpd->lock);
+
+        run_complete = !genpd->suspend_power_off;
+        if (--genpd->prepared_count == 0)
+                genpd->suspend_power_off = false;
+
+        mutex_unlock(&genpd->lock);
+
+        if (run_complete) {
+                pm_generic_complete(dev);
+                pm_runtime_enable(dev);
+        }
+}
+
+#else
+
+#define pm_genpd_prepare                NULL
+#define pm_genpd_suspend                NULL
+#define pm_genpd_suspend_noirq          NULL
+#define pm_genpd_resume_noirq           NULL
+#define pm_genpd_resume                 NULL
+#define pm_genpd_freeze                 NULL
+#define pm_genpd_freeze_noirq           NULL
+#define pm_genpd_thaw_noirq             NULL
+#define pm_genpd_thaw                   NULL
+#define pm_genpd_dev_poweroff_noirq     NULL
+#define pm_genpd_dev_poweroff           NULL
+#define pm_genpd_restore_noirq          NULL
+#define pm_genpd_restore                NULL
+#define pm_genpd_complete               NULL
+
+#endif /* CONFIG_PM_SLEEP */
+
 /**
  * pm_genpd_add_device - Add a device to an I/O PM domain.
  * @genpd: PM domain to add the device to.
@@ -331,6 +823,11 @@ int pm_genpd_add_device(struct generic_pm_domain *genpd, struct device *dev)
                 goto out;
         }
 
+        if (genpd->prepared_count > 0) {
+                ret = -EAGAIN;
+                goto out;
+        }
+
         list_for_each_entry(dle, &genpd->dev_list, node)
                 if (dle->dev == dev) {
                         ret = -EINVAL;
@@ -346,6 +843,7 @@ int pm_genpd_add_device(struct generic_pm_domain *genpd, struct device *dev)
         dle->dev = dev;
         dle->need_restore = false;
         list_add_tail(&dle->node, &genpd->dev_list);
+        genpd->device_count++;
 
         spin_lock_irq(&dev->power.lock);
         dev->pm_domain = &genpd->domain;
@@ -375,6 +873,11 @@ int pm_genpd_remove_device(struct generic_pm_domain *genpd,
 
         mutex_lock(&genpd->lock);
 
+        if (genpd->prepared_count > 0) {
+                ret = -EAGAIN;
+                goto out;
+        }
+
         list_for_each_entry(dle, &genpd->dev_list, node) {
                 if (dle->dev != dev)
                         continue;
@@ -383,6 +886,7 @@ int pm_genpd_remove_device(struct generic_pm_domain *genpd,
                 dev->pm_domain = NULL;
                 spin_unlock_irq(&dev->power.lock);
 
+                genpd->device_count--;
                 list_del(&dle->node);
                 kfree(dle);
 
@@ -390,6 +894,7 @@ int pm_genpd_remove_device(struct generic_pm_domain *genpd,
                 break;
         }
 
+ out:
         mutex_unlock(&genpd->lock);
 
         return ret;
@@ -498,7 +1003,23 @@ void pm_genpd_init(struct generic_pm_domain *genpd,
         genpd->in_progress = 0;
         genpd->sd_count = 0;
         genpd->power_is_off = is_off;
+        genpd->device_count = 0;
+        genpd->suspended_count = 0;
         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;
+        genpd->domain.ops.prepare = pm_genpd_prepare;
+        genpd->domain.ops.suspend = pm_genpd_suspend;
+        genpd->domain.ops.suspend_noirq = pm_genpd_suspend_noirq;
+        genpd->domain.ops.resume_noirq = pm_genpd_resume_noirq;
+        genpd->domain.ops.resume = pm_genpd_resume;
+        genpd->domain.ops.freeze = pm_genpd_freeze;
+        genpd->domain.ops.freeze_noirq = pm_genpd_freeze_noirq;
+        genpd->domain.ops.thaw_noirq = pm_genpd_thaw_noirq;
+        genpd->domain.ops.thaw = pm_genpd_thaw;
+        genpd->domain.ops.poweroff = pm_genpd_dev_poweroff;
+        genpd->domain.ops.poweroff_noirq = pm_genpd_dev_poweroff_noirq;
+        genpd->domain.ops.restore_noirq = pm_genpd_restore_noirq;
+        genpd->domain.ops.restore = pm_genpd_restore;
+        genpd->domain.ops.complete = pm_genpd_complete;
 }