1 files changed, 418 insertions, 43 deletions

diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
index 91a0a7460ebb..5278ffb20e74 100644
--- a/drivers/mmc/core/core.c
+++ b/drivers/mmc/core/core.c
@@ -24,6 +24,8 @@
 #include <linux/regulator/consumer.h>
 #include <linux/pm_runtime.h>
 #include <linux/suspend.h>
+#include <linux/fault-inject.h>
+#include <linux/random.h>
 
 #include <linux/mmc/card.h>
 #include <linux/mmc/host.h>
@@ -83,6 +85,43 @@ static void mmc_flush_scheduled_work(void)
         flush_workqueue(workqueue);
 }
 
+#ifdef CONFIG_FAIL_MMC_REQUEST
+
+/*
+ * Internal function. Inject random data errors.
+ * If mmc_data is NULL no errors are injected.
+ */
+static void mmc_should_fail_request(struct mmc_host *host,
+                                    struct mmc_request *mrq)
+{
+        struct mmc_command *cmd = mrq->cmd;
+        struct mmc_data *data = mrq->data;
+        static const int data_errors[] = {
+                -ETIMEDOUT,
+                -EILSEQ,
+                -EIO,
+        };
+
+        if (!data)
+                return;
+
+        if (cmd->error || data->error ||
+            !should_fail(&host->fail_mmc_request, data->blksz * data->blocks))
+                return;
+
+        data->error = data_errors[random32() % ARRAY_SIZE(data_errors)];
+        data->bytes_xfered = (random32() % (data->bytes_xfered >> 9)) << 9;
+}
+
+#else /* CONFIG_FAIL_MMC_REQUEST */
+
+static inline void mmc_should_fail_request(struct mmc_host *host,
+                                           struct mmc_request *mrq)
+{
+}
+
+#endif /* CONFIG_FAIL_MMC_REQUEST */
+
 /**
  *      mmc_request_done - finish processing an MMC request
  *      @host: MMC host which completed request
@@ -102,13 +141,15 @@ void mmc_request_done(struct mmc_host *host, struct mmc_request *mrq)
         }
 
         if (err && cmd->retries) {
-                pr_debug("%s: req failed (CMD%u): %d, retrying...\n",
-                        mmc_hostname(host), cmd->opcode, err);
-
-                cmd->retries--;
-                cmd->error = 0;
-                host->ops->request(host, mrq);
+                /*
+                 * Request starter must handle retries - see
+                 * mmc_wait_for_req_done().
+                 */
+                if (mrq->done)
+                        mrq->done(mrq);
         } else {
+                mmc_should_fail_request(host, mrq);
+
                 led_trigger_event(host->led, LED_OFF);
 
                 pr_debug("%s: req done (CMD%u): %d: %08x %08x %08x %08x\n",
@@ -133,7 +174,7 @@ void mmc_request_done(struct mmc_host *host, struct mmc_request *mrq)
                 if (mrq->done)
                         mrq->done(mrq);
 
-                mmc_host_clk_gate(host);
+                mmc_host_clk_release(host);
         }
 }
 
@@ -192,7 +233,7 @@ mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
                         mrq->stop->mrq = mrq;
                 }
         }
-        mmc_host_clk_ungate(host);
+        mmc_host_clk_hold(host);
         led_trigger_event(host->led, LED_FULL);
         host->ops->request(host, mrq);
 }
