Merge tag 'mmc-merge-for-3.7-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/cjb/mmc

Pull MMC updates from Chris Ball:
 "Core:
   - Add DT properties for card detection (broken-cd, cd-gpios,
     non-removable)
   - Don't poll non-removable devices
   - Fixup/rework eMMC sleep mode/"power off notify" feature
   - Support eMMC background operations (BKOPS).  To set the one-time
     programmable fuse that enables bkops on an eMMC that doesn't
     already have it set, you can use the "mmc bkops enable" command in:

       git://git.kernel.org/pub/scm/linux/kernel/git/cjb/mmc-utils.git

  Drivers:
   - atmel-mci, dw_mmc, pxa-mci, dove, s3c, spear: Add device tree
     support
   - bfin_sdh: Add support for the controller in bf60x
   - dw_mmc: Support Samsung Exynos SoCs
   - eSDHC: Add ADMA support
   - sdhci: Support testing a cd-gpio (from slot-gpio) instead of
     presence bit
   - sdhci-pltfm: Support broken-cd DT property
   - tegra: Convert to only supporting DT (mach-tegra has gone DT-only)"

* tag 'mmc-merge-for-3.7-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/cjb/mmc: (67 commits)
  mmc: core: Fixup broken suspend and eMMC4.5 power off notify
  mmc: sdhci-spear: Add clk_{un}prepare() support
  mmc: sdhci-spear: add device tree bindings
  mmc: sdhci-s3c: Add clk_(enable/disable) in runtime suspend/resume
  mmc: core: Replace MMC_CAP2_BROKEN_VOLTAGE with test for fixed regulator
  mmc: sdhci-pxav3: Use sdhci_get_of_property for parsing DT quirks
  mmc: dt: Support "broken-cd" property in sdhci-pltfm
  mmc: sdhci-s3c: fix the wrong number of max bus clocks
  mmc: sh-mmcif: avoid oops on spurious interrupts
  mmc: sh-mmcif: properly handle MMC_WRITE_MULTIPLE_BLOCK completion IRQ
  mmc: sdhci-s3c: Fix crash on module insertion for second time
  mmc: sdhci-s3c: Enable only required bus clock
  mmc: Revert "mmc: dw_mmc: Add check for IDMAC configuration"
  mmc: mxcmmc: fix bug that may block a data transfer forever
  mmc: omap_hsmmc: Pass on the suspend failure to the PM core
  mmc: atmel-mci: AP700x PDC is not connected to MCI
  mmc: atmel-mci: DMA can be used with other controllers
  mmc: mmci: use clk_prepare_enable and clk_disable_unprepare
  mmc: sdhci-s3c: Add device tree support
  mmc: dw_mmc: add support for exynos specific implementation of dw-mshc
  ...

6 files changed, 287 insertions, 111 deletions

diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
index 8ac5246e2ab2..06c42cfb7c34 100644
--- a/drivers/mmc/core/core.c
+++ b/drivers/mmc/core/core.c
@@ -26,6 +26,7 @@
 #include <linux/suspend.h>
 #include <linux/fault-inject.h>
 #include <linux/random.h>
+#include <linux/slab.h>
 
 #include <linux/mmc/card.h>
 #include <linux/mmc/host.h>
@@ -41,6 +42,12 @@
 #include "sd_ops.h"
 #include "sdio_ops.h"
 
+/*
+ * Background operations can take a long time, depending on the housekeeping
+ * operations the card has to perform.
+ */
+#define MMC_BKOPS_MAX_TIMEOUT   (4 * 60 * 1000) /* max time to wait in ms */
+
 static struct workqueue_struct *workqueue;
 static const unsigned freqs[] = { 400000, 300000, 200000, 100000 };
 
@@ -245,6 +252,70 @@ mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
         host->ops->request(host, mrq);
 }
 
