1 files changed, 57 insertions, 195 deletions

diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
index 132378b89d76..14f262e9246d 100644
--- a/drivers/mmc/core/core.c
+++ b/drivers/mmc/core/core.c
@@ -188,6 +188,12 @@ mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
         struct scatterlist *sg;
 #endif
 
+        if (mrq->sbc) {
+                pr_debug("<%s: starting CMD%u arg %08x flags %08x>\n",
+                         mmc_hostname(host), mrq->sbc->opcode,
+                         mrq->sbc->arg, mrq->sbc->flags);
+        }
+
         pr_debug("%s: starting CMD%u arg %08x flags %08x\n",
                  mmc_hostname(host), mrq->cmd->opcode,
                  mrq->cmd->arg, mrq->cmd->flags);
@@ -243,16 +249,17 @@ static void mmc_wait_done(struct mmc_request *mrq)
         complete(&mrq->completion);
 }
 
-static void __mmc_start_req(struct mmc_host *host, struct mmc_request *mrq)
+static int __mmc_start_req(struct mmc_host *host, struct mmc_request *mrq)
 {
         init_completion(&mrq->completion);
         mrq->done = mmc_wait_done;
         if (mmc_card_removed(host->card)) {
                 mrq->cmd->error = -ENOMEDIUM;
                 complete(&mrq->completion);
-                return;
+                return -ENOMEDIUM;
         }
         mmc_start_request(host, mrq);
+        return 0;
 }
 
 static void mmc_wait_for_req_done(struct mmc_host *host,
@@ -336,6 +343,7 @@ struct mmc_async_req *mmc_start_req(struct mmc_host *host,
                                     struct mmc_async_req *areq, int *error)
 {
         int err = 0;
+        int start_err = 0;
         struct mmc_async_req *data = host->areq;
 
         /* Prepare a new request */
@@ -345,30 +353,23 @@ struct mmc_async_req *mmc_start_req(struct mmc_host *host,
         if (host->areq) {
                 mmc_wait_for_req_done(host, host->areq->mrq);
                 err = host->areq->err_check(host->card, host->areq);
-                if (err) {
-                        /* post process the completed failed request */
-                        mmc_post_req(host, host->areq->mrq, 0);
-                        if (areq)
-                                /*
-                                 * Cancel the new prepared request, because
-                                 * it can't run until the failed
-                                 * request has been properly handled.
-                                 */
-                                mmc_post_req(host, areq->mrq, -EINVAL);
-
-                        host->areq = NULL;
-                        goto out;
-                }
         }
 
-        if (areq)
-                __mmc_start_req(host, areq->mrq);
+        if (!err && areq)
+                start_err = __mmc_start_req(host, areq->mrq);
 
         if (host->areq)
                 mmc_post_req(host, host->areq->mrq, 0);
 
-        host->areq = areq;
- out:
+         /* Cancel a prepared request if it was not started. */
+        if ((err || start_err) && areq)
+                        mmc_post_req(host, areq->mrq, -EINVAL);
+
+        if (err)
+                host->areq = NULL;
+        else
+                host->areq = areq;
+
         if (error)
                 *error = err;
         return data;
@@ -599,105 +600,6 @@ 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;
-                mmc_host_clk_hold(host);
-                err = host->ops->enable(host);
-                mmc_host_clk_release(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;
-                mmc_host_clk_hold(host);
-                err = host->ops->disable(host, lazy);
-                mmc_host_clk_release(host);
-                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
@@ -735,8 +637,8 @@ 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);
+        if (host->ops->enable && !stop && host->claim_cnt == 1)
+                host->ops->enable(host);
         return stop;
 }
 
@@ -761,21 +663,28 @@ int mmc_try_claim_host(struct mmc_host *host)
                 claimed_host = 1;
         }
         spin_unlock_irqrestore(&host->lock, flags);
+        if (host->ops->enable && claimed_host && host->claim_cnt == 1)
+                host->ops->enable(host);
         return claimed_host;
 }
 EXPORT_SYMBOL(mmc_try_claim_host);
 
 /**
- *      mmc_do_release_host - release a claimed host
+ *      mmc_release_host - release a host
  *      @host: mmc host to release
  *
- *      If you successfully claimed a host, this function will
- *      release it again.
+ *      Release a MMC host, allowing others to claim the host
+ *      for their operations.
  */
