Merge branch 'lpc32xx/drivers' into next/drivers

* lpc32xx/drivers: (566 commits)
  ARM: LPC32xx: ADC support for mach-lpc32xx

Includes an update to Linux 3.3-rc4

Signed-off-by: Arnd Bergmann <arnd@arndb.de>

11 files changed, 154 insertions, 83 deletions

diff --git a/drivers/mmc/host/Kconfig b/drivers/mmc/host/Kconfig
index cf444b0ca2cc..00fcbed1afd2 100644
--- a/drivers/mmc/host/Kconfig
+++ b/drivers/mmc/host/Kconfig
@@ -477,7 +477,6 @@ config MMC_SDHI
 config MMC_CB710
         tristate "ENE CB710 MMC/SD Interface support"
         depends on PCI
-        select MISC_DEVICES
         select CB710_CORE
         help
           This option enables support for MMC/SD part of ENE CB710/720 Flash
diff --git a/drivers/mmc/host/atmel-mci.c b/drivers/mmc/host/atmel-mci.c
index fcfe1eb5acc8..6985cdb0bb26 100644
--- a/drivers/mmc/host/atmel-mci.c
+++ b/drivers/mmc/host/atmel-mci.c
@@ -969,11 +969,14 @@ static void atmci_start_request(struct atmel_mci *host,
         host->data_status = 0;
 
         if (host->need_reset) {
+                iflags = atmci_readl(host, ATMCI_IMR);
+                iflags &= (ATMCI_SDIOIRQA | ATMCI_SDIOIRQB);
                 atmci_writel(host, ATMCI_CR, ATMCI_CR_SWRST);
                 atmci_writel(host, ATMCI_CR, ATMCI_CR_MCIEN);
                 atmci_writel(host, ATMCI_MR, host->mode_reg);
                 if (host->caps.has_cfg_reg)
                         atmci_writel(host, ATMCI_CFG, host->cfg_reg);
+                atmci_writel(host, ATMCI_IER, iflags);
                 host->need_reset = false;
         }
         atmci_writel(host, ATMCI_SDCR, slot->sdc_reg);
diff --git a/drivers/mmc/host/dw_mmc.c b/drivers/mmc/host/dw_mmc.c
index 0e342793ff14..8bec1c36b159 100644
--- a/drivers/mmc/host/dw_mmc.c
+++ b/drivers/mmc/host/dw_mmc.c
@@ -22,7 +22,6 @@
 #include <linux/ioport.h>
 #include <linux/module.h>
 #include <linux/platform_device.h>
-#include <linux/scatterlist.h>
 #include <linux/seq_file.h>
 #include <linux/slab.h>
 #include <linux/stat.h>
@@ -502,8 +501,14 @@ static void dw_mci_submit_data(struct dw_mci *host, struct mmc_data *data)
                 host->dir_status = DW_MCI_SEND_STATUS;
 
         if (dw_mci_submit_data_dma(host, data)) {
+                int flags = SG_MITER_ATOMIC;
+                if (host->data->flags & MMC_DATA_READ)
+                        flags |= SG_MITER_TO_SG;
+                else
+                        flags |= SG_MITER_FROM_SG;
+
+                sg_miter_start(&host->sg_miter, data->sg, data->sg_len, flags);
                 host->sg = data->sg;
-                host->pio_offset = 0;
                 host->part_buf_start = 0;
                 host->part_buf_count = 0;
 
@@ -972,6 +977,7 @@ static void dw_mci_tasklet_func(unsigned long priv)
                                  * generates a block interrupt, hence setting
                                  * the scatter-gather pointer to NULL.
                                  */
+                                sg_miter_stop(&host->sg_miter);
                                 host->sg = NULL;
                                 ctrl = mci_readl(host, CTRL);
                                 ctrl |= SDMMC_CTRL_FIFO_RESET;
@@ -1311,54 +1317,44 @@ static void dw_mci_pull_data(struct dw_mci *host, void *buf, int cnt)
 
 static void dw_mci_read_data_pio(struct dw_mci *host)
 {
-        struct scatterlist *sg = host->sg;
-        void *buf = sg_virt(sg);
-        unsigned int offset = host->pio_offset;
+        struct sg_mapping_iter *sg_miter = &host->sg_miter;
+        void *buf;
+        unsigned int offset;
         struct mmc_data *data = host->data;
         int shift = host->data_shift;
         u32 status;
         unsigned int nbytes = 0, len;
+        unsigned int remain, fcnt;
 
         do {
-                len = host->part_buf_count +
-                        (SDMMC_GET_FCNT(mci_readl(host, STATUS)) << shift);
-                if (offset + len <= sg->length) {
+                if (!sg_miter_next(sg_miter))
+                        goto done;
+
+                host->sg = sg_miter->__sg;
+                buf = sg_miter->addr;
+                remain = sg_miter->length;
+                offset = 0;
+
+                do {
+                        fcnt = (SDMMC_GET_FCNT(mci_readl(host, STATUS))
+                                        << shift) + host->part_buf_count;
+                        len = min(remain, fcnt);
+                        if (!len)
+                                break;
                         dw_mci_pull_data(host, (void *)(buf + offset), len);
-
                         offset += len;
                         nbytes += len;
-
-                        if (offset == sg->length) {
-                                flush_dcache_page(sg_page(sg));
-                                host->sg = sg = sg_next(sg);
-                                if (!sg)
-                                        goto done;
-
-                                offset = 0;
-                                buf = sg_virt(sg);
-                        }
-                } else {
-                        unsigned int remaining = sg->length - offset;
-                        dw_mci_pull_data(host, (void *)(buf + offset),
-                                         remaining);
-                        nbytes += remaining;
-
-                        flush_dcache_page(sg_page(sg));
-                        host->sg = sg = sg_next(sg);
-                        if (!sg)
-                                goto done;
-
-                        offset = len - remaining;
-                        buf = sg_virt(sg);
-                        dw_mci_pull_data(host, buf, offset);
-                        nbytes += offset;
-                }
+                        remain -= len;
+                } while (remain);
+                sg_miter->consumed = offset;
 
                 status = mci_readl(host, MINTSTS);
                 mci_writel(host, RINTSTS, SDMMC_INT_RXDR);
                 if (status & DW_MCI_DATA_ERROR_FLAGS) {
                         host->data_status = status;
                         data->bytes_xfered += nbytes;
+                        sg_miter_stop(sg_miter);
+                        host->sg = NULL;
                         smp_wmb();
 
                         set_bit(EVENT_DATA_ERROR, &host->pending_events);
@@ -1367,65 +1363,66 @@ static void dw_mci_read_data_pio(struct dw_mci *host)
                         return;
                 }
         } while (status & SDMMC_INT_RXDR); /*if the RXDR is ready read again*/
-        host->pio_offset = offset;
         data->bytes_xfered += nbytes;
+
+        if (!remain) {
+                if (!sg_miter_next(sg_miter))
+                        goto done;
+                sg_miter->consumed = 0;
+        }
+        sg_miter_stop(sg_miter);
         return;
 
 done:
         data->bytes_xfered += nbytes;
+        sg_miter_stop(sg_miter);
+        host->sg = NULL;
         smp_wmb();
         set_bit(EVENT_XFER_COMPLETE, &host->pending_events);
 }
 
 static void dw_mci_write_data_pio(struct dw_mci *host)
 {
-        struct scatterlist *sg = host->sg;
-        void *buf = sg_virt(sg);
-        unsigned int offset = host->pio_offset;
+        struct sg_mapping_iter *sg_miter = &host->sg_miter;
+        void *buf;
+        unsigned int offset;
         struct mmc_data *data = host->data;
         int shift = host->data_shift;
         u32 status;
         unsigned int nbytes = 0, len;
+        unsigned int fifo_depth = host->fifo_depth;
+        unsigned int remain, fcnt;
 
         do {
-                len = ((host->fifo_depth -
-                        SDMMC_GET_FCNT(mci_readl(host, STATUS))) << shift)
-                        - host->part_buf_count;
-                if (offset + len <= sg->length) {
+                if (!sg_miter_next(sg_miter))
+                        goto done;
+
+                host->sg = sg_miter->__sg;
+                buf = sg_miter->addr;
+                remain = sg_miter->length;
+                offset = 0;
+
+                do {
+                        fcnt = ((fifo_depth -
+                                 SDMMC_GET_FCNT(mci_readl(host, STATUS)))
+                                        << shift) - host->part_buf_count;
+                        len = min(remain, fcnt);
+                        if (!len)
+                                break;
                         host->push_data(host, (void *)(buf + offset), len);
-
                         offset += len;
                         nbytes += len;
-                        if (offset == sg->length) {
-                                host->sg = sg = sg_next(sg);
-                                if (!sg)
-                                        goto done;
-
-                                offset = 0;
-                                buf = sg_virt(sg);
-                        }
-                } else {
-                        unsigned int remaining = sg->length - offset;
-
-                        host->push_data(host, (void *)(buf + offset),
-                                        remaining);
-                        nbytes += remaining;
-
-                        host->sg = sg = sg_next(sg);
-                        if (!sg)
-                                goto done;
-
-                        offset = len - remaining;
-                        buf = sg_virt(sg);
-                        host->push_data(host, (void *)buf, offset);
-                        nbytes += offset;
-                }
+                        remain -= len;
+                } while (remain);
+                sg_miter->consumed = offset;
 
                 status = mci_readl(host, MINTSTS);
                 mci_writel(host, RINTSTS, SDMMC_INT_TXDR);
                 if (status & DW_MCI_DATA_ERROR_FLAGS) {
                         host->data_status = status;
                         data->bytes_xfered += nbytes;
+                        sg_miter_stop(sg_miter);
+                        host->sg = NULL;
 
                         smp_wmb();
 
@@ -1435,12 +1432,20 @@ static void dw_mci_write_data_pio(struct dw_mci *host)
                         return;
                 }
         } while (status & SDMMC_INT_TXDR); /* if TXDR write again */
-        host->pio_offset = offset;
         data->bytes_xfered += nbytes;
+
+        if (!remain) {
+                if (!sg_miter_next(sg_miter))
+                        goto done;
+                sg_miter->consumed = 0;
+        }
+        sg_miter_stop(sg_miter);
         return;
 
 done:
         data->bytes_xfered += nbytes;
+        sg_miter_stop(sg_miter);
+        host->sg = NULL;
         smp_wmb();
         set_bit(EVENT_XFER_COMPLETE, &host->pending_events);
 }
@@ -1643,6 +1648,7 @@ static void dw_mci_work_routine_card(struct work_struct *work)
                                  * block interrupt, hence setting the
                                  * scatter-gather pointer to NULL.
                                  */
+                                sg_miter_stop(&host->sg_miter);
                                 host->sg = NULL;
 
                                 ctrl = mci_readl(host, CTRL);
diff --git a/drivers/mmc/host/of_mmc_spi.c b/drivers/mmc/host/of_mmc_spi.c
index ab66f2454dc4..1534b582c419 100644
--- a/drivers/mmc/host/of_mmc_spi.c
+++ b/drivers/mmc/host/of_mmc_spi.c
@@ -113,8 +113,8 @@ struct mmc_spi_platform_data *mmc_spi_get_pdata(struct spi_device *spi)
                 const int j = i * 2;
                 u32 mask;
 
-                mask = mmc_vddrange_to_ocrmask(voltage_ranges[j],
-                                               voltage_ranges[j + 1]);
+                mask = mmc_vddrange_to_ocrmask(be32_to_cpu(voltage_ranges[j]),
+                                               be32_to_cpu(voltage_ranges[j + 1]));
                 if (!mask) {
                         ret = -EINVAL;
                         dev_err(dev, "OF: voltage-range #%d is invalid\n", i);
diff --git a/drivers/mmc/host/sdhci-of-esdhc.c b/drivers/mmc/host/sdhci-of-esdhc.c
index ff4adc018041..5d876ff86f37 100644
--- a/drivers/mmc/host/sdhci-of-esdhc.c
+++ b/drivers/mmc/host/sdhci-of-esdhc.c
@@ -38,6 +38,23 @@ static u8 esdhc_readb(struct sdhci_host *host, int reg)
         int base = reg & ~0x3;
         int shift = (reg & 0x3) * 8;
         u8 ret = (in_be32(host->ioaddr + base) >> shift) & 0xff;
+
+        /*
+         * "DMA select" locates at offset 0x28 in SD specification, but on
+         * P5020 or P3041, it locates at 0x29.
+         */
+        if (reg == SDHCI_HOST_CONTROL) {
+                u32 dma_bits;
+
+                dma_bits = in_be32(host->ioaddr + reg);
+                /* DMA select is 22,23 bits in Protocol Control Register */
+                dma_bits = (dma_bits >> 5) & SDHCI_CTRL_DMA_MASK;
+
+                /* fixup the result */
+                ret &= ~SDHCI_CTRL_DMA_MASK;
+                ret |= dma_bits;
+        }
+
         return ret;
 }
 
@@ -56,6 +73,21 @@ static void esdhc_writew(struct sdhci_host *host, u16 val, int reg)
 
 static void esdhc_writeb(struct sdhci_host *host, u8 val, int reg)
 {
+        /*
+         * "DMA select" location is offset 0x28 in SD specification, but on
+         * P5020 or P3041, it's located at 0x29.
+         */
+        if (reg == SDHCI_HOST_CONTROL) {
+                u32 dma_bits;
+
+                /* DMA select is 22,23 bits in Protocol Control Register */
+                dma_bits = (val & SDHCI_CTRL_DMA_MASK) << 5;
+                clrsetbits_be32(host->ioaddr + reg , SDHCI_CTRL_DMA_MASK << 5,
+                        dma_bits);
+                val &= ~SDHCI_CTRL_DMA_MASK;
+                val |= in_be32(host->ioaddr + reg) & SDHCI_CTRL_DMA_MASK;
+        }
+
         /* Prevent SDHCI core from writing reserved bits (e.g. HISPD). */
         if (reg == SDHCI_HOST_CONTROL)
                 val &= ~ESDHC_HOST_CONTROL_RES;
diff --git a/drivers/mmc/host/sdhci-pci.c b/drivers/mmc/host/sdhci-pci.c
index 7165e6a09274..6ebdc4010e7c 100644
--- a/drivers/mmc/host/sdhci-pci.c
+++ b/drivers/mmc/host/sdhci-pci.c
@@ -250,7 +250,7 @@ static int mfd_emmc_probe_slot(struct sdhci_pci_slot *slot)
 
 static int mfd_sdio_probe_slot(struct sdhci_pci_slot *slot)
 {
-        slot->host->mmc->caps |= MMC_CAP_POWER_OFF_CARD;
+        slot->host->mmc->caps |= MMC_CAP_POWER_OFF_CARD | MMC_CAP_NONREMOVABLE;
         return 0;
 }
 
diff --git a/drivers/mmc/host/sdhci-pltfm.c b/drivers/mmc/host/sdhci-pltfm.c
index 03970bcb3495..c5c2a48bdd94 100644
--- a/drivers/mmc/host/sdhci-pltfm.c
+++ b/drivers/mmc/host/sdhci-pltfm.c
@@ -2,7 +2,7 @@
  * sdhci-pltfm.c Support for SDHCI platform devices
  * Copyright (c) 2009 Intel Corporation
  *
- * Copyright (c) 2007 Freescale Semiconductor, Inc.
+ * Copyright (c) 2007, 2011 Freescale Semiconductor, Inc.
  * Copyright (c) 2009 MontaVista Software, Inc.
  *
  * Authors: Xiaobo Xie <X.Xie@freescale.com>
@@ -71,6 +71,14 @@ void sdhci_get_of_property(struct platform_device *pdev)
                 if (sdhci_of_wp_inverted(np))
                         host->quirks |= SDHCI_QUIRK_INVERTED_WRITE_PROTECT;
 
+                if (of_device_is_compatible(np, "fsl,p2020-rev1-esdhc"))
+                        host->quirks |= SDHCI_QUIRK_BROKEN_DMA;
+
+                if (of_device_is_compatible(np, "fsl,p2020-esdhc") ||
+                    of_device_is_compatible(np, "fsl,p1010-esdhc") ||
+                    of_device_is_compatible(np, "fsl,mpc8536-esdhc"))
+                        host->quirks |= SDHCI_QUIRK_BROKEN_TIMEOUT_VAL;
+
                 clk = of_get_property(np, "clock-frequency", &size);
                 if (clk && size == sizeof(*clk) && *clk)
                         pltfm_host->clock = be32_to_cpup(clk);
diff --git a/drivers/mmc/host/sh_mmcif.c b/drivers/mmc/host/sh_mmcif.c
index f5d8b53be333..352d4797865b 100644
--- a/drivers/mmc/host/sh_mmcif.c
+++ b/drivers/mmc/host/sh_mmcif.c
@@ -1327,7 +1327,7 @@ static int __devinit sh_mmcif_probe(struct platform_device *pdev)
         if (ret < 0)
                 goto clean_up2;
 
-        mmc_add_host(mmc);
+        INIT_DELAYED_WORK(&host->timeout_work, mmcif_timeout_work);
 
         sh_mmcif_writel(host->addr, MMCIF_CE_INT_MASK, MASK_ALL);
 
@@ -1338,22 +1338,24 @@ static int __devinit sh_mmcif_probe(struct platform_device *pdev)
         }
         ret = request_threaded_irq(irq[1], sh_mmcif_intr, sh_mmcif_irqt, 0, "sh_mmc:int", host);
         if (ret) {
-                free_irq(irq[0], host);
                 dev_err(&pdev->dev, "request_irq error (sh_mmc:int)\n");
-                goto clean_up3;
+                goto clean_up4;
         }
 
-        INIT_DELAYED_WORK(&host->timeout_work, mmcif_timeout_work);
-
-        mmc_detect_change(host->mmc, 0);
+        ret = mmc_add_host(mmc);
+        if (ret < 0)
+                goto clean_up5;
 
         dev_info(&pdev->dev, "driver version %s\n", DRIVER_VERSION);
         dev_dbg(&pdev->dev, "chip ver H'%04x\n",
                 sh_mmcif_readl(host->addr, MMCIF_CE_VERSION) & 0x0000ffff);
         return ret;
 
+clean_up5:
+        free_irq(irq[1], host);
+clean_up4:
+        free_irq(irq[0], host);
 clean_up3:
-        mmc_remove_host(mmc);
         pm_runtime_suspend(&pdev->dev);
 clean_up2:
         pm_runtime_disable(&pdev->dev);
diff --git a/drivers/mmc/host/tmio_mmc.h b/drivers/mmc/host/tmio_mmc.h
index a95e6d901726..f96c536d130a 100644
--- a/drivers/mmc/host/tmio_mmc.h
+++ b/drivers/mmc/host/tmio_mmc.h
@@ -20,8 +20,8 @@
 #include <linux/mmc/tmio.h>
 #include <linux/mutex.h>
 #include <linux/pagemap.h>
-#include <linux/spinlock.h>
 #include <linux/scatterlist.h>
+#include <linux/spinlock.h>
 
 /* Definitions for values the CTRL_SDIO_STATUS register can take. */
 #define TMIO_SDIO_STAT_IOIRQ    0x0001
@@ -120,6 +120,7 @@ void tmio_mmc_start_dma(struct tmio_mmc_host *host, struct mmc_data *data);
 void tmio_mmc_enable_dma(struct tmio_mmc_host *host, bool enable);
 void tmio_mmc_request_dma(struct tmio_mmc_host *host, struct tmio_mmc_data *pdata);
 void tmio_mmc_release_dma(struct tmio_mmc_host *host);
+void tmio_mmc_abort_dma(struct tmio_mmc_host *host);
 #else
 static inline void tmio_mmc_start_dma(struct tmio_mmc_host *host,
                                struct mmc_data *data)
@@ -140,6 +141,10 @@ static inline void tmio_mmc_request_dma(struct tmio_mmc_host *host,
 static inline void tmio_mmc_release_dma(struct tmio_mmc_host *host)
 {
 }
+
+static inline void tmio_mmc_abort_dma(struct tmio_mmc_host *host)
+{
+}
 #endif
 
 #ifdef CONFIG_PM
diff --git a/drivers/mmc/host/tmio_mmc_dma.c b/drivers/mmc/host/tmio_mmc_dma.c
index 7a6e6cc8f8b8..8253ec12003e 100644
--- a/drivers/mmc/host/tmio_mmc_dma.c
+++ b/drivers/mmc/host/tmio_mmc_dma.c
@@ -34,6 +34,18 @@ void tmio_mmc_enable_dma(struct tmio_mmc_host *host, bool enable)
 #endif
 }
 
+void tmio_mmc_abort_dma(struct tmio_mmc_host *host)
+{
+        tmio_mmc_enable_dma(host, false);
+
+        if (host->chan_rx)
+                dmaengine_terminate_all(host->chan_rx);
+        if (host->chan_tx)
+                dmaengine_terminate_all(host->chan_tx);
+
+        tmio_mmc_enable_dma(host, true);
+}
+
 static void tmio_mmc_start_dma_rx(struct tmio_mmc_host *host)
 {
         struct scatterlist *sg = host->sg_ptr, *sg_tmp;
diff --git a/drivers/mmc/host/tmio_mmc_pio.c b/drivers/mmc/host/tmio_mmc_pio.c
index abad01b37cfb..5f9ad74fbf80 100644
--- a/drivers/mmc/host/tmio_mmc_pio.c
+++ b/drivers/mmc/host/tmio_mmc_pio.c
@@ -41,8 +41,8 @@
 #include <linux/platform_device.h>
 #include <linux/pm_runtime.h>
 #include <linux/scatterlist.h>
-#include <linux/workqueue.h>
 #include <linux/spinlock.h>
+#include <linux/workqueue.h>
 
 #include "tmio_mmc.h"
 
@@ -246,6 +246,7 @@ 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);
 }
 
@@ -272,6 +273,9 @@ 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);
 }