+/**
+ *      mmc_start_bkops - start BKOPS for supported cards
+ *      @card: MMC card to start BKOPS
+ *      @form_exception: A flag to indicate if this function was
+ *                       called due to an exception raised by the card
+ *
+ *      Start background operations whenever requested.
+ *      When the urgent BKOPS bit is set in a R1 command response
+ *      then background operations should be started immediately.
+*/
+void mmc_start_bkops(struct mmc_card *card, bool from_exception)
+{
+        int err;
+        int timeout;
+        bool use_busy_signal;
+
+        BUG_ON(!card);
+
+        if (!card->ext_csd.bkops_en || mmc_card_doing_bkops(card))
+                return;
+
+        err = mmc_read_bkops_status(card);
+        if (err) {
+                pr_err("%s: Failed to read bkops status: %d\n",
+                       mmc_hostname(card->host), err);
+                return;
+        }
+
+        if (!card->ext_csd.raw_bkops_status)
+                return;
+
+        if (card->ext_csd.raw_bkops_status < EXT_CSD_BKOPS_LEVEL_2 &&
+            from_exception)
+                return;
+
+        mmc_claim_host(card->host);
+        if (card->ext_csd.raw_bkops_status >= EXT_CSD_BKOPS_LEVEL_2) {
+                timeout = MMC_BKOPS_MAX_TIMEOUT;
+                use_busy_signal = true;
+        } else {
+                timeout = 0;
+                use_busy_signal = false;
+        }
+
+        err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
+                        EXT_CSD_BKOPS_START, 1, timeout, use_busy_signal);
+        if (err) {
+                pr_warn("%s: Error %d starting bkops\n",
+                        mmc_hostname(card->host), err);
+                goto out;
+        }
+
+        /*
+         * For urgent bkops status (LEVEL_2 and more)
+         * bkops executed synchronously, otherwise
+         * the operation is in progress
+         */
+        if (!use_busy_signal)
+                mmc_card_set_doing_bkops(card);
+out:
+        mmc_release_host(card->host);
+}
+EXPORT_SYMBOL(mmc_start_bkops);
+
 static void mmc_wait_done(struct mmc_request *mrq)
 {
         complete(&mrq->completion);
@@ -354,6 +425,14 @@ 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);
+                /*
+                 * Check BKOPS urgency for each R1 response
+                 */
+                if (host->card && mmc_card_mmc(host->card) &&
+                    ((mmc_resp_type(host->areq->mrq->cmd) == MMC_RSP_R1) ||
+                     (mmc_resp_type(host->areq->mrq->cmd) == MMC_RSP_R1B)) &&
+                    (host->areq->mrq->cmd->resp[0] & R1_EXCEPTION_EVENT))
+                        mmc_start_bkops(host->card, true);
         }
 
         if (!err && areq)
@@ -398,7 +477,7 @@ EXPORT_SYMBOL(mmc_wait_for_req);
  *      @card: the MMC card associated with the HPI transfer
  *
  *      Issued High Priority Interrupt, and check for card status