-void mmc_do_release_host(struct mmc_host *host)
+void mmc_release_host(struct mmc_host *host)
 {
         unsigned long flags;
 
+        WARN_ON(!host->claimed);
+
+        if (host->ops->disable && host->claim_cnt == 1)
+                host->ops->disable(host);
+
         spin_lock_irqsave(&host->lock, flags);
         if (--host->claim_cnt) {
                 /* Release for nested claim */
@@ -787,67 +696,6 @@ void mmc_do_release_host(struct mmc_host *host)
                 wake_up(&host->wq);
         }
 }
-EXPORT_SYMBOL(mmc_do_release_host);
-
-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
- *
- *      Release a MMC host, allowing others to claim the host
- *      for their operations.
- */
-void mmc_release_host(struct mmc_host *host)
-{
-        WARN_ON(!host->claimed);
-
-        mmc_host_lazy_disable(host);
-
-        mmc_do_release_host(host);
-}
-
 EXPORT_SYMBOL(mmc_release_host);
 
 /*
@@ -2115,18 +1963,36 @@ int _mmc_detect_card_removed(struct mmc_host *host)
 int mmc_detect_card_removed(struct mmc_host *host)
 {
         struct mmc_card *card = host->card;
+        int ret;
 
         WARN_ON(!host->claimed);
+
+        if (!card)
+                return 1;
+
+        ret = mmc_card_removed(card);
         /*
          * The card will be considered unchanged unless we have been asked to
          * detect a change or host requires polling to provide card detection.
          */
-        if (card && !host->detect_change && !(host->caps & MMC_CAP_NEEDS_POLL))
-                return mmc_card_removed(card);
+        if (!host->detect_change && !(host->caps & MMC_CAP_NEEDS_POLL) &&
+            !(host->caps2 & MMC_CAP2_DETECT_ON_ERR))
+                return ret;
 
         host->detect_change = 0;
+        if (!ret) {
+                ret = _mmc_detect_card_removed(host);
+                if (ret && (host->caps2 & MMC_CAP2_DETECT_ON_ERR)) {
+                        /*
+                         * Schedule a detect work as soon as possible to let a
+                         * rescan handle the card removal.
+                         */
+                        cancel_delayed_work(&host->detect);
+                        mmc_detect_change(host, 0);
+                }
+        }
 
-        return _mmc_detect_card_removed(host);
+        return ret;
 }
 EXPORT_SYMBOL(mmc_detect_card_removed);
 
@@ -2203,8 +2069,6 @@ 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_sync(&host->detect);
         mmc_flush_scheduled_work();
 
@@ -2399,13 +2263,11 @@ int mmc_suspend_host(struct mmc_host *host)
 {
         int err = 0;
 
-        if (host->caps & MMC_CAP_DISABLE)
-                cancel_delayed_work(&host->disable);
         cancel_delayed_work(&host->detect);
         mmc_flush_scheduled_work();
         if (mmc_try_claim_host(host)) {
                 err = mmc_cache_ctrl(host, 0);
-                mmc_do_release_host(host);
+                mmc_release_host(host);
         } else {
                 err = -EBUSY;
         }
@@ -2426,7 +2288,7 @@ int mmc_suspend_host(struct mmc_host *host)
                         if (host->bus_ops->suspend) {
                                 err = host->bus_ops->suspend(host);
                         }
-                        mmc_do_release_host(host);
+                        mmc_release_host(host);
 
                         if (err == -ENOSYS || !host->bus_ops->resume) {
                                 /*