mmc: fsl_esdhc: fix check_and_invalidate_dcache_range function

[u-boot] / drivers / mmc / dw_mmc.c

diff --git a/drivers/mmc/dw_mmc.c b/drivers/mmc/dw_mmc.c
index bee8fab332d6ae2605c7e083826d08e9602dcd4a..74a2663c8bf976f27b6cce2a5fe2f863cf54b8da 100644 (file)
--- a/drivers/mmc/dw_mmc.c
+++ b/drivers/mmc/dw_mmc.c
@@ -94,12 +94,21 @@ static void dwmci_prepare_data(struct dwmci_host *host,
        dwmci_writel(host, DWMCI_BYTCNT, data->blocksize * data->blocks);
 }
 
-static int dwmci_data_transfer(struct dwmci_host *host)
+static int dwmci_data_transfer(struct dwmci_host *host, struct mmc_data *data)
 {
        int ret = 0;
-       unsigned int timeout = 240000;
-       u32 mask;
+       u32 timeout = 240000;
+       u32 mask, size, i, len = 0;
+       u32 *buf = NULL;
        ulong start = get_timer(0);
+       u32 fifo_depth = (((host->fifoth_val & RX_WMARK_MASK) >>
+                           RX_WMARK_SHIFT) + 1) * 2;
+
+       size = data->blocksize * data->blocks / 4;
+       if (data->flags == MMC_DATA_READ)
+               buf = (unsigned int *)data->dest;
+       else
+               buf = (unsigned int *)data->src;
 
        for (;;) {
                mask = dwmci_readl(host, DWMCI_RINTSTS);
@@ -110,6 +119,36 @@ static int dwmci_data_transfer(struct dwmci_host *host)
                        break;
                }
 
+               if (host->fifo_mode && size) {
+                       if (data->flags == MMC_DATA_READ) {
+                               if ((dwmci_readl(host, DWMCI_RINTSTS) &&
+                                    DWMCI_INTMSK_RXDR)) {
+                                       len = dwmci_readl(host, DWMCI_STATUS);
+                                       len = (len >> DWMCI_FIFO_SHIFT) &
+                                                   DWMCI_FIFO_MASK;
+                                       for (i = 0; i < len; i++)
+                                               *buf++ =
+                                               dwmci_readl(host, DWMCI_DATA);
+                                       dwmci_writel(host, DWMCI_RINTSTS,
+                                                    DWMCI_INTMSK_RXDR);
+                               }
+                       } else {
+                               if ((dwmci_readl(host, DWMCI_RINTSTS) &&
+                                    DWMCI_INTMSK_TXDR)) {
+                                       len = dwmci_readl(host, DWMCI_STATUS);
+                                       len = fifo_depth - ((len >>
+                                                  DWMCI_FIFO_SHIFT) &
+                                                  DWMCI_FIFO_MASK);
+                                       for (i = 0; i < len; i++)
+                                               dwmci_writel(host, DWMCI_DATA,
+                                                            *buf++);
+                                       dwmci_writel(host, DWMCI_RINTSTS,
+                                                    DWMCI_INTMSK_TXDR);
+                               }
+                       }
+                       size = size > len ? (size - len) : 0;
+               }
+
                /* Data arrived correctly. */
                if (mask & DWMCI_INTMSK_DTO) {
                        ret = 0;
@@ -150,7 +189,7 @@ static int dwmci_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd,
                                 data ? DIV_ROUND_UP(data->blocks, 8) : 0);
        int ret = 0, flags = 0, i;
        unsigned int timeout = 100000;
-       u32 retry = 10000;
+       u32 retry = 100000;
        u32 mask, ctrl;
        ulong start = get_timer(0);
        struct bounce_buffer bbstate;
@@ -165,17 +204,24 @@ static int dwmci_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd,
        dwmci_writel(host, DWMCI_RINTSTS, DWMCI_INTMSK_ALL);
 
        if (data) {
-               if (data->flags == MMC_DATA_READ) {
-                       bounce_buffer_start(&bbstate, (void*)data->dest,
-                                           data->blocksize *
-                                           data->blocks, GEN_BB_WRITE);
+               if (host->fifo_mode) {
+                       dwmci_writel(host, DWMCI_BLKSIZ, data->blocksize);
+                       dwmci_writel(host, DWMCI_BYTCNT,
+                                    data->blocksize * data->blocks);
+                       dwmci_wait_reset(host, DWMCI_CTRL_FIFO_RESET);
                } else {
-                       bounce_buffer_start(&bbstate, (void*)data->src,
-                                           data->blocksize *
-                                           data->blocks, GEN_BB_READ);
+                       if (data->flags == MMC_DATA_READ) {
+                               bounce_buffer_start(&bbstate, (void*)data->dest,
+                                               data->blocksize *
+                                               data->blocks, GEN_BB_WRITE);
+                       } else {
+                               bounce_buffer_start(&bbstate, (void*)data->src,
+                                               data->blocksize *
+                                               data->blocks, GEN_BB_READ);
+                       }
+                       dwmci_prepare_data(host, data, cur_idmac,
+                                          bbstate.bounce_buffer);
                }
-               dwmci_prepare_data(host, data, cur_idmac,
-                                  bbstate.bounce_buffer);
        }
 
        dwmci_writel(host, DWMCI_CMDARG, cmd->cmdarg);
@@ -249,12 +295,15 @@ static int dwmci_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd,
        }
 
        if (data) {
-               ret = dwmci_data_transfer(host);
-
-               ctrl = dwmci_readl(host, DWMCI_CTRL);
-               ctrl &= ~(DWMCI_DMA_EN);
-               dwmci_writel(host, DWMCI_CTRL, ctrl);
-               bounce_buffer_stop(&bbstate);
+               ret = dwmci_data_transfer(host, data);
+
+               /* only dma mode need it */
+               if (!host->fifo_mode) {
+                       ctrl = dwmci_readl(host, DWMCI_CTRL);
+                       ctrl &= ~(DWMCI_DMA_EN);
+                       dwmci_writel(host, DWMCI_CTRL, ctrl);
+                       bounce_buffer_stop(&bbstate);
+               }
        }
 
        udelay(100);
@@ -405,27 +454,40 @@ static const struct mmc_ops dwmci_ops = {
        .init           = dwmci_init,
 };
 
-int add_dwmci(struct dwmci_host *host, u32 max_clk, u32 min_clk)
+void dwmci_setup_cfg(struct mmc_config *cfg, const char *name, int buswidth,
+                    uint caps, u32 max_clk, u32 min_clk)
 {
-       host->cfg.name = host->name;
-       host->cfg.ops = &dwmci_ops;
-       host->cfg.f_min = min_clk;
-       host->cfg.f_max = max_clk;
+       cfg->name = name;
+       cfg->ops = &dwmci_ops;
+       cfg->f_min = min_clk;
+       cfg->f_max = max_clk;
 
-       host->cfg.voltages = MMC_VDD_32_33 | MMC_VDD_33_34 | MMC_VDD_165_195;
+       cfg->voltages = MMC_VDD_32_33 | MMC_VDD_33_34 | MMC_VDD_165_195;
 
-       host->cfg.host_caps = host->caps;
+       cfg->host_caps = caps;
 
-       if (host->buswidth == 8) {
-               host->cfg.host_caps |= MMC_MODE_8BIT;
-               host->cfg.host_caps &= ~MMC_MODE_4BIT;
+       if (buswidth == 8) {
+               cfg->host_caps |= MMC_MODE_8BIT;
+               cfg->host_caps &= ~MMC_MODE_4BIT;
        } else {
-               host->cfg.host_caps |= MMC_MODE_4BIT;
-               host->cfg.host_caps &= ~MMC_MODE_8BIT;
+               cfg->host_caps |= MMC_MODE_4BIT;
+               cfg->host_caps &= ~MMC_MODE_8BIT;
        }
-       host->cfg.host_caps |= MMC_MODE_HS | MMC_MODE_HS_52MHz;
+       cfg->host_caps |= MMC_MODE_HS | MMC_MODE_HS_52MHz;
+
+       cfg->b_max = CONFIG_SYS_MMC_MAX_BLK_COUNT;
+}
 
-       host->cfg.b_max = CONFIG_SYS_MMC_MAX_BLK_COUNT;
+#ifdef CONFIG_BLK
+int dwmci_bind(struct udevice *dev, struct mmc *mmc, struct mmc_config *cfg)
+{
+       return mmc_bind(dev, mmc, cfg);
+}
+#else
+int add_dwmci(struct dwmci_host *host, u32 max_clk, u32 min_clk)
+{
+       dwmci_setup_cfg(&host->cfg, host->name, host->buswidth, host->caps,
+                       max_clk, min_clk);
 
        host->mmc = mmc_create(&host->cfg, host);
        if (host->mmc == NULL)
@@ -433,3 +495,4 @@ int add_dwmci(struct dwmci_host *host, u32 max_clk, u32 min_clk)
 
        return 0;
 }
+#endif