- *      util out-of prg-state.
+ *      until out-of prg-state.
  */
 int mmc_interrupt_hpi(struct mmc_card *card)
 {
@@ -424,8 +503,9 @@ int mmc_interrupt_hpi(struct mmc_card *card)
         case R1_STATE_IDLE:
         case R1_STATE_READY:
         case R1_STATE_STBY:
+        case R1_STATE_TRAN:
                 /*
-                 * In idle states, HPI is not needed and the caller
+                 * In idle and transfer states, HPI is not needed and the caller
                  * can issue the next intended command immediately
                  */
                 goto out;
@@ -489,6 +569,64 @@ int mmc_wait_for_cmd(struct mmc_host *host, struct mmc_command *cmd, int retries
 EXPORT_SYMBOL(mmc_wait_for_cmd);
 
 /**
+ *      mmc_stop_bkops - stop ongoing BKOPS
+ *      @card: MMC card to check BKOPS
+ *
+ *      Send HPI command to stop ongoing background operations to
+ *      allow rapid servicing of foreground operations, e.g. read/
+ *      writes. Wait until the card comes out of the programming state
+ *      to avoid errors in servicing read/write requests.
+ */
+int mmc_stop_bkops(struct mmc_card *card)
+{
+        int err = 0;
+
+        BUG_ON(!card);
+        err = mmc_interrupt_hpi(card);
+
+        /*
+         * If err is EINVAL, we can't issue an HPI.
+         * It should complete the BKOPS.
+         */
+        if (!err || (err == -EINVAL)) {
+                mmc_card_clr_doing_bkops(card);
+                err = 0;
+        }
+
+        return err;
+}
+EXPORT_SYMBOL(mmc_stop_bkops);
+
+int mmc_read_bkops_status(struct mmc_card *card)
+{
+        int err;
+        u8 *ext_csd;
+
+        /*
+         * In future work, we should consider storing the entire ext_csd.
+         */
+        ext_csd = kmalloc(512, GFP_KERNEL);
+        if (!ext_csd) {
+                pr_err("%s: could not allocate buffer to receive the ext_csd.\n",
+                       mmc_hostname(card->host));
+                return -ENOMEM;
+        }
+
+        mmc_claim_host(card->host);
+        err = mmc_send_ext_csd(card, ext_csd);
+        mmc_release_host(card->host);
+        if (err)
+                goto out;
+
+        card->ext_csd.raw_bkops_status = ext_csd[EXT_CSD_BKOPS_STATUS];
+        card->ext_csd.raw_exception_status = ext_csd[EXT_CSD_EXP_EVENTS_STATUS];
+out:
+        kfree(ext_csd);
+        return err;
+}
+EXPORT_SYMBOL(mmc_read_bkops_status);
+
+/**
  *      mmc_set_data_timeout - set the timeout for a data command
  *      @data: data phase for command
  *      @card: the MMC card associated with the data transfer
@@ -975,7 +1113,8 @@ int mmc_regulator_set_ocr(struct mmc_host *mmc,
                 int             tmp;
                 int             voltage;
 
-                /* REVISIT mmc_vddrange_to_ocrmask() may have set some
+                /*
+                 * REVISIT mmc_vddrange_to_ocrmask() may have set some
                  * bits this regulator doesn't quite support ... don't
                  * be too picky, most cards and regulators are OK with
                  * a 0.1V range goof (it's a small error percentage).
@@ -989,12 +1128,13 @@ int mmc_regulator_set_ocr(struct mmc_host *mmc,
                         max_uV = min_uV + 100 * 1000;
                 }
 
-                /* avoid needless changes to this voltage; the regulator
-                 * might not allow this operation
+                /*
+                 * If we're using a fixed/static regulator, don't call
+                 * regulator_set_voltage; it would fail.
                  */
                 voltage = regulator_get_voltage(supply);
 
-                if (mmc->caps2 & MMC_CAP2_BROKEN_VOLTAGE)
+                if (regulator_count_voltages(supply) == 1)
                         min_uV = max_uV = voltage;
 
                 if (voltage < 0)
@@ -1133,48 +1273,6 @@ void mmc_set_driver_type(struct mmc_host *host, unsigned int drv_type)
         mmc_host_clk_release(host);
 }
 
-static void mmc_poweroff_notify(struct mmc_host *host)
-{
-        struct mmc_card *card;
-        unsigned int timeout;
-        unsigned int notify_type = EXT_CSD_NO_POWER_NOTIFICATION;
-        int err = 0;
-
-        card = host->card;
-        mmc_claim_host(host);
-
-        /*
-         * Send power notify command only if card
-         * is mmc and notify state is powered ON
-         */
-        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;
-        }
-        mmc_release_host(host);
-}
-
 /*
  * Apply power to the MMC stack.  This is a two-stage process.
  * First, we enable power to the card without the clock running.
@@ -1237,8 +1335,6 @@ static void mmc_power_up(struct mmc_host *host)
 
 void mmc_power_off(struct mmc_host *host)
 {
-        int err = 0;
-
         if (host->ios.power_mode == MMC_POWER_OFF)
                 return;
 
@@ -1247,22 +1343,6 @@ void mmc_power_off(struct mmc_host *host)
         host->ios.clock = 0;
         host->ios.vdd = 0;
 
-        /*
-         * For eMMC 4.5 device send AWAKE command before
-         * POWER_OFF_NOTIFY command, because in sleep state
-         * eMMC 4.5 devices respond to only RESET and AWAKE cmd
-         */
-        if (host->card && mmc_card_is_sleep(host->card) &&
-            host->bus_ops->resume) {
-                err = host->bus_ops->resume(host);
-
-                if (!err)
-                        mmc_poweroff_notify(host);
-                else
-                        pr_warning("%s: error %d during resume "
-                                   "(continue with poweroff sequence)\n",
-                                   mmc_hostname(host), err);
-        }
 
         /*
          * Reset ocr mask to be the highest possible voltage supported for
@@ -2052,6 +2132,11 @@ void mmc_rescan(struct work_struct *work)
         if (host->rescan_disable)
                 return;
 
+        /* If there is a non-removable card registered, only scan once */
+        if ((host->caps & MMC_CAP_NONREMOVABLE) && host->rescan_entered)
+                return;
+        host->rescan_entered = 1;
+
         mmc_bus_get(host);
 
         /*
@@ -2327,9 +2412,14 @@ int mmc_suspend_host(struct mmc_host *host)
 
         mmc_bus_get(host);
         if (host->bus_ops && !host->bus_dead) {
-
-                if (host->bus_ops->suspend)
+                if (host->bus_ops->suspend) {
+                        if (mmc_card_doing_bkops(host->card)) {
+                                err = mmc_stop_bkops(host->card);
+                                if (err)
+                                        goto out;
+                        }
                         err = host->bus_ops->suspend(host);
+                }
 
                 if (err == -ENOSYS || !host->bus_ops->resume) {
                         /*
@@ -2411,15 +2501,24 @@ int mmc_pm_notify(struct notifier_block *notify_block,
         struct mmc_host *host = container_of(
                 notify_block, struct mmc_host, pm_notify);
         unsigned long flags;
-
+        int err = 0;
 
         switch (mode) {
         case PM_HIBERNATION_PREPARE:
         case PM_SUSPEND_PREPARE:
+                if (host->card && mmc_card_mmc(host->card) &&
+                    mmc_card_doing_bkops(host->card)) {
+                        err = mmc_stop_bkops(host->card);
+                        if (err) {
+                                pr_err("%s: didn't stop bkops\n",
+                                        mmc_hostname(host));
+                                return err;
+                        }
+                        mmc_card_clr_doing_bkops(host->card);
+                }
 
                 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);
 
@@ -2443,7 +2542,6 @@ 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);
 
diff --git a/drivers/mmc/core/debugfs.c b/drivers/mmc/core/debugfs.c
index 9ab5b17d488a..d96c643dde1c 100644
--- a/drivers/mmc/core/debugfs.c
+++ b/drivers/mmc/core/debugfs.c
@@ -281,7 +281,7 @@ static int mmc_ext_csd_open(struct inode *inode, struct file *filp)
         if (err)
                 goto out_free;
 
-        for (i = 511; i >= 0; i--)
+        for (i = 0; i < 512; i++)
                 n += sprintf(buf + n, "%02x", ext_csd[i]);
         n += sprintf(buf + n, "\n");
         BUG_ON(n != EXT_CSD_STR_LEN);
diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
index 396b25891bb9..7cc46382fd64 100644
--- a/drivers/mmc/core/mmc.c
+++ b/drivers/mmc/core/mmc.c
@@ -463,6 +463,17 @@ static int mmc_read_ext_csd(struct mmc_card *card, u8 *ext_csd)
         }
 
         if (card->ext_csd.rev >= 5) {
+                /* check whether the eMMC card supports BKOPS */
+                if (ext_csd[EXT_CSD_BKOPS_SUPPORT] & 0x1) {
+                        card->ext_csd.bkops = 1;
+                        card->ext_csd.bkops_en = ext_csd[EXT_CSD_BKOPS_EN];
+                        card->ext_csd.raw_bkops_status =
+                                ext_csd[EXT_CSD_BKOPS_STATUS];
+                        if (!card->ext_csd.bkops_en)
+                                pr_info("%s: BKOPS_EN bit is not set\n",
+                                        mmc_hostname(card->host));
+                }
+
                 /* check whether the eMMC card supports HPI */
                 if (ext_csd[EXT_CSD_HPI_FEATURES] & 0x1) {
                         card->ext_csd.hpi = 1;
@@ -996,7 +1007,7 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
                  * so check for success and update the flag
                  */
                 if (!err)
-                        card->poweroff_notify_state = MMC_POWERED_ON;
+                        card->ext_csd.power_off_notification = EXT_CSD_POWER_ON;
         }
 
         /*
@@ -1262,6 +1273,35 @@ err:
         return err;
 }
 
+static int mmc_can_poweroff_notify(const struct mmc_card *card)
+{
+        return card &&
+                mmc_card_mmc(card) &&
+                (card->ext_csd.power_off_notification == EXT_CSD_POWER_ON);
+}
+
+static int mmc_poweroff_notify(struct mmc_card *card, unsigned int notify_type)
+{
+        unsigned int timeout = card->ext_csd.generic_cmd6_time;
+        int err;
+
+        /* Use EXT_CSD_POWER_OFF_SHORT as default notification type. */
+        if (notify_type == EXT_CSD_POWER_OFF_LONG)
+                timeout = card->ext_csd.power_off_longtime;
+
+        err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
+                         EXT_CSD_POWER_OFF_NOTIFICATION,
+                         notify_type, timeout);
+        if (err)
+                pr_err("%s: Power Off Notification timed out, %u\n",
+                       mmc_hostname(card->host), timeout);
+
+        /* Disable the power off notification after the switch operation. */
+        card->ext_csd.power_off_notification = EXT_CSD_NO_POWER_NOTIFICATION;
+
+        return err;
+}
+
 /*
  * Host is being removed. Free up the current card.
  */