@@ -212,7 +253,21 @@ static void __mmc_start_req(struct mmc_host *host, struct mmc_request *mrq)
 static void mmc_wait_for_req_done(struct mmc_host *host,
                                   struct mmc_request *mrq)
 {
-        wait_for_completion(&mrq->completion);
+        struct mmc_command *cmd;
+
+        while (1) {
+                wait_for_completion(&mrq->completion);
+
+                cmd = mrq->cmd;
+                if (!cmd->error || !cmd->retries)
+                        break;
+
+                pr_debug("%s: req failed (CMD%u): %d, retrying...\n",
+                         mmc_hostname(host), cmd->opcode, cmd->error);
+                cmd->retries--;
+                cmd->error = 0;
+                host->ops->request(host, mrq);
+        }
 }
 
 /**
@@ -279,8 +334,14 @@ struct mmc_async_req *mmc_start_req(struct mmc_host *host,
                 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;
@@ -319,6 +380,63 @@ void mmc_wait_for_req(struct mmc_host *host, struct mmc_request *mrq)
 EXPORT_SYMBOL(mmc_wait_for_req);
 
 /**
+ *      mmc_interrupt_hpi - Issue for High priority Interrupt
+ *      @card: the MMC card associated with the HPI transfer
+ *
+ *      Issued High Priority Interrupt, and check for card status
+ *      util out-of prg-state.
+ */
+int mmc_interrupt_hpi(struct mmc_card *card)
+{
+        int err;
+        u32 status;
+
+        BUG_ON(!card);
+
+        if (!card->ext_csd.hpi_en) {
+                pr_info("%s: HPI enable bit unset\n", mmc_hostname(card->host));
+                return 1;
+        }
+
+        mmc_claim_host(card->host);
+        err = mmc_send_status(card, &status);
+        if (err) {
+                pr_err("%s: Get card status fail\n", mmc_hostname(card->host));
+                goto out;
+        }
+
+        /*
+         * If the card status is in PRG-state, we can send the HPI command.
+         */
+        if (R1_CURRENT_STATE(status) == R1_STATE_PRG) {
+                do {
+                        /*
+                         * We don't know when the HPI command will finish
+                         * processing, so we need to resend HPI until out
+                         * of prg-state, and keep checking the card status
+                         * with SEND_STATUS.  If a timeout error occurs when
+                         * sending the HPI command, we are already out of
+                         * prg-state.
+                         */
+                        err = mmc_send_hpi_cmd(card, &status);
+                        if (err)
+                                pr_debug("%s: abort HPI (%d error)\n",
+                                         mmc_hostname(card->host), err);
+
+                        err = mmc_send_status(card, &status);
+                        if (err)
+                                break;
+                } while (R1_CURRENT_STATE(status) == R1_STATE_PRG);
+        } else
+                pr_debug("%s: Left prg-state\n", mmc_hostname(card->host));
+
+out:
+        mmc_release_host(card->host);
+        return err;
+}
+EXPORT_SYMBOL(mmc_interrupt_hpi);
+
+/**
  *      mmc_wait_for_cmd - start a command and wait for completion
  *      @host: MMC host to start command
  *      @cmd: MMC command to start
@@ -330,7 +448,7 @@ EXPORT_SYMBOL(mmc_wait_for_req);
  */
 int mmc_wait_for_cmd(struct mmc_host *host, struct mmc_command *cmd, int retries)
 {
-        struct mmc_request mrq = {0};
+        struct mmc_request mrq = {NULL};
 
         WARN_ON(!host->claimed);
 
@@ -728,15 +846,17 @@ static inline void mmc_set_ios(struct mmc_host *host)
  */
 void mmc_set_chip_select(struct mmc_host *host, int mode)
 {
+        mmc_host_clk_hold(host);
         host->ios.chip_select = mode;
         mmc_set_ios(host);
+        mmc_host_clk_release(host);
 }
 
 /*
  * Sets the host clock to the highest possible frequency that
  * is below "hz".
  */
-void mmc_set_clock(struct mmc_host *host, unsigned int hz)
+static void __mmc_set_clock(struct mmc_host *host, unsigned int hz)
 {
         WARN_ON(hz < host->f_min);
 
@@ -747,6 +867,13 @@ void mmc_set_clock(struct mmc_host *host, unsigned int hz)
         mmc_set_ios(host);
 }
 
+void mmc_set_clock(struct mmc_host *host, unsigned int hz)
+{
+        mmc_host_clk_hold(host);
+        __mmc_set_clock(host, hz);
+        mmc_host_clk_release(host);
+}
+
 #ifdef CONFIG_MMC_CLKGATE
 /*
  * This gates the clock by setting it to 0 Hz.
@@ -779,7 +906,7 @@ void mmc_ungate_clock(struct mmc_host *host)
         if (host->clk_old) {
                 BUG_ON(host->ios.clock);
                 /* This call will also set host->clk_gated to false */
-                mmc_set_clock(host, host->clk_old);
+                __mmc_set_clock(host, host->clk_old);
         }
 }
 
