10 files changed, 87 insertions, 43 deletions

diff --git a/drivers/mmc/core/sdio.c b/drivers/mmc/core/sdio.c
index bd2755e8d9a3..f332c52968b7 100644
--- a/drivers/mmc/core/sdio.c
+++ b/drivers/mmc/core/sdio.c
@@ -362,9 +362,8 @@ static int mmc_sdio_init_card(struct mmc_host *host, u32 ocr,
                 goto err;
         }
 
-        err = mmc_sd_get_cid(host, host->ocr & ocr, card->raw_cid);
-
-        if (!err) {
+        if (ocr & R4_MEMORY_PRESENT
+            && mmc_sd_get_cid(host, host->ocr & ocr, card->raw_cid) == 0) {
                 card->type = MMC_TYPE_SD_COMBO;
 
                 if (oldcard && (oldcard->type != MMC_TYPE_SD_COMBO ||
diff --git a/drivers/mmc/host/at91_mci.c b/drivers/mmc/host/at91_mci.c
index 5f3a599ead07..87226cd202a5 100644
--- a/drivers/mmc/host/at91_mci.c
+++ b/drivers/mmc/host/at91_mci.c
@@ -66,6 +66,7 @@
 #include <linux/clk.h>
 #include <linux/atmel_pdc.h>
 #include <linux/gfp.h>
+#include <linux/highmem.h>
 
 #include <linux/mmc/host.h>
 
diff --git a/drivers/mmc/host/imxmmc.c b/drivers/mmc/host/imxmmc.c
index 9a68ff4353a2..5a950b16d9e6 100644
--- a/drivers/mmc/host/imxmmc.c
+++ b/drivers/mmc/host/imxmmc.c
@@ -148,11 +148,12 @@ static int imxmci_start_clock(struct imxmci_host *host)
 
                 while (delay--) {
                         reg = readw(host->base + MMC_REG_STATUS);
-                        if (reg & STATUS_CARD_BUS_CLK_RUN)
+                        if (reg & STATUS_CARD_BUS_CLK_RUN) {
                                 /* Check twice before cut */
                                 reg = readw(host->base + MMC_REG_STATUS);
                                 if (reg & STATUS_CARD_BUS_CLK_RUN)
                                         return 0;
+                        }
 
                         if (test_bit(IMXMCI_PEND_STARTED_b, &host->pending_events))
                                 return 0;
diff --git a/drivers/mmc/host/mmci.c b/drivers/mmc/host/mmci.c
index 840b301b5671..f2e02d7d9f3d 100644
--- a/drivers/mmc/host/mmci.c
+++ b/drivers/mmc/host/mmci.c
@@ -41,23 +41,35 @@ static unsigned int fmax = 515633;
  * @clkreg: default value for MCICLOCK register
  * @clkreg_enable: enable value for MMCICLOCK register
  * @datalength_bits: number of bits in the MMCIDATALENGTH register
+ * @fifosize: number of bytes that can be written when MMCI_TXFIFOEMPTY
+ *            is asserted (likewise for RX)
+ * @fifohalfsize: number of bytes that can be written when MCI_TXFIFOHALFEMPTY
+ *                is asserted (likewise for RX)
  */
 struct variant_data {
         unsigned int            clkreg;
         unsigned int            clkreg_enable;
         unsigned int            datalength_bits;
+        unsigned int            fifosize;
+        unsigned int            fifohalfsize;
 };
 
 static struct variant_data variant_arm = {
+        .fifosize               = 16 * 4,
+        .fifohalfsize           = 8 * 4,
         .datalength_bits        = 16,
 };
 
 static struct variant_data variant_u300 = {
+        .fifosize               = 16 * 4,
+        .fifohalfsize           = 8 * 4,
         .clkreg_enable          = 1 << 13, /* HWFCEN */
         .datalength_bits        = 16,
 };
 
 static struct variant_data variant_ux500 = {
+        .fifosize               = 30 * 4,
+        .fifohalfsize           = 8 * 4,
         .clkreg                 = MCI_CLK_ENABLE,
         .clkreg_enable          = 1 << 14, /* HWFCEN */
         .datalength_bits        = 24,
@@ -138,6 +150,7 @@ static void mmci_init_sg(struct mmci_host *host, struct mmc_data *data)
 
 static void mmci_start_data(struct mmci_host *host, struct mmc_data *data)
 {
+        struct variant_data *variant = host->variant;
         unsigned int datactrl, timeout, irqmask;
         unsigned long long clks;
         void __iomem *base;
@@ -173,7 +186,7 @@ static void mmci_start_data(struct mmci_host *host, struct mmc_data *data)
                  * If we have less than a FIFOSIZE of bytes to transfer,
                  * trigger a PIO interrupt as soon as any data is available.
                  */
-                if (host->size < MCI_FIFOSIZE)
+                if (host->size < variant->fifosize)
                         irqmask |= MCI_RXDATAAVLBLMASK;
         } else {
                 /*
@@ -332,13 +345,15 @@ static int mmci_pio_read(struct mmci_host *host, char *buffer, unsigned int rema
 
 static int mmci_pio_write(struct mmci_host *host, char *buffer, unsigned int remain, u32 status)
 {
+        struct variant_data *variant = host->variant;
         void __iomem *base = host->base;
         char *ptr = buffer;
 
         do {
                 unsigned int count, maxcnt;
 
-                maxcnt = status & MCI_TXFIFOEMPTY ? MCI_FIFOSIZE : MCI_FIFOHALFSIZE;
+                maxcnt = status & MCI_TXFIFOEMPTY ?
+                         variant->fifosize : variant->fifohalfsize;
                 count = min(remain, maxcnt);
 
                 writesl(base + MMCIFIFO, ptr, count >> 2);
@@ -362,6 +377,7 @@ static irqreturn_t mmci_pio_irq(int irq, void *dev_id)
 {
         struct mmci_host *host = dev_id;
         struct sg_mapping_iter *sg_miter = &host->sg_miter;
+        struct variant_data *variant = host->variant;
         void __iomem *base = host->base;
         unsigned long flags;
         u32 status;
@@ -420,7 +436,7 @@ static irqreturn_t mmci_pio_irq(int irq, void *dev_id)
          * If we're nearing the end of the read, switch to
          * "any data available" mode.
          */
-        if (status & MCI_RXACTIVE && host->size < MCI_FIFOSIZE)
+        if (status & MCI_RXACTIVE && host->size < variant->fifosize)
                 writel(MCI_RXDATAAVLBLMASK, base + MMCIMASK1);
 
         /*
@@ -564,18 +580,23 @@ static int mmci_get_ro(struct mmc_host *mmc)
         if (host->gpio_wp == -ENOSYS)
                 return -ENOSYS;
 
-        return gpio_get_value(host->gpio_wp);
+        return gpio_get_value_cansleep(host->gpio_wp);
 }
 
 static int mmci_get_cd(struct mmc_host *mmc)
 {
         struct mmci_host *host = mmc_priv(mmc);
+        struct mmci_platform_data *plat = host->plat;
         unsigned int status;
 
-        if (host->gpio_cd == -ENOSYS)
-                status = host->plat->status(mmc_dev(host->mmc));
-        else
-                status = !gpio_get_value(host->gpio_cd);
+        if (host->gpio_cd == -ENOSYS) {
+                if (!plat->status)
+                        return 1; /* Assume always present */
+
+                status = plat->status(mmc_dev(host->mmc));
+        } else
+                status = !!gpio_get_value_cansleep(host->gpio_cd)
+                        ^ plat->cd_invert;
 
         /*
          * Use positive logic throughout - status is zero for no card,
@@ -584,6 +605,15 @@ static int mmci_get_cd(struct mmc_host *mmc)
         return status;
 }
 
+static irqreturn_t mmci_cd_irq(int irq, void *dev_id)
+{
+        struct mmci_host *host = dev_id;
+
+        mmc_detect_change(host->mmc, msecs_to_jiffies(500));
+
+        return IRQ_HANDLED;
+}
+
 static const struct mmc_host_ops mmci_ops = {
         .request        = mmci_request,
         .set_ios        = mmci_set_ios,
@@ -620,6 +650,7 @@ static int __devinit mmci_probe(struct amba_device *dev, struct amba_id *id)
 
         host->gpio_wp = -ENOSYS;
         host->gpio_cd = -ENOSYS;
+        host->gpio_cd_irq = -1;
 
         host->hw_designer = amba_manf(dev);
         host->hw_revision = amba_rev(dev);
@@ -699,7 +730,6 @@ static int __devinit mmci_probe(struct amba_device *dev, struct amba_id *id)
         if (host->vcc == NULL)
                 mmc->ocr_avail = plat->ocr_mask;
         mmc->caps = plat->capabilities;
-        mmc->caps |= MMC_CAP_NEEDS_POLL;
 
         /*
          * We can do SGIO
@@ -744,6 +774,12 @@ static int __devinit mmci_probe(struct amba_device *dev, struct amba_id *id)
                         host->gpio_cd = plat->gpio_cd;
                 else if (ret != -ENOSYS)
                         goto err_gpio_cd;
+
+                ret = request_any_context_irq(gpio_to_irq(plat->gpio_cd),
+                                              mmci_cd_irq, 0,
+                                              DRIVER_NAME " (cd)", host);
+                if (ret >= 0)
+                        host->gpio_cd_irq = gpio_to_irq(plat->gpio_cd);
         }
         if (gpio_is_valid(plat->gpio_wp)) {
                 ret = gpio_request(plat->gpio_wp, DRIVER_NAME " (wp)");
@@ -755,6 +791,10 @@ static int __devinit mmci_probe(struct amba_device *dev, struct amba_id *id)
                         goto err_gpio_wp;
         }
 
+        if ((host->plat->status || host->gpio_cd != -ENOSYS)
+            && host->gpio_cd_irq < 0)
+                mmc->caps |= MMC_CAP_NEEDS_POLL;
+
         ret = request_irq(dev->irq[0], mmci_irq, IRQF_SHARED, DRIVER_NAME " (cmd)", host);
         if (ret)
                 goto unmap;
@@ -781,6 +821,8 @@ static int __devinit mmci_probe(struct amba_device *dev, struct amba_id *id)
         if (host->gpio_wp != -ENOSYS)
                 gpio_free(host->gpio_wp);
  err_gpio_wp:
+        if (host->gpio_cd_irq >= 0)
+                free_irq(host->gpio_cd_irq, host);
         if (host->gpio_cd != -ENOSYS)
                 gpio_free(host->gpio_cd);
  err_gpio_cd:
@@ -819,6 +861,8 @@ static int __devexit mmci_remove(struct amba_device *dev)
 
                 if (host->gpio_wp != -ENOSYS)
                         gpio_free(host->gpio_wp);
+                if (host->gpio_cd_irq >= 0)
+                        free_irq(host->gpio_cd_irq, host);
                 if (host->gpio_cd != -ENOSYS)
                         gpio_free(host->gpio_cd);
 
diff --git a/drivers/mmc/host/mmci.h b/drivers/mmc/host/mmci.h
index 68970cfb81e1..4ae887fc0189 100644
--- a/drivers/mmc/host/mmci.h
+++ b/drivers/mmc/host/mmci.h
@@ -54,10 +54,16 @@
 #define MCI_DPSM_MODE           (1 << 2)
 #define MCI_DPSM_DMAENABLE      (1 << 3)
 #define MCI_DPSM_BLOCKSIZE      (1 << 4)
-#define MCI_DPSM_RWSTART        (1 << 8)
-#define MCI_DPSM_RWSTOP         (1 << 9)
-#define MCI_DPSM_RWMOD          (1 << 10)
-#define MCI_DPSM_SDIOEN         (1 << 11)
+/* Control register extensions in the ST Micro U300 and Ux500 versions */
+#define MCI_ST_DPSM_RWSTART     (1 << 8)
+#define MCI_ST_DPSM_RWSTOP      (1 << 9)
+#define MCI_ST_DPSM_RWMOD       (1 << 10)
+#define MCI_ST_DPSM_SDIOEN      (1 << 11)
+/* Control register extensions in the ST Micro Ux500 versions */
+#define MCI_ST_DPSM_DMAREQCTL   (1 << 12)
+#define MCI_ST_DPSM_DBOOTMODEEN (1 << 13)
+#define MCI_ST_DPSM_BUSYMODE    (1 << 14)
+#define MCI_ST_DPSM_DDRMODE     (1 << 15)
 
 #define MMCIDATACNT             0x030
 #define MMCISTATUS              0x034
@@ -133,13 +139,6 @@
         MCI_DATATIMEOUTMASK|MCI_TXUNDERRUNMASK|MCI_RXOVERRUNMASK|       \
         MCI_CMDRESPENDMASK|MCI_CMDSENTMASK|MCI_DATABLOCKENDMASK)
 
-/*
- * The size of the FIFO in bytes.
- */
-#define MCI_FIFOSIZE    (16*4)
-        
-#define MCI_FIFOHALFSIZE (MCI_FIFOSIZE / 2)
-
 #define NR_SG           16
 
 struct clk;
@@ -154,6 +153,7 @@ struct mmci_host {
         struct clk              *clk;
         int                     gpio_cd;
         int                     gpio_wp;
+        int                     gpio_cd_irq;
 
         unsigned int            data_xfered;
 
diff --git a/drivers/mmc/host/omap_hsmmc.c b/drivers/mmc/host/omap_hsmmc.c
index 4a8776f8afdd..4526d2791f29 100644
--- a/drivers/mmc/host/omap_hsmmc.c
+++ b/drivers/mmc/host/omap_hsmmc.c
@@ -2305,7 +2305,6 @@ static int omap_hsmmc_suspend(struct device *dev)
         int ret = 0;
         struct platform_device *pdev = to_platform_device(dev);
         struct omap_hsmmc_host *host = platform_get_drvdata(pdev);
-        pm_message_t state = PMSG_SUSPEND; /* unused by MMC core */
 
         if (host && host->suspended)
                 return 0;
@@ -2324,8 +2323,8 @@ static int omap_hsmmc_suspend(struct device *dev)
                         }
                 }
                 cancel_work_sync(&host->mmc_carddetect_work);
-                mmc_host_enable(host->mmc);
                 ret = mmc_suspend_host(host->mmc);
+                mmc_host_enable(host->mmc);
                 if (ret == 0) {
                         omap_hsmmc_disable_irq(host);
                         OMAP_HSMMC_WRITE(host->base, HCTL,
diff --git a/drivers/mmc/host/s3cmci.c b/drivers/mmc/host/s3cmci.c
index 2e16e0a90a5e..976330de379e 100644
--- a/drivers/mmc/host/s3cmci.c
+++ b/drivers/mmc/host/s3cmci.c
@@ -1600,7 +1600,7 @@ static int __devinit s3cmci_probe(struct platform_device *pdev)
         host->pio_active        = XFER_NONE;
 
 #ifdef CONFIG_MMC_S3C_PIODMA
-        host->dodma             = host->pdata->dma;
+        host->dodma             = host->pdata->use_dma;
 #endif
 
         host->mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
diff --git a/drivers/mmc/host/sdhci-s3c.c b/drivers/mmc/host/sdhci-s3c.c
index 71ad4163b95e..aacb862ecc8a 100644
--- a/drivers/mmc/host/sdhci-s3c.c
+++ b/drivers/mmc/host/sdhci-s3c.c
@@ -241,8 +241,10 @@ static struct sdhci_ops sdhci_s3c_ops = {
 static void sdhci_s3c_notify_change(struct platform_device *dev, int state)
 {
         struct sdhci_host *host = platform_get_drvdata(dev);
+        unsigned long flags;
+
         if (host) {
-                spin_lock(&host->lock);
+                spin_lock_irqsave(&host->lock, flags);
                 if (state) {
                         dev_dbg(&dev->dev, "card inserted.\n");
                         host->flags &= ~SDHCI_DEVICE_DEAD;
@@ -253,7 +255,7 @@ static void sdhci_s3c_notify_change(struct platform_device *dev, int state)
                         host->quirks &= ~SDHCI_QUIRK_BROKEN_CARD_DETECTION;
                 }
                 tasklet_schedule(&host->card_tasklet);
-                spin_unlock(&host->lock);
+                spin_unlock_irqrestore(&host->lock, flags);
         }
 }
 
@@ -481,8 +483,10 @@ static int __devexit sdhci_s3c_remove(struct platform_device *pdev)
         sdhci_remove_host(host, 1);
 
         for (ptr = 0; ptr < 3; ptr++) {
-                clk_disable(sc->clk_bus[ptr]);
-                clk_put(sc->clk_bus[ptr]);
+                if (sc->clk_bus[ptr]) {
+                        clk_disable(sc->clk_bus[ptr]);
+                        clk_put(sc->clk_bus[ptr]);
+                }
         }
         clk_disable(sc->clk_io);
         clk_put(sc->clk_io);
diff --git a/drivers/mmc/host/tmio_mmc.c b/drivers/mmc/host/tmio_mmc.c
index ee7d0a5a51c4..69d98e3bf6ab 100644
--- a/drivers/mmc/host/tmio_mmc.c
+++ b/drivers/mmc/host/tmio_mmc.c
@@ -164,6 +164,7 @@ tmio_mmc_start_command(struct tmio_mmc_host *host, struct mmc_command *cmd)
 static void tmio_mmc_pio_irq(struct tmio_mmc_host *host)
 {
         struct mmc_data *data = host->data;
+        void *sg_virt;
         unsigned short *buf;
         unsigned int count;
         unsigned long flags;
@@ -173,8 +174,8 @@ static void tmio_mmc_pio_irq(struct tmio_mmc_host *host)
                 return;
         }
 
-        buf = (unsigned short *)(tmio_mmc_kmap_atomic(host, &flags) +
-              host->sg_off);
+        sg_virt = tmio_mmc_kmap_atomic(host->sg_ptr, &flags);
+        buf = (unsigned short *)(sg_virt + host->sg_off);
 
         count = host->sg_ptr->length - host->sg_off;
         if (count > data->blksz)
@@ -191,7 +192,7 @@ static void tmio_mmc_pio_irq(struct tmio_mmc_host *host)
 
         host->sg_off += count;
 
-        tmio_mmc_kunmap_atomic(host, &flags);
+        tmio_mmc_kunmap_atomic(sg_virt, &flags);
 
         if (host->sg_off == host->sg_ptr->length)
                 tmio_mmc_next_sg(host);
diff --git a/drivers/mmc/host/tmio_mmc.h b/drivers/mmc/host/tmio_mmc.h
index 64f7d5dfc106..0fedc78e3ea5 100644
--- a/drivers/mmc/host/tmio_mmc.h
+++ b/drivers/mmc/host/tmio_mmc.h
@@ -82,10 +82,7 @@
 
 #define ack_mmc_irqs(host, i) \
         do { \
-                u32 mask;\
-                mask  = sd_ctrl_read32((host), CTL_STATUS); \
-                mask &= ~((i) & TMIO_MASK_IRQ); \
-                sd_ctrl_write32((host), CTL_STATUS, mask); \
+                sd_ctrl_write32((host), CTL_STATUS, ~(i)); \
         } while (0)
 
 
@@ -177,19 +174,17 @@ static inline int tmio_mmc_next_sg(struct tmio_mmc_host *host)
         return --host->sg_len;
 }
 
-static inline char *tmio_mmc_kmap_atomic(struct tmio_mmc_host *host,
+static inline char *tmio_mmc_kmap_atomic(struct scatterlist *sg,
         unsigned long *flags)
 {
-        struct scatterlist *sg = host->sg_ptr;
-
         local_irq_save(*flags);
         return kmap_atomic(sg_page(sg), KM_BIO_SRC_IRQ) + sg->offset;
 }
 
-static inline void tmio_mmc_kunmap_atomic(struct tmio_mmc_host *host,
+static inline void tmio_mmc_kunmap_atomic(void *virt,
         unsigned long *flags)
 {
-        kunmap_atomic(sg_page(host->sg_ptr), KM_BIO_SRC_IRQ);
+        kunmap_atomic(virt, KM_BIO_SRC_IRQ);
         local_irq_restore(*flags);
 }