@@ -1322,11 +1362,11 @@ static int mmc_suspend(struct mmc_host *host)
         BUG_ON(!host->card);
 
         mmc_claim_host(host);
-        if (mmc_card_can_sleep(host)) {
+        if (mmc_can_poweroff_notify(host->card))
+                err = mmc_poweroff_notify(host->card, EXT_CSD_POWER_OFF_SHORT);
+        else if (mmc_card_can_sleep(host))
                 err = mmc_card_sleep(host);
-                if (!err)
-                        mmc_card_set_sleep(host->card);
-        } else if (!mmc_host_is_spi(host))
+        else if (!mmc_host_is_spi(host))
                 err = mmc_deselect_cards(host);
         host->card->state &= ~(MMC_STATE_HIGHSPEED | MMC_STATE_HIGHSPEED_200);
         mmc_release_host(host);
@@ -1348,11 +1388,7 @@ static int mmc_resume(struct mmc_host *host)
         BUG_ON(!host->card);
 
         mmc_claim_host(host);
-        if (mmc_card_is_sleep(host->card)) {
-                err = mmc_card_awake(host);
-                mmc_card_clr_sleep(host->card);
-        } else
-                err = mmc_init_card(host, host->ocr, host->card);
+        err = mmc_init_card(host, host->ocr, host->card);
         mmc_release_host(host);
 
         return err;