@@ -807,8 +934,10 @@ void mmc_set_ungated(struct mmc_host *host)
  */
 void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode)
 {
+        mmc_host_clk_hold(host);
         host->ios.bus_mode = mode;
         mmc_set_ios(host);
+        mmc_host_clk_release(host);
 }
 
 /*
@@ -816,8 +945,10 @@ void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode)
  */
 void mmc_set_bus_width(struct mmc_host *host, unsigned int width)
 {
+        mmc_host_clk_hold(host);
         host->ios.bus_width = width;
         mmc_set_ios(host);
+        mmc_host_clk_release(host);
 }
 
 /**
@@ -1015,8 +1146,10 @@ u32 mmc_select_voltage(struct mmc_host *host, u32 ocr)
 
                 ocr &= 3 << bit;
 
+                mmc_host_clk_hold(host);
                 host->ios.vdd = bit;
                 mmc_set_ios(host);
+                mmc_host_clk_release(host);
         } else {
                 pr_warning("%s: host doesn't support card's voltages\n",
                                 mmc_hostname(host));
@@ -1063,8 +1196,10 @@ int mmc_set_signal_voltage(struct mmc_host *host, int signal_voltage, bool cmd11
  */
 void mmc_set_timing(struct mmc_host *host, unsigned int timing)
 {
+        mmc_host_clk_hold(host);
         host->ios.timing = timing;
         mmc_set_ios(host);
+        mmc_host_clk_release(host);
 }
 
 /*
@@ -1072,8 +1207,10 @@ void mmc_set_timing(struct mmc_host *host, unsigned int timing)
  */
 void mmc_set_driver_type(struct mmc_host *host, unsigned int drv_type)
 {
+        mmc_host_clk_hold(host);
         host->ios.drv_type = drv_type;
         mmc_set_ios(host);
+        mmc_host_clk_release(host);
 }
 
 /*
@@ -1091,6 +1228,8 @@ static void mmc_power_up(struct mmc_host *host)
 {
         int bit;
 
+        mmc_host_clk_hold(host);
+
         /* If ocr is set, we use it */
         if (host->ocr)
                 bit = ffs(host->ocr) - 1;
@@ -1098,13 +1237,11 @@ static void mmc_power_up(struct mmc_host *host)
                 bit = fls(host->ocr_avail) - 1;
 
         host->ios.vdd = bit;
-        if (mmc_host_is_spi(host)) {
+        if (mmc_host_is_spi(host))
                 host->ios.chip_select = MMC_CS_HIGH;
-                host->ios.bus_mode = MMC_BUSMODE_PUSHPULL;
-        } else {
+        else
                 host->ios.chip_select = MMC_CS_DONTCARE;
-                host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
-        }
+        host->ios.bus_mode = MMC_BUSMODE_PUSHPULL;
         host->ios.power_mode = MMC_POWER_UP;
         host->ios.bus_width = MMC_BUS_WIDTH_1;
         host->ios.timing = MMC_TIMING_LEGACY;
@@ -1126,13 +1263,49 @@ static void mmc_power_up(struct mmc_host *host)
          * time required to reach a stable voltage.
          */
         mmc_delay(10);
+
+        mmc_host_clk_release(host);
 }
 
