Merge branch 'master' of master.kernel.org:/pub/scm/linux/kernel/git/torvalds/linux-2.6 into rmobile-latest

Conflicts:
	arch/arm/mach-shmobile/Kconfig

Signed-off-by: Paul Mundt <lethal@linux-sh.org>

6 files changed, 320 insertions, 74 deletions

diff --git a/drivers/mmc/host/at91_mci.c b/drivers/mmc/host/at91_mci.c
index 591ab540b407..d3e6a962f423 100644
--- a/drivers/mmc/host/at91_mci.c
+++ b/drivers/mmc/host/at91_mci.c
@@ -69,6 +69,7 @@
 #include <linux/highmem.h>
 
 #include <linux/mmc/host.h>
+#include <linux/mmc/sdio.h>
 
 #include <asm/io.h>
 #include <asm/irq.h>
@@ -493,10 +494,14 @@ static void at91_mci_send_command(struct at91mci_host *host, struct mmc_command
                 else if (data->flags & MMC_DATA_WRITE)
                         cmdr |= AT91_MCI_TRCMD_START;
 
-                if (data->flags & MMC_DATA_STREAM)
-                        cmdr |= AT91_MCI_TRTYP_STREAM;
-                if (data->blocks > 1)
-                        cmdr |= AT91_MCI_TRTYP_MULTIPLE;
+                if (cmd->opcode == SD_IO_RW_EXTENDED) {
+                        cmdr |= AT91_MCI_TRTYP_SDIO_BLOCK;
+                } else {
+                        if (data->flags & MMC_DATA_STREAM)
+                                cmdr |= AT91_MCI_TRTYP_STREAM;
+                        if (data->blocks > 1)
+                                cmdr |= AT91_MCI_TRTYP_MULTIPLE;
+                }
         }
         else {
                 block_length = 0;
diff --git a/drivers/mmc/host/atmel-mci.c b/drivers/mmc/host/atmel-mci.c
index 301351a5d838..ad2a7a032cdf 100644
--- a/drivers/mmc/host/atmel-mci.c
+++ b/drivers/mmc/host/atmel-mci.c
@@ -26,6 +26,7 @@
 #include <linux/stat.h>
 
 #include <linux/mmc/host.h>
+#include <linux/mmc/sdio.h>
 
 #include <mach/atmel-mci.h>
 #include <linux/atmel-mci.h>
@@ -532,12 +533,17 @@ static u32 atmci_prepare_command(struct mmc_host *mmc,
         data = cmd->data;
         if (data) {
                 cmdr |= MCI_CMDR_START_XFER;
-                if (data->flags & MMC_DATA_STREAM)
-                        cmdr |= MCI_CMDR_STREAM;
-                else if (data->blocks > 1)
-                        cmdr |= MCI_CMDR_MULTI_BLOCK;
-                else
-                        cmdr |= MCI_CMDR_BLOCK;
+
+                if (cmd->opcode == SD_IO_RW_EXTENDED) {
+                        cmdr |= MCI_CMDR_SDIO_BLOCK;
+                } else {
+                        if (data->flags & MMC_DATA_STREAM)
+                                cmdr |= MCI_CMDR_STREAM;
+                        else if (data->blocks > 1)
+                                cmdr |= MCI_CMDR_MULTI_BLOCK;
+                        else
+                                cmdr |= MCI_CMDR_BLOCK;
+                }
 
                 if (data->flags & MMC_DATA_READ)
                         cmdr |= MCI_CMDR_TRDIR_READ;
diff --git a/drivers/mmc/host/mmci.c b/drivers/mmc/host/mmci.c
index 87b4fc6c98c2..563022825667 100644
--- a/drivers/mmc/host/mmci.c
+++ b/drivers/mmc/host/mmci.c
@@ -19,6 +19,7 @@
 #include <linux/highmem.h>
 #include <linux/log2.h>
 #include <linux/mmc/host.h>
+#include <linux/mmc/card.h>
 #include <linux/amba/bus.h>
 #include <linux/clk.h>
 #include <linux/scatterlist.h>
@@ -45,6 +46,12 @@ static unsigned int fmax = 515633;
  *            is asserted (likewise for RX)
  * @fifohalfsize: number of bytes that can be written when MCI_TXFIFOHALFEMPTY
  *                is asserted (likewise for RX)
+ * @broken_blockend: the MCI_DATABLOCKEND is broken on the hardware
+ *              and will not work at all.
+ * @broken_blockend_dma: the MCI_DATABLOCKEND is broken on the hardware when
+ *              using DMA.
+ * @sdio: variant supports SDIO
+ * @st_clkdiv: true if using a ST-specific clock divider algorithm
  */
 struct variant_data {
         unsigned int            clkreg;
@@ -52,6 +59,10 @@ struct variant_data {
         unsigned int            datalength_bits;
         unsigned int            fifosize;
         unsigned int            fifohalfsize;
+        bool                    broken_blockend;
+        bool                    broken_blockend_dma;
+        bool                    sdio;
+        bool                    st_clkdiv;
 };
 
 static struct variant_data variant_arm = {
@@ -65,6 +76,8 @@ static struct variant_data variant_u300 = {
         .fifohalfsize           = 8 * 4,
         .clkreg_enable          = 1 << 13, /* HWFCEN */
         .datalength_bits        = 16,
+        .broken_blockend_dma    = true,
+        .sdio                   = true,
 };
 
 static struct variant_data variant_ux500 = {
@@ -73,7 +86,11 @@ static struct variant_data variant_ux500 = {
         .clkreg                 = MCI_CLK_ENABLE,
         .clkreg_enable          = 1 << 14, /* HWFCEN */
         .datalength_bits        = 24,
+        .broken_blockend        = true,
+        .sdio                   = true,
+        .st_clkdiv              = true,
 };
+
 /*
  * This must be called with host->lock held
  */
@@ -86,7 +103,22 @@ static void mmci_set_clkreg(struct mmci_host *host, unsigned int desired)
                 if (desired >= host->mclk) {
                         clk = MCI_CLK_BYPASS;
                         host->cclk = host->mclk;
+                } else if (variant->st_clkdiv) {
+                        /*
+                         * DB8500 TRM says f = mclk / (clkdiv + 2)
+                         * => clkdiv = (mclk / f) - 2
+                         * Round the divider up so we don't exceed the max
+                         * frequency
+                         */
+                        clk = DIV_ROUND_UP(host->mclk, desired) - 2;
+                        if (clk >= 256)
+                                clk = 255;
+                        host->cclk = host->mclk / (clk + 2);
                 } else {
+                        /*
+                         * PL180 TRM says f = mclk / (2 * (clkdiv + 1))
+                         * => clkdiv = mclk / (2 * f) - 1
+                         */
                         clk = host->mclk / (2 * desired) - 1;
                         if (clk >= 256)
                                 clk = 255;
@@ -129,10 +161,26 @@ mmci_request_end(struct mmci_host *host, struct mmc_request *mrq)
         spin_lock(&host->lock);
 }
 
+static void mmci_set_mask1(struct mmci_host *host, unsigned int mask)
+{
+        void __iomem *base = host->base;
+
+        if (host->singleirq) {
+                unsigned int mask0 = readl(base + MMCIMASK0);
+
+                mask0 &= ~MCI_IRQ1MASK;
+                mask0 |= mask;
+
+                writel(mask0, base + MMCIMASK0);
+        }
+
+        writel(mask, base + MMCIMASK1);
+}
+
 static void mmci_stop_data(struct mmci_host *host)
 {
         writel(0, host->base + MMCIDATACTRL);
-        writel(0, host->base + MMCIMASK1);
+        mmci_set_mask1(host, 0);
         host->data = NULL;
 }
 
@@ -162,6 +210,8 @@ static void mmci_start_data(struct mmci_host *host, struct mmc_data *data)
         host->data = data;
         host->size = data->blksz * data->blocks;
         host->data_xfered = 0;
+        host->blockend = false;
+        host->dataend = false;
 
         mmci_init_sg(host, data);
 
@@ -196,9 +246,14 @@ static void mmci_start_data(struct mmci_host *host, struct mmc_data *data)
                 irqmask = MCI_TXFIFOHALFEMPTYMASK;
         }
 
+        /* The ST Micro variants has a special bit to enable SDIO */
+        if (variant->sdio && host->mmc->card)
+                if (mmc_card_sdio(host->mmc->card))
+                        datactrl |= MCI_ST_DPSM_SDIOEN;
+
         writel(datactrl, base + MMCIDATACTRL);
         writel(readl(base + MMCIMASK0) & ~MCI_DATAENDMASK, base + MMCIMASK0);
-        writel(irqmask, base + MMCIMASK1);
+        mmci_set_mask1(host, irqmask);
 }
 
 static void
@@ -233,20 +288,9 @@ static void
 mmci_data_irq(struct mmci_host *host, struct mmc_data *data,
               unsigned int status)
 {
-        if (status & MCI_DATABLOCKEND) {
-                host->data_xfered += data->blksz;
-#ifdef CONFIG_ARCH_U300
-                /*
-                 * On the U300 some signal or other is
-                 * badly routed so that a data write does
-                 * not properly terminate with a MCI_DATAEND
-                 * status flag. This quirk will make writes
-                 * work again.
-                 */
-                if (data->flags & MMC_DATA_WRITE)
-                        status |= MCI_DATAEND;
-#endif
-        }
+        struct variant_data *variant = host->variant;
+
+        /* First check for errors */
         if (status & (MCI_DATACRCFAIL|MCI_DATATIMEOUT|MCI_TXUNDERRUN|MCI_RXOVERRUN)) {
                 dev_dbg(mmc_dev(host->mmc), "MCI ERROR IRQ (status %08x)\n", status);
                 if (status & MCI_DATACRCFAIL)
@@ -255,7 +299,10 @@ mmci_data_irq(struct mmci_host *host, struct mmc_data *data,
                         data->error = -ETIMEDOUT;
                 else if (status & (MCI_TXUNDERRUN|MCI_RXOVERRUN))
                         data->error = -EIO;
-                status |= MCI_DATAEND;
+
+                /* Force-complete the transaction */
+                host->blockend = true;
+                host->dataend = true;
 
                 /*
                  * We hit an error condition.  Ensure that any data
@@ -273,9 +320,64 @@ mmci_data_irq(struct mmci_host *host, struct mmc_data *data,
                         local_irq_restore(flags);
                 }
         }
-        if (status & MCI_DATAEND) {
+
+        /*
+         * On ARM variants in PIO mode, MCI_DATABLOCKEND
+         * is always sent first, and we increase the
+         * transfered number of bytes for that IRQ. Then
+         * MCI_DATAEND follows and we conclude the transaction.
+         *
+         * On the Ux500 single-IRQ variant MCI_DATABLOCKEND
+         * doesn't seem to immediately clear from the status,
+         * so we can't use it keep count when only one irq is
+         * used because the irq will hit for other reasons, and
+         * then the flag is still up. So we use the MCI_DATAEND
+         * IRQ at the end of the entire transfer because
+         * MCI_DATABLOCKEND is broken.
+         *
+         * In the U300, the IRQs can arrive out-of-order,
+         * e.g. MCI_DATABLOCKEND sometimes arrives after MCI_DATAEND,
+         * so for this case we use the flags "blockend" and
+         * "dataend" to make sure both IRQs have arrived before
+         * concluding the transaction. (This does not apply
+         * to the Ux500 which doesn't fire MCI_DATABLOCKEND
+         * at all.) In DMA mode it suffers from the same problem
+         * as the Ux500.
+         */
+        if (status & MCI_DATABLOCKEND) {
+                /*
+                 * Just being a little over-cautious, we do not
+                 * use this progressive update if the hardware blockend
+                 * flag is unreliable: since it can stay high between
+                 * IRQs it will corrupt the transfer counter.
+                 */
+                if (!variant->broken_blockend)
+                        host->data_xfered += data->blksz;
+                host->blockend = true;
+        }
+
+        if (status & MCI_DATAEND)
+                host->dataend = true;
+
+        /*
+         * On variants with broken blockend we shall only wait for dataend,
+         * on others we must sync with the blockend signal since they can
+         * appear out-of-order.
+         */
+        if (host->dataend && (host->blockend || variant->broken_blockend)) {
                 mmci_stop_data(host);
 
+                /* Reset these flags */
+                host->blockend = false;
+                host->dataend = false;
+
+                /*
+                 * Variants with broken blockend flags need to handle the
+                 * end of the entire transfer here.
+                 */
+                if (variant->broken_blockend && !data->error)
+                        host->data_xfered += data->blksz * data->blocks;
+
                 if (!data->stop) {
                         mmci_request_end(host, data->mrq);
                 } else {
@@ -356,7 +458,32 @@ static int mmci_pio_write(struct mmci_host *host, char *buffer, unsigned int rem
                          variant->fifosize : variant->fifohalfsize;
                 count = min(remain, maxcnt);
 
-                writesl(base + MMCIFIFO, ptr, count >> 2);
+                /*
+                 * The ST Micro variant for SDIO transfer sizes
+                 * less then 8 bytes should have clock H/W flow
+                 * control disabled.
+                 */
+                if (variant->sdio &&
+                    mmc_card_sdio(host->mmc->card)) {
+                        if (count < 8)
+                                writel(readl(host->base + MMCICLOCK) &
+                                        ~variant->clkreg_enable,
+                                        host->base + MMCICLOCK);
+                        else
+                                writel(readl(host->base + MMCICLOCK) |
+                                        variant->clkreg_enable,
+                                        host->base + MMCICLOCK);
+                }
+
+                /*
+                 * SDIO especially may want to send something that is
+                 * not divisible by 4 (as opposed to card sectors
+                 * etc), and the FIFO only accept full 32-bit writes.
+                 * So compensate by adding +3 on the count, a single
+                 * byte become a 32bit write, 7 bytes will be two
+                 * 32bit writes etc.
+                 */
+                writesl(base + MMCIFIFO, ptr, (count + 3) >> 2);
 
                 ptr += count;
                 remain -= count;
@@ -437,7 +564,7 @@ static irqreturn_t mmci_pio_irq(int irq, void *dev_id)
          * "any data available" mode.
          */
         if (status & MCI_RXACTIVE && host->size < variant->fifosize)
-                writel(MCI_RXDATAAVLBLMASK, base + MMCIMASK1);
+                mmci_set_mask1(host, MCI_RXDATAAVLBLMASK);
 
         /*
          * If we run out of data, disable the data IRQs; this
@@ -446,7 +573,7 @@ static irqreturn_t mmci_pio_irq(int irq, void *dev_id)
          * stops us racing with our data end IRQ.
          */
         if (host->size == 0) {
-                writel(0, base + MMCIMASK1);
+                mmci_set_mask1(host, 0);
                 writel(readl(base + MMCIMASK0) | MCI_DATAENDMASK, base + MMCIMASK0);
         }
 
@@ -469,6 +596,14 @@ static irqreturn_t mmci_irq(int irq, void *dev_id)
                 struct mmc_data *data;
 
                 status = readl(host->base + MMCISTATUS);
+
+                if (host->singleirq) {
+                        if (status & readl(host->base + MMCIMASK1))
+                                mmci_pio_irq(irq, dev_id);
+
+                        status &= ~MCI_IRQ1MASK;
+                }
+
                 status &= readl(host->base + MMCIMASK0);
                 writel(status, host->base + MMCICLEAR);
 
@@ -635,6 +770,7 @@ static int __devinit mmci_probe(struct amba_device *dev, struct amba_id *id)
         struct variant_data *variant = id->data;
         struct mmci_host *host;
         struct mmc_host *mmc;
+        unsigned int mask;
         int ret;
 
         /* must have platform data */
@@ -806,20 +942,30 @@ static int __devinit mmci_probe(struct amba_device *dev, struct amba_id *id)
         if (ret)
                 goto unmap;
 
-        ret = request_irq(dev->irq[1], mmci_pio_irq, IRQF_SHARED, DRIVER_NAME " (pio)", host);
-        if (ret)
-                goto irq0_free;
+        if (dev->irq[1] == NO_IRQ)
+                host->singleirq = true;
+        else {
+                ret = request_irq(dev->irq[1], mmci_pio_irq, IRQF_SHARED,
+                                  DRIVER_NAME " (pio)", host);
+                if (ret)
+                        goto irq0_free;
+        }
 
-        writel(MCI_IRQENABLE, host->base + MMCIMASK0);
+        mask = MCI_IRQENABLE;
+        /* Don't use the datablockend flag if it's broken */
+        if (variant->broken_blockend)
+                mask &= ~MCI_DATABLOCKEND;
 
-        amba_set_drvdata(dev, mmc);
+        writel(mask, host->base + MMCIMASK0);
 
-        mmc_add_host(mmc);
+        amba_set_drvdata(dev, mmc);
 
-        dev_info(&dev->dev, "%s: MMCI rev %x cfg %02x at 0x%016llx irq %d,%d\n",
-                mmc_hostname(mmc), amba_rev(dev), amba_config(dev),
+        dev_info(&dev->dev, "%s: PL%03x rev%u at 0x%08llx irq %d,%d\n",
+                mmc_hostname(mmc), amba_part(dev), amba_rev(dev),
                 (unsigned long long)dev->res.start, dev->irq[0], dev->irq[1]);
 
+        mmc_add_host(mmc);
+
         return 0;
 
  irq0_free:
@@ -864,7 +1010,8 @@ static int __devexit mmci_remove(struct amba_device *dev)
                 writel(0, host->base + MMCIDATACTRL);
 
                 free_irq(dev->irq[0], host);
-                free_irq(dev->irq[1], host);
+                if (!host->singleirq)
+                        free_irq(dev->irq[1], host);
 
                 if (host->gpio_wp != -ENOSYS)
                         gpio_free(host->gpio_wp);
diff --git a/drivers/mmc/host/mmci.h b/drivers/mmc/host/mmci.h
index 4ae887fc0189..df06f01aac89 100644
--- a/drivers/mmc/host/mmci.h
+++ b/drivers/mmc/host/mmci.h
@@ -139,6 +139,11 @@
         MCI_DATATIMEOUTMASK|MCI_TXUNDERRUNMASK|MCI_RXOVERRUNMASK|       \
         MCI_CMDRESPENDMASK|MCI_CMDSENTMASK|MCI_DATABLOCKENDMASK)
 
+/* These interrupts are directed to IRQ1 when two IRQ lines are available */
+#define MCI_IRQ1MASK \
+        (MCI_RXFIFOHALFFULLMASK | MCI_RXDATAAVLBLMASK | \
+         MCI_TXFIFOHALFEMPTYMASK)
+
 #define NR_SG           16
 
 struct clk;
@@ -154,6 +159,7 @@ struct mmci_host {
         int                     gpio_cd;
         int                     gpio_wp;
         int                     gpio_cd_irq;
+        bool                    singleirq;
 
         unsigned int            data_xfered;
 
@@ -171,6 +177,9 @@ struct mmci_host {
         struct timer_list       timer;
         unsigned int            oldstat;
 
+        bool                    blockend;
+        bool                    dataend;
+
         /* pio stuff */
         struct sg_mapping_iter  sg_miter;
         unsigned int            size;
diff --git a/drivers/mmc/host/msm_sdcc.c b/drivers/mmc/host/msm_sdcc.c
index 1290d14c5839..5decfd0bd61d 100644
--- a/drivers/mmc/host/msm_sdcc.c
+++ b/drivers/mmc/host/msm_sdcc.c
@@ -44,6 +44,7 @@
 #include <mach/mmc.h>
 #include <mach/msm_iomap.h>
 #include <mach/dma.h>
+#include <mach/clk.h>
 
 #include "msm_sdcc.h"
 
@@ -126,6 +127,40 @@ static void
 msmsdcc_start_command(struct msmsdcc_host *host, struct mmc_command *cmd,
                       u32 c);
 
+static void msmsdcc_reset_and_restore(struct msmsdcc_host *host)
+{
+        u32     mci_clk = 0;
+        u32     mci_mask0 = 0;
+        int     ret = 0;
+
+        /* Save the controller state */
+        mci_clk = readl(host->base + MMCICLOCK);
+        mci_mask0 = readl(host->base + MMCIMASK0);
+
+        /* Reset the controller */
+        ret = clk_reset(host->clk, CLK_RESET_ASSERT);
+        if (ret)
+                pr_err("%s: Clock assert failed at %u Hz with err %d\n",
+                                mmc_hostname(host->mmc), host->clk_rate, ret);
+
+        ret = clk_reset(host->clk, CLK_RESET_DEASSERT);
+        if (ret)
+                pr_err("%s: Clock deassert failed at %u Hz with err %d\n",
+                                mmc_hostname(host->mmc), host->clk_rate, ret);
+
+        pr_info("%s: Controller has been re-initialiazed\n",
+                        mmc_hostname(host->mmc));
+
+        /* Restore the contoller state */
+        writel(host->pwr, host->base + MMCIPOWER);
+        writel(mci_clk, host->base + MMCICLOCK);
+        writel(mci_mask0, host->base + MMCIMASK0);
+        ret = clk_set_rate(host->clk, host->clk_rate);
+        if (ret)
+                pr_err("%s: Failed to set clk rate %u Hz (%d)\n",
+                                mmc_hostname(host->mmc), host->clk_rate, ret);
+}
+
 static void
 msmsdcc_request_end(struct msmsdcc_host *host, struct mmc_request *mrq)
 {
@@ -155,7 +190,7 @@ static void
 msmsdcc_stop_data(struct msmsdcc_host *host)
 {
         host->curr.data = NULL;
-        host->curr.got_dataend = host->curr.got_datablkend = 0;
+        host->curr.got_dataend = 0;
 }
 
 uint32_t msmsdcc_fifo_addr(struct msmsdcc_host *host)
@@ -189,42 +224,42 @@ msmsdcc_dma_exec_func(struct msm_dmov_cmd *cmd)
 }
 
 static void
-msmsdcc_dma_complete_func(struct msm_dmov_cmd *cmd,
-                          unsigned int result,
-                          struct msm_dmov_errdata *err)
+msmsdcc_dma_complete_tlet(unsigned long data)
 {
-        struct msmsdcc_dma_data *dma_data =
-                container_of(cmd, struct msmsdcc_dma_data, hdr);
-        struct msmsdcc_host     *host = dma_data->host;
+        struct msmsdcc_host *host = (struct msmsdcc_host *)data;
         unsigned long           flags;
         struct mmc_request      *mrq;
+        struct msm_dmov_errdata err;
 
         spin_lock_irqsave(&host->lock, flags);
         host->dma.active = 0;
 
+        err = host->dma.err;
         mrq = host->curr.mrq;
         BUG_ON(!mrq);
         WARN_ON(!mrq->data);
 
-        if (!(result & DMOV_RSLT_VALID)) {
+        if (!(host->dma.result & DMOV_RSLT_VALID)) {
                 pr_err("msmsdcc: Invalid DataMover result\n");
                 goto out;
         }
 
-        if (result & DMOV_RSLT_DONE) {
+        if (host->dma.result & DMOV_RSLT_DONE) {
                 host->curr.data_xfered = host->curr.xfer_size;
         } else {
                 /* Error or flush  */
-                if (result & DMOV_RSLT_ERROR)
+                if (host->dma.result & DMOV_RSLT_ERROR)
                         pr_err("%s: DMA error (0x%.8x)\n",
-                               mmc_hostname(host->mmc), result);
-                if (result & DMOV_RSLT_FLUSH)
+                               mmc_hostname(host->mmc), host->dma.result);
+                if (host->dma.result & DMOV_RSLT_FLUSH)
                         pr_err("%s: DMA channel flushed (0x%.8x)\n",
-                               mmc_hostname(host->mmc), result);
-                if (err)
-                        pr_err("Flush data: %.8x %.8x %.8x %.8x %.8x %.8x\n",
-                               err->flush[0], err->flush[1], err->flush[2],
-                               err->flush[3], err->flush[4], err->flush[5]);
+                               mmc_hostname(host->mmc), host->dma.result);
+
+                pr_err("Flush data: %.8x %.8x %.8x %.8x %.8x %.8x\n",
+                       err.flush[0], err.flush[1], err.flush[2],
+                       err.flush[3], err.flush[4], err.flush[5]);
+
+                msmsdcc_reset_and_restore(host);
                 if (!mrq->data->error)
                         mrq->data->error = -EIO;
         }
@@ -242,8 +277,7 @@ msmsdcc_dma_complete_func(struct msm_dmov_cmd *cmd,
         host->dma.sg = NULL;
         host->dma.busy = 0;
 
-        if ((host->curr.got_dataend && host->curr.got_datablkend)
-             || mrq->data->error) {
+        if (host->curr.got_dataend || mrq->data->error) {
 
                 /*
                  * If we've already gotten our DATAEND / DATABLKEND
@@ -273,6 +307,22 @@ out:
         return;
 }
 
+static void
+msmsdcc_dma_complete_func(struct msm_dmov_cmd *cmd,
+                          unsigned int result,
+                          struct msm_dmov_errdata *err)
+{
+        struct msmsdcc_dma_data *dma_data =
+                container_of(cmd, struct msmsdcc_dma_data, hdr);
+        struct msmsdcc_host *host = dma_data->host;
+
+        dma_data->result = result;
+        if (err)
+                memcpy(&dma_data->err, err, sizeof(struct msm_dmov_errdata));
+
+        tasklet_schedule(&host->dma_tlet);
+}
+
 static int validate_dma(struct msmsdcc_host *host, struct mmc_data *data)
 {
         if (host->dma.channel == -1)
@@ -424,6 +474,11 @@ msmsdcc_start_command_deferred(struct msmsdcc_host *host,
               (cmd->opcode == 53))
                 *c |= MCI_CSPM_DATCMD;
 
+        if (host->prog_scan && (cmd->opcode == 12)) {
+                *c |= MCI_CPSM_PROGENA;
+                host->prog_enable = true;
+        }
+
         if (cmd == cmd->mrq->stop)
                 *c |= MCI_CSPM_MCIABORT;
 
@@ -450,7 +505,6 @@ msmsdcc_start_data(struct msmsdcc_host *host, struct mmc_data *data,
         host->curr.xfer_remain = host->curr.xfer_size;
         host->curr.data_xfered = 0;
         host->curr.got_dataend = 0;
-        host->curr.got_datablkend = 0;
 
         memset(&host->pio, 0, sizeof(host->pio));
 
@@ -494,6 +548,8 @@ msmsdcc_start_data(struct msmsdcc_host *host, struct mmc_data *data,
                         host->cmd_c = c;
                 }
                 msm_dmov_enqueue_cmd(host->dma.channel, &host->dma.hdr);
+                if (data->flags & MMC_DATA_WRITE)
+                        host->prog_scan = true;
         } else {
                 msmsdcc_writel(host, timeout, MMCIDATATIMER);
 
@@ -555,6 +611,9 @@ msmsdcc_pio_read(struct msmsdcc_host *host, char *buffer, unsigned int remain)
         uint32_t        *ptr = (uint32_t *) buffer;
         int             count = 0;
 
+        if (remain % 4)
+                remain = ((remain >> 2) + 1) << 2;
+
         while (msmsdcc_readl(host, MMCISTATUS) & MCI_RXDATAAVLBL) {
                 *ptr = msmsdcc_readl(host, MMCIFIFO + (count % MCI_FIFOSIZE));
                 ptr++;
@@ -575,13 +634,14 @@ msmsdcc_pio_write(struct msmsdcc_host *host, char *buffer,
         char *ptr = buffer;
 
         do {
-                unsigned int count, maxcnt;
+                unsigned int count, maxcnt, sz;
 
                 maxcnt = status & MCI_TXFIFOEMPTY ? MCI_FIFOSIZE :
                                                     MCI_FIFOHALFSIZE;
                 count = min(remain, maxcnt);
 
-                writesl(base + MMCIFIFO, ptr, count >> 2);
+                sz = count % 4 ? (count >> 2) + 1 : (count >> 2);
+                writesl(base + MMCIFIFO, ptr, sz);
                 ptr += count;
                 remain -= count;
 
@@ -702,10 +762,26 @@ static void msmsdcc_do_cmdirq(struct msmsdcc_host *host, uint32_t status)
                         msm_dmov_stop_cmd(host->dma.channel,
                                           &host->dma.hdr, 0);
                 else if (host->curr.data) { /* Non DMA */
+                        msmsdcc_reset_and_restore(host);
                         msmsdcc_stop_data(host);
                         msmsdcc_request_end(host, cmd->mrq);
-                } else /* host->data == NULL */
-                        msmsdcc_request_end(host, cmd->mrq);
+                } else { /* host->data == NULL */
+                        if (!cmd->error && host->prog_enable) {
+                                if (status & MCI_PROGDONE) {
+                                        host->prog_scan = false;
+                                        host->prog_enable = false;
+                                        msmsdcc_request_end(host, cmd->mrq);
+                                } else {
+                                        host->curr.cmd = cmd;
+                                }
+                        } else {
+                                if (host->prog_enable) {
+                                        host->prog_scan = false;
+                                        host->prog_enable = false;
+                                }
+                                msmsdcc_request_end(host, cmd->mrq);
+                        }
+                }
         } else if (cmd->data)
                 if (!(cmd->data->flags & MMC_DATA_READ))
                         msmsdcc_start_data(host, cmd->data,
@@ -719,7 +795,7 @@ msmsdcc_handle_irq_data(struct msmsdcc_host *host, u32 status,
         struct mmc_data *data = host->curr.data;
 
         if (status & (MCI_CMDSENT | MCI_CMDRESPEND | MCI_CMDCRCFAIL |
-                      MCI_CMDTIMEOUT) && host->curr.cmd) {
+                        MCI_CMDTIMEOUT | MCI_PROGDONE) && host->curr.cmd) {
                 msmsdcc_do_cmdirq(host, status);
         }
 
@@ -735,6 +811,7 @@ msmsdcc_handle_irq_data(struct msmsdcc_host *host, u32 status,
                         msm_dmov_stop_cmd(host->dma.channel,
                                           &host->dma.hdr, 0);
                 else {
+                        msmsdcc_reset_and_restore(host);
                         if (host->curr.data)
                                 msmsdcc_stop_data(host);
                         if (!data->stop)
@@ -748,14 +825,10 @@ msmsdcc_handle_irq_data(struct msmsdcc_host *host, u32 status,
         if (!host->curr.got_dataend && (status & MCI_DATAEND))
                 host->curr.got_dataend = 1;
 
-        if (!host->curr.got_datablkend && (status & MCI_DATABLOCKEND))
-                host->curr.got_datablkend = 1;
-
         /*
          * If DMA is still in progress, we complete via the completion handler
          */
-        if (host->curr.got_dataend && host->curr.got_datablkend &&
-            !host->dma.busy) {
+        if (host->curr.got_dataend && !host->dma.busy) {
                 /*
                  * There appears to be an issue in the controller where
                  * if you request a small block transfer (< fifo size),
@@ -792,8 +865,7 @@ msmsdcc_irq(int irq, void *dev_id)
 
         do {
                 status = msmsdcc_readl(host, MMCISTATUS);
-                status &= (msmsdcc_readl(host, MMCIMASK0) |
-                                              MCI_DATABLOCKENDMASK);
+                status &= msmsdcc_readl(host, MMCIMASK0);
                 msmsdcc_writel(host, status, MMCICLEAR);
 
                 if (status & MCI_SDIOINTR)
@@ -1118,6 +1190,9 @@ msmsdcc_probe(struct platform_device *pdev)
         host->dmares = dmares;
         spin_lock_init(&host->lock);
 
+        tasklet_init(&host->dma_tlet, msmsdcc_dma_complete_tlet,
+                        (unsigned long)host);
+
         /*
          * Setup DMA
          */
diff --git a/drivers/mmc/host/msm_sdcc.h b/drivers/mmc/host/msm_sdcc.h
index ff2b0f74f6f4..939557af266d 100644
--- a/drivers/mmc/host/msm_sdcc.h
+++ b/drivers/mmc/host/msm_sdcc.h
@@ -138,7 +138,7 @@
 #define MCI_IRQENABLE   \
         (MCI_CMDCRCFAILMASK|MCI_DATACRCFAILMASK|MCI_CMDTIMEOUTMASK|     \
         MCI_DATATIMEOUTMASK|MCI_TXUNDERRUNMASK|MCI_RXOVERRUNMASK|       \
-        MCI_CMDRESPENDMASK|MCI_CMDSENTMASK|MCI_DATAENDMASK)
+        MCI_CMDRESPENDMASK|MCI_CMDSENTMASK|MCI_DATAENDMASK|MCI_PROGDONEMASK)
 
 /*
  * The size of the FIFO in bytes.
@@ -172,6 +172,8 @@ struct msmsdcc_dma_data {
         struct msmsdcc_host             *host;
         int                             busy; /* Set if DM is busy */
         int                             active;
+        unsigned int                    result;
+        struct msm_dmov_errdata         err;
 };
 
 struct msmsdcc_pio_data {
@@ -188,7 +190,6 @@ struct msmsdcc_curr_req {
         unsigned int            xfer_remain;    /* Bytes remaining to send */
         unsigned int            data_xfered;    /* Bytes acked by BLKEND irq */
         int                     got_dataend;
-        int                     got_datablkend;
         int                     user_pages;
 };
 
@@ -235,6 +236,7 @@ struct msmsdcc_host {
         int                     cmdpoll;
         struct msmsdcc_stats    stats;
 
+        struct tasklet_struct   dma_tlet;
         /* Command parameters */
         unsigned int            cmd_timeout;
         unsigned int            cmd_pio_irqmask;
@@ -242,6 +244,8 @@ struct msmsdcc_host {
         struct mmc_command      *cmd_cmd;
         u32                     cmd_c;
 
+        bool prog_scan;
+        bool prog_enable;
 };
 
 #endif