1 files changed, 142 insertions, 256 deletions

diff --git a/drivers/mmc/host/tmio_mmc_pio.c b/drivers/mmc/host/tmio_mmc_pio.c
index 50bf495a988..1f16357e730 100644
--- a/drivers/mmc/host/tmio_mmc_pio.c
+++ b/drivers/mmc/host/tmio_mmc_pio.c
@@ -35,30 +35,27 @@
 #include <linux/irq.h>
 #include <linux/mfd/tmio.h>
 #include <linux/mmc/host.h>
-#include <linux/mmc/mmc.h>
-#include <linux/mmc/slot-gpio.h>
 #include <linux/mmc/tmio.h>
 #include <linux/module.h>
 #include <linux/pagemap.h>
 #include <linux/platform_device.h>
-#include <linux/pm_qos.h>
 #include <linux/pm_runtime.h>
 #include <linux/scatterlist.h>
-#include <linux/spinlock.h>
 #include <linux/workqueue.h>
+#include <linux/spinlock.h>
 
 #include "tmio_mmc.h"
 
 void tmio_mmc_enable_mmc_irqs(struct tmio_mmc_host *host, u32 i)
 {
-        host->sdcard_irq_mask &= ~(i & TMIO_MASK_IRQ);
-        sd_ctrl_write32(host, CTL_IRQ_MASK, host->sdcard_irq_mask);
+        u32 mask = sd_ctrl_read32(host, CTL_IRQ_MASK) & ~(i & TMIO_MASK_IRQ);
+        sd_ctrl_write32(host, CTL_IRQ_MASK, mask);
 }
 
 void tmio_mmc_disable_mmc_irqs(struct tmio_mmc_host *host, u32 i)
 {
-        host->sdcard_irq_mask |= (i & TMIO_MASK_IRQ);
-        sd_ctrl_write32(host, CTL_IRQ_MASK, host->sdcard_irq_mask);
+        u32 mask = sd_ctrl_read32(host, CTL_IRQ_MASK) | (i & TMIO_MASK_IRQ);
+        sd_ctrl_write32(host, CTL_IRQ_MASK, mask);
 }
 
 static void tmio_mmc_ack_mmc_irqs(struct tmio_mmc_host *host, u32 i)
@@ -95,7 +92,7 @@ static int tmio_mmc_next_sg(struct tmio_mmc_host *host)
 static void pr_debug_status(u32 status)
 {
         int i = 0;
-        pr_debug("status: %08x = ", status);
+        printk(KERN_DEBUG "status: %08x = ", status);
         STATUS_TO_TEXT(CARD_REMOVE, status, i);
         STATUS_TO_TEXT(CARD_INSERT, status, i);
         STATUS_TO_TEXT(SIGSTATE, status, i);
@@ -129,14 +126,14 @@ static void tmio_mmc_enable_sdio_irq(struct mmc_host *mmc, int enable)
         struct tmio_mmc_host *host = mmc_priv(mmc);
 
         if (enable) {
-                host->sdio_irq_mask = TMIO_SDIO_MASK_ALL &
-                                        ~TMIO_SDIO_STAT_IOIRQ;
+                host->sdio_irq_enabled = 1;
                 sd_ctrl_write16(host, CTL_TRANSACTION_CTL, 0x0001);
-                sd_ctrl_write16(host, CTL_SDIO_IRQ_MASK, host->sdio_irq_mask);
+                sd_ctrl_write16(host, CTL_SDIO_IRQ_MASK,
+                        (TMIO_SDIO_MASK_ALL & ~TMIO_SDIO_STAT_IOIRQ));
         } else {
-                host->sdio_irq_mask = TMIO_SDIO_MASK_ALL;
-                sd_ctrl_write16(host, CTL_SDIO_IRQ_MASK, host->sdio_irq_mask);
+                sd_ctrl_write16(host, CTL_SDIO_IRQ_MASK, TMIO_SDIO_MASK_ALL);
                 sd_ctrl_write16(host, CTL_TRANSACTION_CTL, 0x0000);
+                host->sdio_irq_enabled = 0;
         }
 }
 
@@ -247,7 +244,6 @@ static void tmio_mmc_reset_work(struct work_struct *work)
         /* Ready for new calls */
         host->mrq = NULL;
 
-        tmio_mmc_abort_dma(host);
         mmc_request_done(host->mmc, mrq);
 }
 