-static void mmc_power_off(struct mmc_host *host)
+void mmc_power_off(struct mmc_host *host)
 {
+        struct mmc_card *card;
+        unsigned int notify_type;
+        unsigned int timeout;
+        int err;
+
+        mmc_host_clk_hold(host);
+
+        card = host->card;
         host->ios.clock = 0;
         host->ios.vdd = 0;
 
+        if (card && mmc_card_mmc(card) &&
+            (card->poweroff_notify_state == MMC_POWERED_ON)) {
+
+                if (host->power_notify_type == MMC_HOST_PW_NOTIFY_SHORT) {
+                        notify_type = EXT_CSD_POWER_OFF_SHORT;
+                        timeout = card->ext_csd.generic_cmd6_time;
+                        card->poweroff_notify_state = MMC_POWEROFF_SHORT;
+                } else {
+                        notify_type = EXT_CSD_POWER_OFF_LONG;
+                        timeout = card->ext_csd.power_off_longtime;
+                        card->poweroff_notify_state = MMC_POWEROFF_LONG;
+                }
+
+                err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
+                                 EXT_CSD_POWER_OFF_NOTIFICATION,
+                                 notify_type, timeout);
+
+                if (err && err != -EBADMSG)
+                        pr_err("Device failed to respond within %d poweroff "
+                               "time. Forcefully powering down the device\n",
+                               timeout);
+
+                /* Set the card state to no notification after the poweroff */
+                card->poweroff_notify_state = MMC_NO_POWER_NOTIFICATION;
+        }
+
         /*
          * Reset ocr mask to be the highest possible voltage supported for
          * this mmc host. This value will be used at next power up.
@@ -1147,6 +1320,15 @@ static void mmc_power_off(struct mmc_host *host)
         host->ios.bus_width = MMC_BUS_WIDTH_1;
         host->ios.timing = MMC_TIMING_LEGACY;
         mmc_set_ios(host);
+
+        /*
+         * Some configurations, such as the 802.11 SDIO card in the OLPC
+         * XO-1.5, require a short delay after poweroff before the card
+         * can be successfully turned on again.
+         */
+        mmc_delay(1);
+
+        mmc_host_clk_release(host);
 }
 
 /*
@@ -1214,8 +1396,7 @@ void mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops)
 }
 
 /*
- * Remove the current bus handler from a host. Assumes that there are
- * no interesting cards left, so the bus is powered down.
+ * Remove the current bus handler from a host.
  */
 void mmc_detach_bus(struct mmc_host *host)
 {
@@ -1232,8 +1413,6 @@ void mmc_detach_bus(struct mmc_host *host)
 
         spin_unlock_irqrestore(&host->lock, flags);
 
-        mmc_power_off(host);
-
         mmc_bus_put(host);
 }
 
