Merge branch 'omap-fixes'

[linux-2.6-omap-h63xx.git] / drivers / mmc / host / sdhci.c

diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
index 6fbbc005dd7f39d515bbe70e06c38917f73575da..30d8e3d4e6fdbc727605aa3f99563980c38940dd 100644 (file)
--- a/drivers/mmc/host/sdhci.c
+++ b/drivers/mmc/host/sdhci.c
@@ -112,6 +112,9 @@ static void sdhci_set_card_detection(struct sdhci_host *host, bool enable)
 {
        u32 irqs = SDHCI_INT_CARD_REMOVE | SDHCI_INT_CARD_INSERT;
 
+       if (host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION)
+               return;
+
        if (enable)
                sdhci_unmask_irqs(host, irqs);
        else
@@ -131,6 +134,7 @@ static void sdhci_disable_card_detection(struct sdhci_host *host)
 static void sdhci_reset(struct sdhci_host *host, u8 mask)
 {
        unsigned long timeout;
+       u32 uninitialized_var(ier);
 
        if (host->quirks & SDHCI_QUIRK_NO_CARD_NO_RESET) {
                if (!(sdhci_readl(host, SDHCI_PRESENT_STATE) &
@@ -138,6 +142,9 @@ static void sdhci_reset(struct sdhci_host *host, u8 mask)
                        return;
        }
 
+       if (host->quirks & SDHCI_QUIRK_RESTORE_IRQS_AFTER_RESET)
+               ier = sdhci_readl(host, SDHCI_INT_ENABLE);
+
        sdhci_writeb(host, mask, SDHCI_SOFTWARE_RESET);
 
        if (mask & SDHCI_RESET_ALL)
@@ -157,6 +164,9 @@ static void sdhci_reset(struct sdhci_host *host, u8 mask)
                timeout--;
                mdelay(1);
        }
+
+       if (host->quirks & SDHCI_QUIRK_RESTORE_IRQS_AFTER_RESET)
+               sdhci_clear_set_irqs(host, SDHCI_INT_ALL_MASK, ier);
 }
 
 static void sdhci_init(struct sdhci_host *host)
@@ -333,6 +343,9 @@ static void sdhci_transfer_pio(struct sdhci_host *host)
                mask = ~0;
 
        while (sdhci_readl(host, SDHCI_PRESENT_STATE) & mask) {
+               if (host->quirks & SDHCI_QUIRK_PIO_NEEDS_DELAY)
+                       udelay(100);
+
                if (host->data->flags & MMC_DATA_READ)
                        sdhci_read_block_pio(host);
                else
@@ -946,6 +959,12 @@ static void sdhci_set_clock(struct sdhci_host *host, unsigned int clock)
        if (clock == host->clock)
                return;
 
+       if (host->ops->set_clock) {
+               host->ops->set_clock(host, clock);
+               if (host->quirks & SDHCI_QUIRK_NONSTANDARD_CLOCK)
+                       return;
+       }
+
        sdhci_writew(host, 0, SDHCI_CLOCK_CONTROL);
 
        if (clock == 0)
@@ -1041,6 +1060,7 @@ out:
 static void sdhci_request(struct mmc_host *mmc, struct mmc_request *mrq)
 {
        struct sdhci_host *host;
+       bool present;
        unsigned long flags;
 
        host = mmc_priv(mmc);
@@ -1055,8 +1075,14 @@ static void sdhci_request(struct mmc_host *mmc, struct mmc_request *mrq)
 
        host->mrq = mrq;
 
-       if (!(sdhci_readl(host, SDHCI_PRESENT_STATE) & SDHCI_CARD_PRESENT)
-               || (host->flags & SDHCI_DEVICE_DEAD)) {
+       /* If polling, assume that the card is always present. */
+       if (host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION)
+               present = true;
+       else
+               present = sdhci_readl(host, SDHCI_PRESENT_STATE) &
+                               SDHCI_CARD_PRESENT;
+
+       if (!present || host->flags & SDHCI_DEVICE_DEAD) {
                host->mrq->cmd->error = -ENOMEDIUM;
                tasklet_schedule(&host->finish_tasklet);
        } else
@@ -1139,6 +1165,8 @@ static int sdhci_get_ro(struct mmc_host *mmc)
 
        spin_unlock_irqrestore(&host->lock, flags);
 
+       if (host->quirks & SDHCI_QUIRK_INVERTED_WRITE_PROTECT)
+               return !!(present & SDHCI_WRITE_PROTECT);
        return !(present & SDHCI_WRITE_PROTECT);
 }
 
@@ -1662,19 +1690,27 @@ int sdhci_add_host(struct sdhci_host *host)
 
        host->max_clk =
                (caps & SDHCI_CLOCK_BASE_MASK) >> SDHCI_CLOCK_BASE_SHIFT;
+       host->max_clk *= 1000000;
        if (host->max_clk == 0) {
-               printk(KERN_ERR "%s: Hardware doesn't specify base clock "
-                       "frequency.\n", mmc_hostname(mmc));
-               return -ENODEV;
+               if (!host->ops->get_max_clock) {
+                       printk(KERN_ERR
+                              "%s: Hardware doesn't specify base clock "
+                              "frequency.\n", mmc_hostname(mmc));
+                       return -ENODEV;
+               }
+               host->max_clk = host->ops->get_max_clock(host);
        }
-       host->max_clk *= 1000000;
 
        host->timeout_clk =
                (caps & SDHCI_TIMEOUT_CLK_MASK) >> SDHCI_TIMEOUT_CLK_SHIFT;
        if (host->timeout_clk == 0) {
-               printk(KERN_ERR "%s: Hardware doesn't specify timeout clock "
-                       "frequency.\n", mmc_hostname(mmc));
-               return -ENODEV;
+               if (!host->ops->get_timeout_clock) {
+                       printk(KERN_ERR
+                              "%s: Hardware doesn't specify timeout clock "
+                              "frequency.\n", mmc_hostname(mmc));
+                       return -ENODEV;
+               }
+               host->timeout_clk = host->ops->get_timeout_clock(host);
        }
        if (caps & SDHCI_TIMEOUT_CLK_UNIT)
                host->timeout_clk *= 1000;
@@ -1690,6 +1726,9 @@ int sdhci_add_host(struct sdhci_host *host)
        if (caps & SDHCI_CAN_DO_HISPD)
                mmc->caps |= MMC_CAP_SD_HIGHSPEED;
 
+       if (host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION)
+               mmc->caps |= MMC_CAP_NEEDS_POLL;
+
        mmc->ocr_avail = 0;
        if (caps & SDHCI_CAN_VDD_330)
                mmc->ocr_avail |= MMC_VDD_32_33|MMC_VDD_33_34;
@@ -1738,13 +1777,19 @@ int sdhci_add_host(struct sdhci_host *host)
         * Maximum block size. This varies from controller to controller and
         * is specified in the capabilities register.
         */
-       mmc->max_blk_size = (caps & SDHCI_MAX_BLOCK_MASK) >> SDHCI_MAX_BLOCK_SHIFT;
-       if (mmc->max_blk_size >= 3) {
-               printk(KERN_WARNING "%s: Invalid maximum block size, "
-                       "assuming 512 bytes\n", mmc_hostname(mmc));
-               mmc->max_blk_size = 512;
-       } else
-               mmc->max_blk_size = 512 << mmc->max_blk_size;
+       if (host->quirks & SDHCI_QUIRK_FORCE_BLK_SZ_2048) {
+               mmc->max_blk_size = 2;
+       } else {
+               mmc->max_blk_size = (caps & SDHCI_MAX_BLOCK_MASK) >>
+                               SDHCI_MAX_BLOCK_SHIFT;
+               if (mmc->max_blk_size >= 3) {
+                       printk(KERN_WARNING "%s: Invalid maximum block size, "
+                               "assuming 512 bytes\n", mmc_hostname(mmc));
+                       mmc->max_blk_size = 0;
+               }
+       }
+
+       mmc->max_blk_size = 512 << mmc->max_blk_size;
 
        /*
         * Maximum block count.