@@ -274,9 +270,6 @@ static void tmio_mmc_finish_request(struct tmio_mmc_host *host)
         host->mrq = NULL;
         spin_unlock_irqrestore(&host->lock, flags);
 
-        if (mrq->cmd->error || (mrq->data && mrq->data->error))
-                tmio_mmc_abort_dma(host);
-
         mmc_request_done(host->mmc, mrq);
 }
 
@@ -304,10 +297,9 @@ static int tmio_mmc_start_command(struct tmio_mmc_host *host, struct mmc_command
 {
         struct mmc_data *data = host->data;
         int c = cmd->opcode;
-        u32 irq_mask = TMIO_MASK_CMD;
 
-        /* CMD12 is handled by hardware */
-        if (cmd->opcode == MMC_STOP_TRANSMISSION && !cmd->arg) {
+        /* Command 12 is handled by hardware */
+        if (cmd->opcode == 12 && !cmd->arg) {
                 sd_ctrl_write16(host, CTL_STOP_INTERNAL_ACTION, 0x001);
                 return 0;
         }
@@ -340,9 +332,7 @@ static int tmio_mmc_start_command(struct tmio_mmc_host *host, struct mmc_command
                         c |= TRANSFER_READ;
         }
 
-        if (!host->native_hotplug)
-                irq_mask &= ~(TMIO_STAT_CARD_REMOVE | TMIO_STAT_CARD_INSERT);
-        tmio_mmc_enable_mmc_irqs(host, irq_mask);
+        tmio_mmc_enable_mmc_irqs(host, TMIO_MASK_CMD);
 
         /* Fire off the command */
         sd_ctrl_write32(host, CTL_ARG_REG, cmd->arg);
@@ -450,7 +440,7 @@ void tmio_mmc_do_data_irq(struct tmio_mmc_host *host)
         }
 
         if (stop) {
-                if (stop->opcode == MMC_STOP_TRANSMISSION && !stop->arg)
+                if (stop->opcode == 12 && !stop->arg)
                         sd_ctrl_write16(host, CTL_STOP_INTERNAL_ACTION, 0x000);
                 else
                         BUG();
@@ -553,20 +543,45 @@ out:
         spin_unlock(&host->lock);
 }
 
-static void tmio_mmc_card_irq_status(struct tmio_mmc_host *host,
-                                       int *ireg, int *status)
+irqreturn_t tmio_mmc_irq(int irq, void *devid)
 {
-        *status = sd_ctrl_read32(host, CTL_STATUS);
-        *ireg = *status & TMIO_MASK_IRQ & ~host->sdcard_irq_mask;
+        struct tmio_mmc_host *host = devid;
+        struct mmc_host *mmc = host->mmc;
+        struct tmio_mmc_data *pdata = host->pdata;
+        unsigned int ireg, irq_mask, status;
+        unsigned int sdio_ireg, sdio_irq_mask, sdio_status;
 
-        pr_debug_status(*status);
-        pr_debug_status(*ireg);
-}
+        pr_debug("MMC IRQ begin\n");
 
-static bool __tmio_mmc_card_detect_irq(struct tmio_mmc_host *host,
-                                      int ireg, int status)
-{
-        struct mmc_host *mmc = host->mmc;
+        status = sd_ctrl_read32(host, CTL_STATUS);
+        irq_mask = sd_ctrl_read32(host, CTL_IRQ_MASK);
+        ireg = status & TMIO_MASK_IRQ & ~irq_mask;
+
+        sdio_ireg = 0;
+        if (!ireg && pdata->flags & TMIO_MMC_SDIO_IRQ) {
+                sdio_status = sd_ctrl_read16(host, CTL_SDIO_STATUS);
+                sdio_irq_mask = sd_ctrl_read16(host, CTL_SDIO_IRQ_MASK);
+                sdio_ireg = sdio_status & TMIO_SDIO_MASK_ALL & ~sdio_irq_mask;
+
+                sd_ctrl_write16(host, CTL_SDIO_STATUS, sdio_status & ~TMIO_SDIO_MASK_ALL);
+
+                if (sdio_ireg && !host->sdio_irq_enabled) {
+                        pr_warning("tmio_mmc: Spurious SDIO IRQ, disabling! 0x%04x 0x%04x 0x%04x\n",
+                                   sdio_status, sdio_irq_mask, sdio_ireg);
+                        tmio_mmc_enable_sdio_irq(mmc, 0);
+                        goto out;
+                }
+
+                if (mmc->caps & MMC_CAP_SDIO_IRQ &&
+                        sdio_ireg & TMIO_SDIO_STAT_IOIRQ)
+                        mmc_signal_sdio_irq(mmc);
+
+                if (sdio_ireg)
+                        goto out;
+        }
+
+        pr_debug_status(status);
+        pr_debug_status(ireg);
 
         /* Card insert / remove attempts */
         if (ireg & (TMIO_STAT_CARD_INSERT | TMIO_STAT_CARD_REMOVE)) {
@@ -576,102 +591,43 @@ static bool __tmio_mmc_card_detect_irq(struct tmio_mmc_host *host,
                      ((ireg & TMIO_STAT_CARD_INSERT) && !mmc->card)) &&
                     !work_pending(&mmc->detect.work))
                         mmc_detect_change(host->mmc, msecs_to_jiffies(100));
-                return true;
+                goto out;
         }
 
-        return false;
-}
-
-irqreturn_t tmio_mmc_card_detect_irq(int irq, void *devid)
-{
-        unsigned int ireg, status;
-        struct tmio_mmc_host *host = devid;
-
-        tmio_mmc_card_irq_status(host, &ireg, &status);
-        __tmio_mmc_card_detect_irq(host, ireg, status);
-
-        return IRQ_HANDLED;
-}
-EXPORT_SYMBOL(tmio_mmc_card_detect_irq);
+        /* CRC and other errors */
+/*      if (ireg & TMIO_STAT_ERR_IRQ)
+ *              handled |= tmio_error_irq(host, irq, stat);
+ */
 
-static bool __tmio_mmc_sdcard_irq(struct tmio_mmc_host *host,
-                                 int ireg, int status)
-{
         /* Command completion */
         if (ireg & (TMIO_STAT_CMDRESPEND | TMIO_STAT_CMDTIMEOUT)) {
                 tmio_mmc_ack_mmc_irqs(host,
                              TMIO_STAT_CMDRESPEND |
                              TMIO_STAT_CMDTIMEOUT);
                 tmio_mmc_cmd_irq(host, status);
-                return true;
+                goto out;
         }
 
         /* Data transfer */
         if (ireg & (TMIO_STAT_RXRDY | TMIO_STAT_TXRQ)) {
                 tmio_mmc_ack_mmc_irqs(host, TMIO_STAT_RXRDY | TMIO_STAT_TXRQ);
                 tmio_mmc_pio_irq(host);
-                return true;
+                goto out;
         }
 
         /* Data transfer completion */
         if (ireg & TMIO_STAT_DATAEND) {
                 tmio_mmc_ack_mmc_irqs(host, TMIO_STAT_DATAEND);
                 tmio_mmc_data_irq(host);
-                return true;
+                goto out;
         }
 
-        return false;
-}
-
-irqreturn_t tmio_mmc_sdcard_irq(int irq, void *devid)
-{
-        unsigned int ireg, status;
-        struct tmio_mmc_host *host = devid;
-
-        tmio_mmc_card_irq_status(host, &ireg, &status);
-        __tmio_mmc_sdcard_irq(host, ireg, status);
-
-        return IRQ_HANDLED;
-}
-EXPORT_SYMBOL(tmio_mmc_sdcard_irq);
-
-irqreturn_t tmio_mmc_sdio_irq(int irq, void *devid)
-{
-        struct tmio_mmc_host *host = devid;
-        struct mmc_host *mmc = host->mmc;
-        struct tmio_mmc_data *pdata = host->pdata;
-        unsigned int ireg, status;
-
-        if (!(pdata->flags & TMIO_MMC_SDIO_IRQ))
-                return IRQ_HANDLED;
-
-        status = sd_ctrl_read16(host, CTL_SDIO_STATUS);
-        ireg = status & TMIO_SDIO_MASK_ALL & ~host->sdcard_irq_mask;
-
-        sd_ctrl_write16(host, CTL_SDIO_STATUS, status & ~TMIO_SDIO_MASK_ALL);
-
-        if (mmc->caps & MMC_CAP_SDIO_IRQ && ireg & TMIO_SDIO_STAT_IOIRQ)
-                mmc_signal_sdio_irq(mmc);
-
-        return IRQ_HANDLED;
-}
-EXPORT_SYMBOL(tmio_mmc_sdio_irq);
-
-irqreturn_t tmio_mmc_irq(int irq, void *devid)
-{
-        struct tmio_mmc_host *host = devid;
-        unsigned int ireg, status;
-
-        pr_debug("MMC IRQ begin\n");
-
-        tmio_mmc_card_irq_status(host, &ireg, &status);
-        if (__tmio_mmc_card_detect_irq(host, ireg, status))
-                return IRQ_HANDLED;
-        if (__tmio_mmc_sdcard_irq(host, ireg, status))
-                return IRQ_HANDLED;
-
-        tmio_mmc_sdio_irq(irq, devid);
+        pr_warning("tmio_mmc: Spurious irq, disabling! "
+                "0x%08x 0x%08x 0x%08x\n", status, irq_mask, ireg);
+        pr_debug_status(status);
+        tmio_mmc_disable_mmc_irqs(host, status & ~irq_mask);
 
+out:
         return IRQ_HANDLED;
 }
 EXPORT_SYMBOL(tmio_mmc_irq);
@@ -752,34 +708,6 @@ fail:
         mmc_request_done(mmc, mrq);
 }
 
