Merge branch 'dmaengine' into async-tx-next

Conflicts:
	crypto/async_tx/async_xor.c
	drivers/dma/ioat/dma_v2.h
	drivers/dma/ioat/pci.c
	drivers/md/raid5.c

1 files changed, 79 insertions, 29 deletions

diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
index 9234be2226e7..6779b4ecab18 100644
--- a/drivers/mmc/host/sdhci.c
+++ b/drivers/mmc/host/sdhci.c
@@ -78,6 +78,11 @@ static void sdhci_dumpregs(struct sdhci_host *host)
                 sdhci_readl(host, SDHCI_CAPABILITIES),
                 sdhci_readl(host, SDHCI_MAX_CURRENT));
 
+        if (host->flags & SDHCI_USE_ADMA)
+                printk(KERN_DEBUG DRIVER_NAME ": ADMA Err: 0x%08x | ADMA Ptr: 0x%08x\n",
+                       readl(host->ioaddr + SDHCI_ADMA_ERROR),
+                       readl(host->ioaddr + SDHCI_ADMA_ADDRESS));
+
         printk(KERN_DEBUG DRIVER_NAME ": ===========================================\n");
 }
 
@@ -579,7 +584,7 @@ static u8 sdhci_calc_timeout(struct sdhci_host *host, struct mmc_data *data)
          * longer to time out, but that's much better than having a too-short
          * timeout value.
          */
-        if ((host->quirks & SDHCI_QUIRK_BROKEN_TIMEOUT_VAL))
+        if (host->quirks & SDHCI_QUIRK_BROKEN_TIMEOUT_VAL)
                 return 0xE;
 
         /* timeout in us */
@@ -1005,12 +1010,34 @@ static void sdhci_set_power(struct sdhci_host *host, unsigned short power)
 {
         u8 pwr;
 
-        if (host->power == power)
+        if (power == (unsigned short)-1)
+                pwr = 0;
+        else {
+                switch (1 << power) {
+                case MMC_VDD_165_195:
+                        pwr = SDHCI_POWER_180;
+                        break;
+                case MMC_VDD_29_30:
+                case MMC_VDD_30_31:
+                        pwr = SDHCI_POWER_300;
+                        break;
+                case MMC_VDD_32_33:
+                case MMC_VDD_33_34:
+                        pwr = SDHCI_POWER_330;
+                        break;
+                default:
+                        BUG();
+                }
+        }
+
+        if (host->pwr == pwr)
                 return;
 
-        if (power == (unsigned short)-1) {
+        host->pwr = pwr;
+
+        if (pwr == 0) {
                 sdhci_writeb(host, 0, SDHCI_POWER_CONTROL);
-                goto out;
+                return;
         }
 
         /*
@@ -1020,35 +1047,23 @@ static void sdhci_set_power(struct sdhci_host *host, unsigned short power)
         if (!(host->quirks & SDHCI_QUIRK_SINGLE_POWER_WRITE))
                 sdhci_writeb(host, 0, SDHCI_POWER_CONTROL);
 
-        pwr = SDHCI_POWER_ON;
-
-        switch (1 << power) {
-        case MMC_VDD_165_195:
-                pwr |= SDHCI_POWER_180;
-                break;
-        case MMC_VDD_29_30:
-        case MMC_VDD_30_31:
-                pwr |= SDHCI_POWER_300;
-                break;
-        case MMC_VDD_32_33:
-        case MMC_VDD_33_34:
-                pwr |= SDHCI_POWER_330;
-                break;
-        default:
-                BUG();
-        }
-
         /*
          * At least the Marvell CaFe chip gets confused if we set the voltage
          * and set turn on power at the same time, so set the voltage first.
          */
-        if ((host->quirks & SDHCI_QUIRK_NO_SIMULT_VDD_AND_POWER))
-                sdhci_writeb(host, pwr & ~SDHCI_POWER_ON, SDHCI_POWER_CONTROL);
+        if (host->quirks & SDHCI_QUIRK_NO_SIMULT_VDD_AND_POWER)
+                sdhci_writeb(host, pwr, SDHCI_POWER_CONTROL);
+
+        pwr |= SDHCI_POWER_ON;
 
         sdhci_writeb(host, pwr, SDHCI_POWER_CONTROL);
 
-out:
-        host->power = power;
+        /*
+         * Some controllers need an extra 10ms delay of 10ms before they
+         * can apply clock after applying power
+         */
+        if (host->quirks & SDHCI_QUIRK_DELAY_AFTER_POWER)
+                mdelay(10);
 }
 
 /*****************************************************************************\
@@ -1374,6 +1389,35 @@ static void sdhci_cmd_irq(struct sdhci_host *host, u32 intmask)
                 sdhci_finish_command(host);
 }
 
+#ifdef DEBUG
+static void sdhci_show_adma_error(struct sdhci_host *host)
+{
+        const char *name = mmc_hostname(host->mmc);
+        u8 *desc = host->adma_desc;
+        __le32 *dma;
+        __le16 *len;
+        u8 attr;
+
+        sdhci_dumpregs(host);
+
+        while (true) {
+                dma = (__le32 *)(desc + 4);
+                len = (__le16 *)(desc + 2);
+                attr = *desc;
+
+                DBG("%s: %p: DMA 0x%08x, LEN 0x%04x, Attr=0x%02x\n",
+                    name, desc, le32_to_cpu(*dma), le16_to_cpu(*len), attr);
+
+                desc += 8;
+
+                if (attr & 2)
+                        break;
+        }
+}
+#else
+static void sdhci_show_adma_error(struct sdhci_host *host) { }
+#endif
+
 static void sdhci_data_irq(struct sdhci_host *host, u32 intmask)
 {
         BUG_ON(intmask == 0);
@@ -1403,8 +1447,11 @@ static void sdhci_data_irq(struct sdhci_host *host, u32 intmask)
                 host->data->error = -ETIMEDOUT;
         else if (intmask & (SDHCI_INT_DATA_CRC | SDHCI_INT_DATA_END_BIT))
                 host->data->error = -EILSEQ;
-        else if (intmask & SDHCI_INT_ADMA_ERROR)
+        else if (intmask & SDHCI_INT_ADMA_ERROR) {
+                printk(KERN_ERR "%s: ADMA error\n", mmc_hostname(host->mmc));
+                sdhci_show_adma_error(host);
                 host->data->error = -EIO;
+        }
 
         if (host->data->error)
                 sdhci_finish_data(host);
@@ -1721,7 +1768,10 @@ int sdhci_add_host(struct sdhci_host *host)
         mmc->ops = &sdhci_ops;
         mmc->f_min = host->max_clk / 256;
         mmc->f_max = host->max_clk;
-        mmc->caps = MMC_CAP_4_BIT_DATA | MMC_CAP_SDIO_IRQ;
+        mmc->caps = MMC_CAP_SDIO_IRQ;
+
+        if (!(host->quirks & SDHCI_QUIRK_FORCE_1_BIT_DATA))
+                mmc->caps |= MMC_CAP_4_BIT_DATA;
 
         if (caps & SDHCI_CAN_DO_HISPD)
                 mmc->caps |= MMC_CAP_SD_HIGHSPEED;
@@ -1794,7 +1844,7 @@ int sdhci_add_host(struct sdhci_host *host)
         /*
          * Maximum block count.
          */
-        mmc->max_blk_count = 65535;
+        mmc->max_blk_count = (host->quirks & SDHCI_QUIRK_NO_MULTIBLOCK) ? 1 : 65535;
 
         /*
          * Init tasklets.