@@ -1363,7 +1399,6 @@ static int mmc_power_restore(struct mmc_host *host)
         int ret;
 
         host->card->state &= ~(MMC_STATE_HIGHSPEED | MMC_STATE_HIGHSPEED_200);
-        mmc_card_clr_sleep(host->card);
         mmc_claim_host(host);
         ret = mmc_init_card(host, host->ocr, host->card);
         mmc_release_host(host);
diff --git a/drivers/mmc/core/mmc_ops.c b/drivers/mmc/core/mmc_ops.c
index 0ed2cc5f35b6..a0e172042e65 100644
--- a/drivers/mmc/core/mmc_ops.c
+++ b/drivers/mmc/core/mmc_ops.c
@@ -230,6 +230,10 @@ mmc_send_cxd_native(struct mmc_host *host, u32 arg, u32 *cxd, int opcode)
         return 0;
 }
 
+/*
+ * NOTE: void *buf, caller for the buf is required to use DMA-capable
+ * buffer or on-stack buffer (with some overhead in callee).
+ */
 static int
 mmc_send_cxd_data(struct mmc_card *card, struct mmc_host *host,
                 u32 opcode, void *buf, unsigned len)
@@ -239,13 +243,19 @@ mmc_send_cxd_data(struct mmc_card *card, struct mmc_host *host,
         struct mmc_data data = {0};
         struct scatterlist sg;
         void *data_buf;
+        int is_on_stack;
 
-        /* dma onto stack is unsafe/nonportable, but callers to this
-         * routine normally provide temporary on-stack buffers ...
-         */
-        data_buf = kmalloc(len, GFP_KERNEL);
-        if (data_buf == NULL)
-                return -ENOMEM;
+        is_on_stack = object_is_on_stack(buf);
+        if (is_on_stack) {
+                /*
+                 * dma onto stack is unsafe/nonportable, but callers to this
+                 * routine normally provide temporary on-stack buffers ...
+                 */
+                data_buf = kmalloc(len, GFP_KERNEL);
+                if (!data_buf)
+                        return -ENOMEM;
+        } else
+                data_buf = buf;
 
         mrq.cmd = &cmd;
         mrq.data = &data;
@@ -280,8 +290,10 @@ mmc_send_cxd_data(struct mmc_card *card, struct mmc_host *host,
 
         mmc_wait_for_req(host, &mrq);
 
-        memcpy(buf, data_buf, len);
-        kfree(data_buf);
+        if (is_on_stack) {
+                memcpy(buf, data_buf, len);
+                kfree(data_buf);
+        }
 
         if (cmd.error)
                 return cmd.error;
@@ -294,24 +306,32 @@ mmc_send_cxd_data(struct mmc_card *card, struct mmc_host *host,
 int mmc_send_csd(struct mmc_card *card, u32 *csd)
 {
         int ret, i;
+        u32 *csd_tmp;
 
         if (!mmc_host_is_spi(card->host))
                 return mmc_send_cxd_native(card->host, card->rca << 16,
                                 csd, MMC_SEND_CSD);
 
-        ret = mmc_send_cxd_data(card, card->host, MMC_SEND_CSD, csd, 16);
+        csd_tmp = kmalloc(16, GFP_KERNEL);
+        if (!csd_tmp)
+                return -ENOMEM;
+
+        ret = mmc_send_cxd_data(card, card->host, MMC_SEND_CSD, csd_tmp, 16);
         if (ret)
-                return ret;
+                goto err;
 
         for (i = 0;i < 4;i++)
-                csd[i] = be32_to_cpu(csd[i]);
+                csd[i] = be32_to_cpu(csd_tmp[i]);
 
-        return 0;
+err:
+        kfree(csd_tmp);
+        return ret;
 }
 
 int mmc_send_cid(struct mmc_host *host, u32 *cid)
 {
         int ret, i;
+        u32 *cid_tmp;
 
         if (!mmc_host_is_spi(host)) {
                 if (!host->card)
@@ -320,14 +340,20 @@ int mmc_send_cid(struct mmc_host *host, u32 *cid)
                                 cid, MMC_SEND_CID);
         }
 
-        ret = mmc_send_cxd_data(NULL, host, MMC_SEND_CID, cid, 16);
+        cid_tmp = kmalloc(16, GFP_KERNEL);
+        if (!cid_tmp)
+                return -ENOMEM;
+
+        ret = mmc_send_cxd_data(NULL, host, MMC_SEND_CID, cid_tmp, 16);
         if (ret)
-                return ret;
+                goto err;
 
         for (i = 0;i < 4;i++)
-                cid[i] = be32_to_cpu(cid[i]);
+                cid[i] = be32_to_cpu(cid_tmp[i]);
 
-        return 0;
+err:
+        kfree(cid_tmp);
+        return ret;
 }
 
 int mmc_send_ext_csd(struct mmc_card *card, u8 *ext_csd)
@@ -367,18 +393,19 @@ int mmc_spi_set_crc(struct mmc_host *host, int use_crc)
 }
 
 /**
- *      mmc_switch - modify EXT_CSD register
+ *      __mmc_switch - modify EXT_CSD register
  *      @card: the MMC card associated with the data transfer
  *      @set: cmd set values
  *      @index: EXT_CSD register index
  *      @value: value to program into EXT_CSD register
  *      @timeout_ms: timeout (ms) for operation performed by register write,
  *                   timeout of zero implies maximum possible timeout
+ *      @use_busy_signal: use the busy signal as response type
  *
  *      Modifies the EXT_CSD register for selected card.
  */
-int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value,
-               unsigned int timeout_ms)
+int __mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value,
+               unsigned int timeout_ms, bool use_busy_signal)
 {
         int err;
         struct mmc_command cmd = {0};
@@ -392,13 +419,23 @@ int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value,
                   (index << 16) |
                   (value << 8) |
                   set;
-        cmd.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC;
+        cmd.flags = MMC_CMD_AC;
+        if (use_busy_signal)
+                cmd.flags |= MMC_RSP_SPI_R1B | MMC_RSP_R1B;
+        else
+                cmd.flags |= MMC_RSP_SPI_R1 | MMC_RSP_R1;
+
+
         cmd.cmd_timeout_ms = timeout_ms;
 
         err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES);
         if (err)
                 return err;
 
