Merge remote-tracking branch 'u-boot-ti/master'

[platform/kernel/u-boot.git] / drivers / mmc / mxsmmc.c

diff --git a/drivers/mmc/mxsmmc.c b/drivers/mmc/mxsmmc.c
index c2aa4aa..109acbf 100644 (file)
--- a/drivers/mmc/mxsmmc.c
+++ b/drivers/mmc/mxsmmc.c
@@ -42,6 +42,7 @@
 #include <asm/arch/imx-regs.h>
 #include <asm/arch/sys_proto.h>
 #include <asm/arch/dma.h>
+#include <bouncebuf.h>
 
 struct mxsmmc_priv {
        int                     id;
@@ -95,41 +96,57 @@ static int mxsmmc_send_cmd_pio(struct mxsmmc_priv *priv, struct mmc_data *data)
 static int mxsmmc_send_cmd_dma(struct mxsmmc_priv *priv, struct mmc_data *data)
 {
        uint32_t data_count = data->blocksize * data->blocks;
-       uint32_t cache_data_count;
+       uint32_t cache_data_count = roundup(data_count, ARCH_DMA_MINALIGN);
        int dmach;
+       struct mxs_dma_desc *desc = priv->desc;
+       void *addr, *backup;
+       uint8_t flags;
 
-       if (data_count % ARCH_DMA_MINALIGN)
-               cache_data_count = roundup(data_count, ARCH_DMA_MINALIGN);
-       else
-               cache_data_count = data_count;
+       memset(desc, 0, sizeof(struct mxs_dma_desc));
+       desc->address = (dma_addr_t)desc;
 
        if (data->flags & MMC_DATA_READ) {
                priv->desc->cmd.data = MXS_DMA_DESC_COMMAND_DMA_WRITE;
-               priv->desc->cmd.address = (dma_addr_t)data->dest;
+               addr = data->dest;
+               flags = GEN_BB_WRITE;
        } else {
                priv->desc->cmd.data = MXS_DMA_DESC_COMMAND_DMA_READ;
-               priv->desc->cmd.address = (dma_addr_t)data->src;
+               addr = (void *)data->src;
+               flags = GEN_BB_READ;
+       }
+
+       bounce_buffer_start(&addr, data_count, &backup, flags);
 
+       priv->desc->cmd.address = (dma_addr_t)addr;
+
+       if (data->flags & MMC_DATA_WRITE) {
                /* Flush data to DRAM so DMA can pick them up */
-               flush_dcache_range((uint32_t)priv->desc->cmd.address,
-                       (uint32_t)(priv->desc->cmd.address + cache_data_count));
+               flush_dcache_range((uint32_t)addr,
+                       (uint32_t)(addr) + cache_data_count);
        }
 
+       /* Invalidate the area, so no writeback into the RAM races with DMA */
+       invalidate_dcache_range((uint32_t)priv->desc->cmd.address,
+                       (uint32_t)(priv->desc->cmd.address + cache_data_count));
+
        priv->desc->cmd.data |= MXS_DMA_DESC_IRQ | MXS_DMA_DESC_DEC_SEM |
                                (data_count << MXS_DMA_DESC_BYTES_OFFSET);
 
-
        dmach = MXS_DMA_CHANNEL_AHB_APBH_SSP0 + priv->id;
        mxs_dma_desc_append(dmach, priv->desc);
-       if (mxs_dma_go(dmach))
+       if (mxs_dma_go(dmach)) {
+               bounce_buffer_stop(&addr, data_count, &backup, flags);
                return COMM_ERR;
+       }
 
        /* The data arrived into DRAM, invalidate cache over them */
        if (data->flags & MMC_DATA_READ) {
-               invalidate_dcache_range((uint32_t)priv->desc->cmd.address,
-                       (uint32_t)(priv->desc->cmd.address + cache_data_count));
+               invalidate_dcache_range((uint32_t)addr,
+                       (uint32_t)(addr) + cache_data_count);
        }
 
+       bounce_buffer_stop(&addr, data_count, &backup, flags);
+
        return 0;
 }
 
@@ -183,6 +200,11 @@ mxsmmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data)
        if (cmd->resp_type & MMC_RSP_136)       /* It's a 136 bits response */
                ctrl0 |= SSP_CTRL0_LONG_RESP;
 
+       if (data && (data->blocksize * data->blocks < MXSMMC_SMALL_TRANSFER))
+               writel(SSP_CTRL1_DMA_ENABLE, &ssp_regs->hw_ssp_ctrl1_clr);
+       else
+               writel(SSP_CTRL1_DMA_ENABLE, &ssp_regs->hw_ssp_ctrl1_set);
+
        /* Command index */
        reg = readl(&ssp_regs->hw_ssp_cmd0);
        reg &= ~(SSP_CMD0_CMD_MASK | SSP_CMD0_APPEND_8CYC);
@@ -264,17 +286,6 @@ mxsmmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data)
                return 0;
 
        if (data->blocksize * data->blocks < MXSMMC_SMALL_TRANSFER) {
-               writel(SSP_CTRL1_DMA_ENABLE, &ssp_regs->hw_ssp_ctrl1_set);
-
-               ret = mxsmmc_send_cmd_dma(priv, data);
-               if (ret) {
-                       printf("MMC%d: DMA transfer failed\n",
-                               mmc->block_dev.dev);
-                       return ret;
-               }
-       } else {
-               writel(SSP_CTRL1_DMA_ENABLE, &ssp_regs->hw_ssp_ctrl1_clr);
-
                ret = mxsmmc_send_cmd_pio(priv, data);
                if (ret) {
                        printf("MMC%d: Data timeout with command %d "
@@ -282,6 +293,13 @@ mxsmmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data)
                                mmc->block_dev.dev, cmd->cmdidx, reg);
                        return ret;
                }
+       } else {
+               ret = mxsmmc_send_cmd_dma(priv, data);
+               if (ret) {
+                       printf("MMC%d: DMA transfer failed\n",
+                               mmc->block_dev.dev);
+                       return ret;
+               }
        }
 
        /* Check data errors */
@@ -332,13 +350,13 @@ static int mxsmmc_init(struct mmc *mmc)
        struct mxs_ssp_regs *ssp_regs = priv->regs;
 
        /* Reset SSP */
-       mx28_reset_block(&ssp_regs->hw_ssp_ctrl0_reg);
+       mxs_reset_block(&ssp_regs->hw_ssp_ctrl0_reg);
 
        /* 8 bits word length in MMC mode */
        clrsetbits_le32(&ssp_regs->hw_ssp_ctrl1,
-               SSP_CTRL1_SSP_MODE_MASK | SSP_CTRL1_WORD_LENGTH_MASK,
-               SSP_CTRL1_SSP_MODE_SD_MMC | SSP_CTRL1_WORD_LENGTH_EIGHT_BITS |
-               SSP_CTRL1_DMA_ENABLE);
+               SSP_CTRL1_SSP_MODE_MASK | SSP_CTRL1_WORD_LENGTH_MASK |
+               SSP_CTRL1_DMA_ENABLE,
+               SSP_CTRL1_SSP_MODE_SD_MMC | SSP_CTRL1_WORD_LENGTH_EIGHT_BITS);
 
        /* Set initial bit clock 400 KHz */
        mx28_set_ssp_busclock(priv->id, 400);