@@ -1451,9 +1630,9 @@ static int mmc_do_erase(struct mmc_card *card, unsigned int from,
         cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
         err = mmc_wait_for_cmd(card->host, &cmd, 0);
         if (err) {
-                printk(KERN_ERR "mmc_erase: group start error %d, "
+                pr_err("mmc_erase: group start error %d, "
                        "status %#x\n", err, cmd.resp[0]);
-                err = -EINVAL;
+                err = -EIO;
                 goto out;
         }
 
@@ -1466,9 +1645,9 @@ static int mmc_do_erase(struct mmc_card *card, unsigned int from,
         cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
         err = mmc_wait_for_cmd(card->host, &cmd, 0);
         if (err) {
-                printk(KERN_ERR "mmc_erase: group end error %d, status %#x\n",
+                pr_err("mmc_erase: group end error %d, status %#x\n",
                        err, cmd.resp[0]);
-                err = -EINVAL;
+                err = -EIO;
                 goto out;
         }
 
@@ -1479,7 +1658,7 @@ static int mmc_do_erase(struct mmc_card *card, unsigned int from,
         cmd.cmd_timeout_ms = mmc_erase_timeout(card, arg, qty);
         err = mmc_wait_for_cmd(card->host, &cmd, 0);
         if (err) {
-                printk(KERN_ERR "mmc_erase: erase error %d, status %#x\n",
+                pr_err("mmc_erase: erase error %d, status %#x\n",
                        err, cmd.resp[0]);
                 err = -EIO;
                 goto out;
@@ -1496,7 +1675,7 @@ static int mmc_do_erase(struct mmc_card *card, unsigned int from,
                 /* Do not retry else we can't see errors */
                 err = mmc_wait_for_cmd(card->host, &cmd, 0);
                 if (err || (cmd.resp[0] & 0xFDF92000)) {
-                        printk(KERN_ERR "error %d requesting status %#x\n",
+                        pr_err("error %d requesting status %#x\n",
                                 err, cmd.resp[0]);
                         err = -EIO;
                         goto out;
@@ -1587,10 +1766,32 @@ int mmc_can_trim(struct mmc_card *card)
 {
         if (card->ext_csd.sec_feature_support & EXT_CSD_SEC_GB_CL_EN)
                 return 1;
+        if (mmc_can_discard(card))
+                return 1;
         return 0;
 }
 EXPORT_SYMBOL(mmc_can_trim);
 
+int mmc_can_discard(struct mmc_card *card)
+{
+        /*
+         * As there's no way to detect the discard support bit at v4.5
+         * use the s/w feature support filed.
+         */
+        if (card->ext_csd.feature_support & MMC_DISCARD_FEATURE)
+                return 1;
+        return 0;
+}
+EXPORT_SYMBOL(mmc_can_discard);
+
+int mmc_can_sanitize(struct mmc_card *card)
+{
+        if (card->ext_csd.sec_feature_support & EXT_CSD_SEC_SANITIZE)
+                return 1;
+        return 0;
+}
+EXPORT_SYMBOL(mmc_can_sanitize);
+
 int mmc_can_secure_erase_trim(struct mmc_card *card)
 {
         if (card->ext_csd.sec_feature_support & EXT_CSD_SEC_ER_EN)
@@ -1700,6 +1901,94 @@ int mmc_set_blocklen(struct mmc_card *card, unsigned int blocklen)
 }
 EXPORT_SYMBOL(mmc_set_blocklen);
 
+static void mmc_hw_reset_for_init(struct mmc_host *host)
+{
+        if (!(host->caps & MMC_CAP_HW_RESET) || !host->ops->hw_reset)
+                return;
+        mmc_host_clk_hold(host);
+        host->ops->hw_reset(host);
+        mmc_host_clk_release(host);
+}
+
+int mmc_can_reset(struct mmc_card *card)
+{
+        u8 rst_n_function;
+
+        if (!mmc_card_mmc(card))
+                return 0;
+        rst_n_function = card->ext_csd.rst_n_function;
+        if ((rst_n_function & EXT_CSD_RST_N_EN_MASK) != EXT_CSD_RST_N_ENABLED)
+                return 0;
+        return 1;
+}
+EXPORT_SYMBOL(mmc_can_reset);
+
+static int mmc_do_hw_reset(struct mmc_host *host, int check)
+{
+        struct mmc_card *card = host->card;
+
+        if (!host->bus_ops->power_restore)
+                return -EOPNOTSUPP;
+
+        if (!(host->caps & MMC_CAP_HW_RESET) || !host->ops->hw_reset)
+                return -EOPNOTSUPP;
+
+        if (!card)
+                return -EINVAL;
+
+        if (!mmc_can_reset(card))
+                return -EOPNOTSUPP;
+
+        mmc_host_clk_hold(host);
+        mmc_set_clock(host, host->f_init);
+
+        host->ops->hw_reset(host);
+
+        /* If the reset has happened, then a status command will fail */
+        if (check) {
+                struct mmc_command cmd = {0};
+                int err;
+
+                cmd.opcode = MMC_SEND_STATUS;
+                if (!mmc_host_is_spi(card->host))
+                        cmd.arg = card->rca << 16;
+                cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_AC;
+                err = mmc_wait_for_cmd(card->host, &cmd, 0);
+                if (!err) {
+                        mmc_host_clk_release(host);
+                        return -ENOSYS;
+                }
+        }
+
+        host->card->state &= ~(MMC_STATE_HIGHSPEED | MMC_STATE_HIGHSPEED_DDR);
+        if (mmc_host_is_spi(host)) {
+                host->ios.chip_select = MMC_CS_HIGH;
+                host->ios.bus_mode = MMC_BUSMODE_PUSHPULL;
+        } else {
+                host->ios.chip_select = MMC_CS_DONTCARE;
+                host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
+        }
+        host->ios.bus_width = MMC_BUS_WIDTH_1;
+        host->ios.timing = MMC_TIMING_LEGACY;
+        mmc_set_ios(host);
+
+        mmc_host_clk_release(host);
+
+        return host->bus_ops->power_restore(host);
+}
+
+int mmc_hw_reset(struct mmc_host *host)
+{
+        return mmc_do_hw_reset(host, 0);
+}
+EXPORT_SYMBOL(mmc_hw_reset);
+
+int mmc_hw_reset_check(struct mmc_host *host)
+{
+        return mmc_do_hw_reset(host, 1);
+}
+EXPORT_SYMBOL(mmc_hw_reset_check);
+
 static int mmc_rescan_try_freq(struct mmc_host *host, unsigned freq)
 {
         host->f_init = freq;
@@ -1711,6 +2000,12 @@ static int mmc_rescan_try_freq(struct mmc_host *host, unsigned freq)
         mmc_power_up(host);
 
         /*
+         * Some eMMCs (with VCCQ always on) may not be reset after power up, so
+         * do a hardware reset if possible.
+         */
+        mmc_hw_reset_for_init(host);
+
+        /*
          * sdio_reset sends CMD52 to reset card.  Since we do not know
          * if the card is being re-initialized, just send it.  CMD52
          * should be ignored by SD/eMMC cards.
@@ -1818,6 +2113,7 @@ void mmc_stop_host(struct mmc_host *host)
 
                 mmc_claim_host(host);
                 mmc_detach_bus(host);
+                mmc_power_off(host);
                 mmc_release_host(host);
                 mmc_bus_put(host);
                 return;
@@ -1919,6 +2215,65 @@ int mmc_card_can_sleep(struct mmc_host *host)
 }
 EXPORT_SYMBOL(mmc_card_can_sleep);
 
+/*
+ * Flush the cache to the non-volatile storage.
+ */
+int mmc_flush_cache(struct mmc_card *card)
+{
+        struct mmc_host *host = card->host;
+        int err = 0;
+
+        if (!(host->caps2 & MMC_CAP2_CACHE_CTRL))
+                return err;
+
+        if (mmc_card_mmc(card) &&
+                        (card->ext_csd.cache_size > 0) &&
+                        (card->ext_csd.cache_ctrl & 1)) {
+                err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
+                                EXT_CSD_FLUSH_CACHE, 1, 0);
+                if (err)
+                        pr_err("%s: cache flush error %d\n",
+                                        mmc_hostname(card->host), err);
+        }
+
+        return err;
+}
+EXPORT_SYMBOL(mmc_flush_cache);
+
+/*
+ * Turn the cache ON/OFF.
+ * Turning the cache OFF shall trigger flushing of the data
+ * to the non-volatile storage.
+ */
+int mmc_cache_ctrl(struct mmc_host *host, u8 enable)
+{
+        struct mmc_card *card = host->card;
+        int err = 0;
+
+        if (!(host->caps2 & MMC_CAP2_CACHE_CTRL) ||
+                        mmc_card_is_removable(host))
+                return err;
+
+        if (card && mmc_card_mmc(card) &&
+                        (card->ext_csd.cache_size > 0)) {
+                enable = !!enable;
+
+                if (card->ext_csd.cache_ctrl ^ enable)
+                        err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
+                                        EXT_CSD_CACHE_CTRL, enable, 0);
+                if (err)
+                        pr_err("%s: cache %s error %d\n",
+                                        mmc_hostname(card->host),
+                                        enable ? "on" : "off",
+                                        err);
+                else
+                        card->ext_csd.cache_ctrl = enable;
+        }
+
+        return err;
+}
+EXPORT_SYMBOL(mmc_cache_ctrl);
+
 #ifdef CONFIG_PM
 
 /**
@@ -1933,23 +2288,39 @@ int mmc_suspend_host(struct mmc_host *host)
                 cancel_delayed_work(&host->disable);
         cancel_delayed_work(&host->detect);
         mmc_flush_scheduled_work();
+        err = mmc_cache_ctrl(host, 0);
+        if (err)
+                goto out;
 
         mmc_bus_get(host);
         if (host->bus_ops && !host->bus_dead) {
-                if (host->bus_ops->suspend)
-                        err = host->bus_ops->suspend(host);
-                if (err == -ENOSYS || !host->bus_ops->resume) {
-                        /*
-                         * We simply "remove" the card in this case.
-                         * It will be redetected on resume.
-                         */
-                        if (host->bus_ops->remove)
-                                host->bus_ops->remove(host);
-                        mmc_claim_host(host);
-                        mmc_detach_bus(host);
-                        mmc_release_host(host);
-                        host->pm_flags = 0;
-                        err = 0;
+
+                /*
+                 * A long response time is not acceptable for device drivers
+                 * when doing suspend. Prevent mmc_claim_host in the suspend
+                 * sequence, to potentially wait "forever" by trying to
+                 * pre-claim the host.
+                 */
+                if (mmc_try_claim_host(host)) {
+                        if (host->bus_ops->suspend)
+                                err = host->bus_ops->suspend(host);
+                        if (err == -ENOSYS || !host->bus_ops->resume) {
+                                /*
+                                 * We simply "remove" the card in this case.
+                                 * It will be redetected on resume.
+                                 */
+                                if (host->bus_ops->remove)
+                                        host->bus_ops->remove(host);
+                                mmc_claim_host(host);
+                                mmc_detach_bus(host);
+                                mmc_power_off(host);
+                                mmc_release_host(host);
+                                host->pm_flags = 0;
+                                err = 0;
+                        }
+                        mmc_do_release_host(host);
+                } else {
+                        err = -EBUSY;
                 }
         }
         mmc_bus_put(host);
@@ -1957,6 +2328,7 @@ int mmc_suspend_host(struct mmc_host *host)
         if (!err && !mmc_card_keep_power(host))
                 mmc_power_off(host);
 
+out:
         return err;
 }
 
@@ -1991,7 +2363,7 @@ int mmc_resume_host(struct mmc_host *host)
                 BUG_ON(!host->bus_ops->resume);
                 err = host->bus_ops->resume(host);
                 if (err) {
-                        printk(KERN_WARNING "%s: error %d during resume "
+                        pr_warning("%s: error %d during resume "
                                             "(card was removed?)\n",
                                             mmc_hostname(host), err);
                         err = 0;
@@ -2022,6 +2394,7 @@ int mmc_pm_notify(struct notifier_block *notify_block,
 
                 spin_lock_irqsave(&host->lock, flags);
                 host->rescan_disable = 1;
+                host->power_notify_type = MMC_HOST_PW_NOTIFY_SHORT;
                 spin_unlock_irqrestore(&host->lock, flags);
                 cancel_delayed_work_sync(&host->detect);
 
@@ -2034,6 +2407,7 @@ int mmc_pm_notify(struct notifier_block *notify_block,
                         host->bus_ops->remove(host);
 
                 mmc_detach_bus(host);
+                mmc_power_off(host);
                 mmc_release_host(host);
                 host->pm_flags = 0;
                 break;
@@ -2044,6 +2418,7 @@ int mmc_pm_notify(struct notifier_block *notify_block,
 
                 spin_lock_irqsave(&host->lock, flags);
                 host->rescan_disable = 0;
+                host->power_notify_type = MMC_HOST_PW_NOTIFY_LONG;
                 spin_unlock_irqrestore(&host->lock, flags);
                 mmc_detect_change(host, 0);