mmc: add 'enable' and 'disable' methods to mmc host

MMC hosts that support power saving can use the 'enable' and 'disable'
methods to exit and enter power saving states.  An explanation of their
use is provided in the comments added to include/linux/mmc/host.h.

Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Matt Fleming <matt@console-pimps.org>
Cc: Ian Molton <ian@mnementh.co.uk>
Cc: "Roberto A. Foglietta" <roberto.foglietta@gmail.com>
Cc: Jarkko Lavinen <jarkko.lavinen@nokia.com>
Cc: Denis Karpov <ext-denis.2.karpov@nokia.com>
Cc: Pierre Ossman <pierre@ossman.eu>
Cc: Philip Langdale <philipl@overt.org>
Cc: "Madhusudhan" <madhu.cr@ti.com>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

3 files changed, 174 insertions, 6 deletions

diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
index e22d2b5576ec..fb24a096dba8 100644
--- a/drivers/mmc/core/core.c
+++ b/drivers/mmc/core/core.c
@@ -344,6 +344,101 @@ unsigned int mmc_align_data_size(struct mmc_card *card, unsigned int sz)
 EXPORT_SYMBOL(mmc_align_data_size);
 
 /**
+ *      mmc_host_enable - enable a host.
+ *      @host: mmc host to enable
+ *
+ *      Hosts that support power saving can use the 'enable' and 'disable'
+ *      methods to exit and enter power saving states. For more information
+ *      see comments for struct mmc_host_ops.
+ */
+int mmc_host_enable(struct mmc_host *host)
+{
+        if (!(host->caps & MMC_CAP_DISABLE))
+                return 0;
+
+        if (host->en_dis_recurs)
+                return 0;
+
+        if (host->nesting_cnt++)
+                return 0;
+
+        cancel_delayed_work_sync(&host->disable);
+
+        if (host->enabled)
+                return 0;
+
+        if (host->ops->enable) {
+                int err;
+
+                host->en_dis_recurs = 1;
+                err = host->ops->enable(host);
+                host->en_dis_recurs = 0;
+
+                if (err) {
+                        pr_debug("%s: enable error %d\n",
+                                 mmc_hostname(host), err);
+                        return err;
+                }
+        }
+        host->enabled = 1;
+        return 0;
+}
+EXPORT_SYMBOL(mmc_host_enable);
+
+static int mmc_host_do_disable(struct mmc_host *host, int lazy)
+{
+        if (host->ops->disable) {
+                int err;
+
+                host->en_dis_recurs = 1;
+                err = host->ops->disable(host, lazy);
+                host->en_dis_recurs = 0;
+
+                if (err < 0) {
+                        pr_debug("%s: disable error %d\n",
+                                 mmc_hostname(host), err);
+                        return err;
+                }
+                if (err > 0) {
+                        unsigned long delay = msecs_to_jiffies(err);
+
+                        mmc_schedule_delayed_work(&host->disable, delay);
+                }
+        }
+        host->enabled = 0;
+        return 0;
+}
+
+/**
+ *      mmc_host_disable - disable a host.
+ *      @host: mmc host to disable
+ *
+ *      Hosts that support power saving can use the 'enable' and 'disable'
+ *      methods to exit and enter power saving states. For more information
+ *      see comments for struct mmc_host_ops.
+ */
+int mmc_host_disable(struct mmc_host *host)
+{
+        int err;
+
+        if (!(host->caps & MMC_CAP_DISABLE))
+                return 0;
+
+        if (host->en_dis_recurs)
+                return 0;
+
+        if (--host->nesting_cnt)
+                return 0;
+
+        if (!host->enabled)
+                return 0;
+
+        err = mmc_host_do_disable(host, 0);
+        return err;
+}
+EXPORT_SYMBOL(mmc_host_disable);
+
+/**
  *      __mmc_claim_host - exclusively claim a host
  *      @host: mmc host to claim
  *      @abort: whether or not the operation should be aborted
@@ -379,11 +474,81 @@ int __mmc_claim_host(struct mmc_host *host, atomic_t *abort)
                 wake_up(&host->wq);
         spin_unlock_irqrestore(&host->lock, flags);
         remove_wait_queue(&host->wq, &wait);
+        if (!stop)
+                mmc_host_enable(host);
         return stop;
 }
 
 EXPORT_SYMBOL(__mmc_claim_host);
 
+static int mmc_try_claim_host(struct mmc_host *host)
+{
+        int claimed_host = 0;
+        unsigned long flags;
+
+        spin_lock_irqsave(&host->lock, flags);
+        if (!host->claimed) {
+                host->claimed = 1;
+                claimed_host = 1;
+        }
+        spin_unlock_irqrestore(&host->lock, flags);
+        return claimed_host;
+}
+
+static void mmc_do_release_host(struct mmc_host *host)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&host->lock, flags);
+        host->claimed = 0;
+        spin_unlock_irqrestore(&host->lock, flags);
+
+        wake_up(&host->wq);
+}
+
+void mmc_host_deeper_disable(struct work_struct *work)
+{
+        struct mmc_host *host =
+                container_of(work, struct mmc_host, disable.work);
+
+        /* If the host is claimed then we do not want to disable it anymore */
+        if (!mmc_try_claim_host(host))
+                return;
+        mmc_host_do_disable(host, 1);
+        mmc_do_release_host(host);
+}
+
+/**
+ *      mmc_host_lazy_disable - lazily disable a host.
+ *      @host: mmc host to disable
+ *
+ *      Hosts that support power saving can use the 'enable' and 'disable'
+ *      methods to exit and enter power saving states. For more information
+ *      see comments for struct mmc_host_ops.
+ */
+int mmc_host_lazy_disable(struct mmc_host *host)
+{
+        if (!(host->caps & MMC_CAP_DISABLE))
+                return 0;
+
+        if (host->en_dis_recurs)
+                return 0;
+
+        if (--host->nesting_cnt)
+                return 0;
+
+        if (!host->enabled)
+                return 0;
+
+        if (host->disable_delay) {
+                mmc_schedule_delayed_work(&host->disable,
+                                msecs_to_jiffies(host->disable_delay));
+                return 0;
+        } else
+                return mmc_host_do_disable(host, 1);
+}
+EXPORT_SYMBOL(mmc_host_lazy_disable);
+
 /**
  *      mmc_release_host - release a host
  *      @host: mmc host to release
@@ -393,15 +558,11 @@ EXPORT_SYMBOL(__mmc_claim_host);
  */
 void mmc_release_host(struct mmc_host *host)
 {
-        unsigned long flags;
-
         WARN_ON(!host->claimed);
 
-        spin_lock_irqsave(&host->lock, flags);
-        host->claimed = 0;
-        spin_unlock_irqrestore(&host->lock, flags);
+        mmc_host_lazy_disable(host);
 
-        wake_up(&host->wq);
+        mmc_do_release_host(host);
 }
 
 EXPORT_SYMBOL(mmc_release_host);