+        /* No need to check card status in case of unblocking command */
+        if (!use_busy_signal)
+                return 0;
+
         /* Must check status to be sure of no errors */
         do {
                 err = mmc_send_status(card, &status);
@@ -423,6 +460,13 @@ int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value,
 
         return 0;
 }
+EXPORT_SYMBOL_GPL(__mmc_switch);
+
+int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value,
+                unsigned int timeout_ms)
+{
+        return __mmc_switch(card, set, index, value, timeout_ms, true);
+}
 EXPORT_SYMBOL_GPL(mmc_switch);
 
 int mmc_send_status(struct mmc_card *card, u32 *status)
diff --git a/drivers/mmc/core/sdio_bus.c b/drivers/mmc/core/sdio_bus.c
index 236842ec955a..6bf68799fe97 100644
--- a/drivers/mmc/core/sdio_bus.c
+++ b/drivers/mmc/core/sdio_bus.c
@@ -193,14 +193,7 @@ static int sdio_bus_remove(struct device *dev)
 }
 
 #ifdef CONFIG_PM
-
-static int pm_no_operation(struct device *dev)
-{
-        return 0;
-}
-
 static const struct dev_pm_ops sdio_bus_pm_ops = {
-        SET_SYSTEM_SLEEP_PM_OPS(pm_no_operation, pm_no_operation)
         SET_RUNTIME_PM_OPS(
                 pm_generic_runtime_suspend,
                 pm_generic_runtime_resume,
diff --git a/drivers/mmc/core/slot-gpio.c b/drivers/mmc/core/slot-gpio.c
index 058242916cef..08c6b3dfe080 100644
--- a/drivers/mmc/core/slot-gpio.c
+++ b/drivers/mmc/core/slot-gpio.c
@@ -100,7 +100,13 @@ int mmc_gpio_request_ro(struct mmc_host *host, unsigned int gpio)
 
         ctx = host->slot.handler_priv;
 
-        return gpio_request_one(gpio, GPIOF_DIR_IN, ctx->ro_label);
+        ret = gpio_request_one(gpio, GPIOF_DIR_IN, ctx->ro_label);
+        if (ret < 0)
+                return ret;
+
+        ctx->ro_gpio = gpio;
+
+        return 0;
 }
 EXPORT_SYMBOL(mmc_gpio_request_ro);