-static int tmio_mmc_clk_update(struct mmc_host *mmc)
-{
-        struct tmio_mmc_host *host = mmc_priv(mmc);
-        struct tmio_mmc_data *pdata = host->pdata;
-        int ret;
-
-        if (!pdata->clk_enable)
-                return -ENOTSUPP;
-
-        ret = pdata->clk_enable(host->pdev, &mmc->f_max);
-        if (!ret)
-                mmc->f_min = mmc->f_max / 512;
-
-        return ret;
-}
-
-static void tmio_mmc_set_power(struct tmio_mmc_host *host, struct mmc_ios *ios)
-{
-        struct mmc_host *mmc = host->mmc;
-
-        if (host->set_pwr)
-                host->set_pwr(host->pdev, ios->power_mode != MMC_POWER_OFF);
-        if (!IS_ERR(mmc->supply.vmmc))
-                /* Errors ignored... */
-                mmc_regulator_set_ocr(mmc, mmc->supply.vmmc,
-                                      ios->power_mode ? ios->vdd : 0);
-}
-
 /* Set MMC clock / power.
  * Note: This controller uses a simple divider scheme therefore it cannot
  * run a MMC card at full speed (20MHz). The max clock is 24MHz on SD, but as
@@ -789,7 +717,7 @@ static void tmio_mmc_set_power(struct tmio_mmc_host *host, struct mmc_ios *ios)
 static void tmio_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 {
         struct tmio_mmc_host *host = mmc_priv(mmc);
-        struct device *dev = &host->pdev->dev;
+        struct tmio_mmc_data *pdata = host->pdata;
         unsigned long flags;
 
         mutex_lock(&host->ios_lock);
@@ -797,13 +725,13 @@ static void tmio_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
         spin_lock_irqsave(&host->lock, flags);
         if (host->mrq) {
                 if (IS_ERR(host->mrq)) {
-                        dev_dbg(dev,
+                        dev_dbg(&host->pdev->dev,
                                 "%s.%d: concurrent .set_ios(), clk %u, mode %u\n",
                                 current->comm, task_pid_nr(current),
                                 ios->clock, ios->power_mode);
                         host->mrq = ERR_PTR(-EINTR);
                 } else {
-                        dev_dbg(dev,
+                        dev_dbg(&host->pdev->dev,
                                 "%s.%d: CMD%u active since %lu, now %lu!\n",
                                 current->comm, task_pid_nr(current),
                                 host->mrq->cmd->opcode, host->last_req_ts, jiffies);
@@ -819,44 +747,38 @@ static void tmio_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
         spin_unlock_irqrestore(&host->lock, flags);
 
         /*
-         * host->power toggles between false and true in both cases - either
-         * or not the controller can be runtime-suspended during inactivity.
-         * But if the controller has to be kept on, the runtime-pm usage_count
-         * is kept positive, so no suspending actually takes place.
+         * pdata->power == false only if COLD_CD is available, otherwise only
+         * in short time intervals during probing or resuming
          */
         if (ios->power_mode == MMC_POWER_ON && ios->clock) {
-                if (!host->power) {
-                        tmio_mmc_clk_update(mmc);
-                        pm_runtime_get_sync(dev);
-                        host->power = true;
+                if (!pdata->power) {
+                        pm_runtime_get_sync(&host->pdev->dev);
+                        pdata->power = true;
                 }
                 tmio_mmc_set_clock(host, ios->clock);
                 /* power up SD bus */
-                tmio_mmc_set_power(host, ios);
+                if (host->set_pwr)
+                        host->set_pwr(host->pdev, 1);
                 /* start bus clock */
                 tmio_mmc_clk_start(host);
         } else if (ios->power_mode != MMC_POWER_UP) {
-                if (ios->power_mode == MMC_POWER_OFF)
-                        tmio_mmc_set_power(host, ios);
-                if (host->power) {
-                        struct tmio_mmc_data *pdata = host->pdata;
-                        tmio_mmc_clk_stop(host);
-                        host->power = false;
-                        pm_runtime_put(dev);
-                        if (pdata->clk_disable)
-                                pdata->clk_disable(host->pdev);
+                if (host->set_pwr)
+                        host->set_pwr(host->pdev, 0);
+                if ((pdata->flags & TMIO_MMC_HAS_COLD_CD) &&
+                    pdata->power) {
+                        pdata->power = false;
+                        pm_runtime_put(&host->pdev->dev);
                 }
+                tmio_mmc_clk_stop(host);
         }
 
-        if (host->power) {
-                switch (ios->bus_width) {
-                case MMC_BUS_WIDTH_1:
-                        sd_ctrl_write16(host, CTL_SD_MEM_CARD_OPT, 0x80e0);
-                break;
-                case MMC_BUS_WIDTH_4:
-                        sd_ctrl_write16(host, CTL_SD_MEM_CARD_OPT, 0x00e0);
-                break;
-                }
+        switch (ios->bus_width) {
+        case MMC_BUS_WIDTH_1:
+                sd_ctrl_write16(host, CTL_SD_MEM_CARD_OPT, 0x80e0);
+        break;
+        case MMC_BUS_WIDTH_4:
+                sd_ctrl_write16(host, CTL_SD_MEM_CARD_OPT, 0x00e0);
+        break;
         }
 
         /* Let things settle. delay taken from winCE driver */
@@ -875,9 +797,6 @@ static int tmio_mmc_get_ro(struct mmc_host *mmc)
 {
         struct tmio_mmc_host *host = mmc_priv(mmc);
         struct tmio_mmc_data *pdata = host->pdata;
-        int ret = mmc_gpio_get_ro(mmc);
-        if (ret >= 0)
-                return ret;
 
         return !((pdata->flags & TMIO_MMC_WRPROTECT_DISABLE) ||
                  (sd_ctrl_read32(host, CTL_STATUS) & TMIO_STAT_WRPROTECT));
@@ -887,9 +806,6 @@ static int tmio_mmc_get_cd(struct mmc_host *mmc)
 {
         struct tmio_mmc_host *host = mmc_priv(mmc);
         struct tmio_mmc_data *pdata = host->pdata;
-        int ret = mmc_gpio_get_cd(mmc);
-        if (ret >= 0)
-                return ret;
 
         if (!pdata->get_cd)
                 return -ENOSYS;
@@ -905,20 +821,7 @@ static const struct mmc_host_ops tmio_mmc_ops = {
         .enable_sdio_irq = tmio_mmc_enable_sdio_irq,
 };
 
-static void tmio_mmc_init_ocr(struct tmio_mmc_host *host)
-{
-        struct tmio_mmc_data *pdata = host->pdata;
-        struct mmc_host *mmc = host->mmc;
-
-        mmc_regulator_get_supply(mmc);
-
-        if (!mmc->ocr_avail)
-                mmc->ocr_avail = pdata->ocr_mask ? : MMC_VDD_32_33 | MMC_VDD_33_34;
-        else if (pdata->ocr_mask)
-                dev_warn(mmc_dev(mmc), "Platform OCR mask is ignored\n");
-}
-
-int tmio_mmc_host_probe(struct tmio_mmc_host **host,
+int __devinit tmio_mmc_host_probe(struct tmio_mmc_host **host,
                                   struct platform_device *pdev,
                                   struct tmio_mmc_data *pdata)
 {
@@ -957,61 +860,29 @@ int tmio_mmc_host_probe(struct tmio_mmc_host **host,
 
         mmc->ops = &tmio_mmc_ops;
         mmc->caps = MMC_CAP_4_BIT_DATA | pdata->capabilities;
-        mmc->caps2 = pdata->capabilities2;
+        mmc->f_max = pdata->hclk;
+        mmc->f_min = mmc->f_max / 512;
         mmc->max_segs = 32;
         mmc->max_blk_size = 512;
         mmc->max_blk_count = (PAGE_CACHE_SIZE / mmc->max_blk_size) *
                 mmc->max_segs;
         mmc->max_req_size = mmc->max_blk_size * mmc->max_blk_count;
         mmc->max_seg_size = mmc->max_req_size;
-        tmio_mmc_init_ocr(_host);
-
-        _host->native_hotplug = !(pdata->flags & TMIO_MMC_USE_GPIO_CD ||
-                                  mmc->caps & MMC_CAP_NEEDS_POLL ||
-                                  mmc->caps & MMC_CAP_NONREMOVABLE);
+        if (pdata->ocr_mask)
+                mmc->ocr_avail = pdata->ocr_mask;
+        else
+                mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
 
-        _host->power = false;
+        pdata->power = false;
         pm_runtime_enable(&pdev->dev);
         ret = pm_runtime_resume(&pdev->dev);
         if (ret < 0)
                 goto pm_disable;
 
-        if (tmio_mmc_clk_update(mmc) < 0) {
-                mmc->f_max = pdata->hclk;
-                mmc->f_min = mmc->f_max / 512;
-        }
-
-        /*
-         * There are 4 different scenarios for the card detection:
-         *  1) an external gpio irq handles the cd (best for power savings)
-         *  2) internal sdhi irq handles the cd
-         *  3) a worker thread polls the sdhi - indicated by MMC_CAP_NEEDS_POLL
-         *  4) the medium is non-removable - indicated by MMC_CAP_NONREMOVABLE
-         *
-         *  While we increment the runtime PM counter for all scenarios when
-         *  the mmc core activates us by calling an appropriate set_ios(), we
-         *  must additionally ensure that in case 2) the tmio mmc hardware stays
-         *  powered on during runtime for the card detection to work.
-         */
-        if (_host->native_hotplug)
-                pm_runtime_get_noresume(&pdev->dev);
-
         tmio_mmc_clk_stop(_host);
         tmio_mmc_reset(_host);
 
-        _host->sdcard_irq_mask = sd_ctrl_read32(_host, CTL_IRQ_MASK);
         tmio_mmc_disable_mmc_irqs(_host, TMIO_MASK_ALL);
-
-        /* Unmask the IRQs we want to know about */
-        if (!_host->chan_rx)
-                irq_mask |= TMIO_MASK_READOP;
-        if (!_host->chan_tx)
-                irq_mask |= TMIO_MASK_WRITEOP;
-        if (!_host->native_hotplug)
-                irq_mask &= ~(TMIO_STAT_CARD_REMOVE | TMIO_STAT_CARD_INSERT);
-
-        _host->sdcard_irq_mask &= ~irq_mask;
-
         if (pdata->flags & TMIO_MMC_SDIO_IRQ)
                 tmio_mmc_enable_sdio_irq(mmc, 0);
 
@@ -1025,23 +896,21 @@ int tmio_mmc_host_probe(struct tmio_mmc_host **host,
         /* See if we also get DMA */
         tmio_mmc_request_dma(_host, pdata);
 
-        ret = mmc_add_host(mmc);
-        if (pdata->clk_disable)
-                pdata->clk_disable(pdev);
-        if (ret < 0) {
-                tmio_mmc_host_remove(_host);
-                return ret;
+        /* We have to keep the device powered for its card detection to work */
+        if (!(pdata->flags & TMIO_MMC_HAS_COLD_CD)) {
+                pdata->power = true;
+                pm_runtime_get_noresume(&pdev->dev);
         }
 
-        dev_pm_qos_expose_latency_limit(&pdev->dev, 100);
+        mmc_add_host(mmc);
 
-        if (pdata->flags & TMIO_MMC_USE_GPIO_CD) {
-                ret = mmc_gpio_request_cd(mmc, pdata->cd_gpio);
-                if (ret < 0) {
-                        tmio_mmc_host_remove(_host);
-                        return ret;
-                }
-        }
+        /* Unmask the IRQs we want to know about */
+        if (!_host->chan_rx)
+                irq_mask |= TMIO_MASK_READOP;
+        if (!_host->chan_tx)
+                irq_mask |= TMIO_MASK_WRITEOP;
+
+        tmio_mmc_enable_mmc_irqs(_host, irq_mask);
 
         *host = _host;
 
@@ -1060,22 +929,18 @@ EXPORT_SYMBOL(tmio_mmc_host_probe);
 void tmio_mmc_host_remove(struct tmio_mmc_host *host)
 {
         struct platform_device *pdev = host->pdev;
-        struct tmio_mmc_data *pdata = host->pdata;
-        struct mmc_host *mmc = host->mmc;
 
-        if (pdata->flags & TMIO_MMC_USE_GPIO_CD)
-                /*
-                 * This means we can miss a card-eject, but this is anyway
-                 * possible, because of delayed processing of hotplug events.
-                 */
-                mmc_gpio_free_cd(mmc);
-
-        if (!host->native_hotplug)
+        /*
+         * We don't have to manipulate pdata->power here: if there is a card in
+         * the slot, the runtime PM is active and our .runtime_resume() will not
+         * be run. If there is no card in the slot and the platform can suspend
+         * the controller, the runtime PM is suspended and pdata->power == false,
+         * so, our .runtime_resume() will not try to detect a card in the slot.
+         */
+        if (host->pdata->flags & TMIO_MMC_HAS_COLD_CD)
                 pm_runtime_get_sync(&pdev->dev);
 
-        dev_pm_qos_hide_latency_limit(&pdev->dev);
-
-        mmc_remove_host(mmc);
+        mmc_remove_host(host->mmc);
         cancel_work_sync(&host->done);
         cancel_delayed_work_sync(&host->delayed_reset_work);
         tmio_mmc_release_dma(host);
@@ -1084,7 +949,7 @@ void tmio_mmc_host_remove(struct tmio_mmc_host *host)
         pm_runtime_disable(&pdev->dev);
 
         iounmap(host->ctl);
-        mmc_free_host(mmc);
+        mmc_free_host(host->mmc);
 }
 EXPORT_SYMBOL(tmio_mmc_host_remove);
 
@@ -1098,6 +963,8 @@ int tmio_mmc_host_suspend(struct device *dev)
         if (!ret)
                 tmio_mmc_disable_mmc_irqs(host, TMIO_MASK_ALL);
 
+        host->pm_error = pm_runtime_put_sync(dev);
+
         return ret;
 }
 EXPORT_SYMBOL(tmio_mmc_host_suspend);
@@ -1107,10 +974,20 @@ int tmio_mmc_host_resume(struct device *dev)
         struct mmc_host *mmc = dev_get_drvdata(dev);
         struct tmio_mmc_host *host = mmc_priv(mmc);
 
-        tmio_mmc_reset(host);
-        tmio_mmc_enable_dma(host, true);
-
         /* The MMC core will perform the complete set up */
+        host->pdata->power = false;
+
+        host->pm_global = true;
+        if (!host->pm_error)
+                pm_runtime_get_sync(dev);
+
+        if (host->pm_global) {
+                /* Runtime PM resume callback didn't run */
+                tmio_mmc_reset(host);
+                tmio_mmc_enable_dma(host, true);
+                host->pm_global = false;
+        }
+
         return mmc_resume_host(mmc);
 }
 EXPORT_SYMBOL(tmio_mmc_host_resume);
@@ -1127,10 +1004,19 @@ int tmio_mmc_host_runtime_resume(struct device *dev)
 {
         struct mmc_host *mmc = dev_get_drvdata(dev);
         struct tmio_mmc_host *host = mmc_priv(mmc);
+        struct tmio_mmc_data *pdata = host->pdata;
 
         tmio_mmc_reset(host);
         tmio_mmc_enable_dma(host, true);
 
+        if (pdata->power) {
+                /* Only entered after a card-insert interrupt */
+                if (!mmc->card)
+                        tmio_mmc_set_ios(mmc, &mmc->ios);
+                mmc_detect_change(mmc, msecs_to_jiffies(100));
+        }
+        host->pm_global = false;
+
         return 0;
 }
 EXPORT_SYMBOL(tmio_mmc_host_runtime_resume);