@@ -953,6 +1114,8 @@ void mmc_stop_host(struct mmc_host *host)
         spin_unlock_irqrestore(&host->lock, flags);
 #endif
 
+        if (host->caps & MMC_CAP_DISABLE)
+                cancel_delayed_work(&host->disable);
         cancel_delayed_work(&host->detect);
         mmc_flush_scheduled_work();
 
@@ -981,6 +1144,8 @@ void mmc_stop_host(struct mmc_host *host)
  */
 int mmc_suspend_host(struct mmc_host *host, pm_message_t state)
 {
+        if (host->caps & MMC_CAP_DISABLE)
+                cancel_delayed_work(&host->disable);
         cancel_delayed_work(&host->detect);
         mmc_flush_scheduled_work();
 
diff --git a/drivers/mmc/core/host.c b/drivers/mmc/core/host.c
index 5e945e64ead7..a268d12f1af0 100644
--- a/drivers/mmc/core/host.c
+++ b/drivers/mmc/core/host.c
@@ -83,6 +83,7 @@ struct mmc_host *mmc_alloc_host(int extra, struct device *dev)
         spin_lock_init(&host->lock);
         init_waitqueue_head(&host->wq);
         INIT_DELAYED_WORK(&host->detect, mmc_rescan);
+        INIT_DELAYED_WORK_DEFERRABLE(&host->disable, mmc_host_deeper_disable);
 
         /*
          * By default, hosts do not support SGIO or large requests.
diff --git a/drivers/mmc/core/host.h b/drivers/mmc/core/host.h
index c2dc3d2d9f9a..8c87e1109a34 100644
--- a/drivers/mmc/core/host.h
+++ b/drivers/mmc/core/host.h
@@ -14,5 +14,7 @@
 int mmc_register_host_class(void);
 void mmc_unregister_host_class(void);
 
+void mmc_host_deeper_disable(struct work_struct *work);
+
 #endif