|
@@ -67,17 +67,123 @@ static void sdhci_transfer_pio(struct sdhci_host *host, struct mmc_data *data)
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-static int sdhci_transfer_data(struct sdhci_host *host, struct mmc_data *data,
|
|
|
- unsigned int start_addr)
|
|
|
+#if CONFIG_IS_ENABLED(MMC_SDHCI_ADMA)
|
|
|
+static void sdhci_adma_desc(struct sdhci_host *host, char *buf, u16 len,
|
|
|
+ bool end)
|
|
|
+{
|
|
|
+ struct sdhci_adma_desc *desc;
|
|
|
+ u8 attr;
|
|
|
+
|
|
|
+ desc = &host->adma_desc_table[host->desc_slot];
|
|
|
+
|
|
|
+ attr = ADMA_DESC_ATTR_VALID | ADMA_DESC_TRANSFER_DATA;
|
|
|
+ if (!end)
|
|
|
+ host->desc_slot++;
|
|
|
+ else
|
|
|
+ attr |= ADMA_DESC_ATTR_END;
|
|
|
+
|
|
|
+ desc->attr = attr;
|
|
|
+ desc->len = len;
|
|
|
+ desc->reserved = 0;
|
|
|
+ desc->addr_lo = (dma_addr_t)buf;
|
|
|
+#ifdef CONFIG_DMA_ADDR_T_64BIT
|
|
|
+ desc->addr_hi = (u64)buf >> 32;
|
|
|
+#endif
|
|
|
+}
|
|
|
+
|
|
|
+static void sdhci_prepare_adma_table(struct sdhci_host *host,
|
|
|
+ struct mmc_data *data)
|
|
|
+{
|
|
|
+ uint trans_bytes = data->blocksize * data->blocks;
|
|
|
+ uint desc_count = DIV_ROUND_UP(trans_bytes, ADMA_MAX_LEN);
|
|
|
+ int i = desc_count;
|
|
|
+ char *buf;
|
|
|
+
|
|
|
+ host->desc_slot = 0;
|
|
|
+
|
|
|
+ if (data->flags & MMC_DATA_READ)
|
|
|
+ buf = data->dest;
|
|
|
+ else
|
|
|
+ buf = (char *)data->src;
|
|
|
+
|
|
|
+ while (--i) {
|
|
|
+ sdhci_adma_desc(host, buf, ADMA_MAX_LEN, false);
|
|
|
+ buf += ADMA_MAX_LEN;
|
|
|
+ trans_bytes -= ADMA_MAX_LEN;
|
|
|
+ }
|
|
|
+
|
|
|
+ sdhci_adma_desc(host, buf, trans_bytes, true);
|
|
|
+
|
|
|
+ flush_cache((dma_addr_t)host->adma_desc_table,
|
|
|
+ ROUND(desc_count * sizeof(struct sdhci_adma_desc),
|
|
|
+ ARCH_DMA_MINALIGN));
|
|
|
+}
|
|
|
+#elif defined(CONFIG_MMC_SDHCI_SDMA)
|
|
|
+static void sdhci_prepare_adma_table(struct sdhci_host *host,
|
|
|
+ struct mmc_data *data)
|
|
|
+{}
|
|
|
+#endif
|
|
|
+#if (defined(CONFIG_MMC_SDHCI_SDMA) || CONFIG_IS_ENABLED(MMC_SDHCI_ADMA))
|
|
|
+static void sdhci_prepare_dma(struct sdhci_host *host, struct mmc_data *data,
|
|
|
+ int *is_aligned, int trans_bytes)
|
|
|
{
|
|
|
- unsigned int stat, rdy, mask, timeout, block = 0;
|
|
|
- bool transfer_done = false;
|
|
|
-#ifdef CONFIG_MMC_SDHCI_SDMA
|
|
|
unsigned char ctrl;
|
|
|
+
|
|
|
+ if (data->flags == MMC_DATA_READ)
|
|
|
+ host->start_addr = (dma_addr_t)data->dest;
|
|
|
+ else
|
|
|
+ host->start_addr = (dma_addr_t)data->src;
|
|
|
+
|
|
|
ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL);
|
|
|
ctrl &= ~SDHCI_CTRL_DMA_MASK;
|
|
|
+ if (host->flags & USE_ADMA64)
|
|
|
+ ctrl |= SDHCI_CTRL_ADMA64;
|
|
|
+ else if (host->flags & USE_ADMA)
|
|
|
+ ctrl |= SDHCI_CTRL_ADMA32;
|
|
|
sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
|
|
|
+
|
|
|
+ if (host->flags & USE_SDMA) {
|
|
|
+ if ((host->quirks & SDHCI_QUIRK_32BIT_DMA_ADDR) &&
|
|
|
+ (host->start_addr & 0x7) != 0x0) {
|
|
|
+ *is_aligned = 0;
|
|
|
+ host->start_addr = (unsigned long)aligned_buffer;
|
|
|
+ if (data->flags != MMC_DATA_READ)
|
|
|
+ memcpy(aligned_buffer, data->src, trans_bytes);
|
|
|
+ }
|
|
|
+
|
|
|
+#if defined(CONFIG_FIXED_SDHCI_ALIGNED_BUFFER)
|
|
|
+ /*
|
|
|
+ * Always use this bounce-buffer when
|
|
|
+ * CONFIG_FIXED_SDHCI_ALIGNED_BUFFER is defined
|
|
|
+ */
|
|
|
+ *is_aligned = 0;
|
|
|
+ host->start_addr = (unsigned long)aligned_buffer;
|
|
|
+ if (data->flags != MMC_DATA_READ)
|
|
|
+ memcpy(aligned_buffer, data->src, trans_bytes);
|
|
|
+#endif
|
|
|
+ sdhci_writel(host, host->start_addr, SDHCI_DMA_ADDRESS);
|
|
|
+
|
|
|
+ } else if (host->flags & (USE_ADMA | USE_ADMA64)) {
|
|
|
+ sdhci_prepare_adma_table(host, data);
|
|
|
+
|
|
|
+ sdhci_writel(host, (u32)host->adma_addr, SDHCI_ADMA_ADDRESS);
|
|
|
+ if (host->flags & USE_ADMA64)
|
|
|
+ sdhci_writel(host, (u64)host->adma_addr >> 32,
|
|
|
+ SDHCI_ADMA_ADDRESS_HI);
|
|
|
+ }
|
|
|
+
|
|
|
+ flush_cache(host->start_addr, ROUND(trans_bytes, ARCH_DMA_MINALIGN));
|
|
|
+}
|
|
|
+#else
|
|
|
+static void sdhci_prepare_dma(struct sdhci_host *host, struct mmc_data *data,
|
|
|
+ int *is_aligned, int trans_bytes)
|
|
|
+{}
|
|
|
#endif
|
|
|
+static int sdhci_transfer_data(struct sdhci_host *host, struct mmc_data *data)
|
|
|
+{
|
|
|
+ dma_addr_t start_addr = host->start_addr;
|
|
|
+ unsigned int stat, rdy, mask, timeout, block = 0;
|
|
|
+ bool transfer_done = false;
|
|
|
|
|
|
timeout = 1000000;
|
|
|
rdy = SDHCI_INT_SPACE_AVAIL | SDHCI_INT_DATA_AVAIL;
|
|
@@ -104,14 +210,17 @@ static int sdhci_transfer_data(struct sdhci_host *host, struct mmc_data *data,
|
|
|
continue;
|
|
|
}
|
|
|
}
|
|
|
-#ifdef CONFIG_MMC_SDHCI_SDMA
|
|
|
- if (!transfer_done && (stat & SDHCI_INT_DMA_END)) {
|
|
|
+ if ((host->flags & USE_DMA) && !transfer_done &&
|
|
|
+ (stat & SDHCI_INT_DMA_END)) {
|
|
|
sdhci_writel(host, SDHCI_INT_DMA_END, SDHCI_INT_STATUS);
|
|
|
- start_addr &= ~(SDHCI_DEFAULT_BOUNDARY_SIZE - 1);
|
|
|
- start_addr += SDHCI_DEFAULT_BOUNDARY_SIZE;
|
|
|
- sdhci_writel(host, start_addr, SDHCI_DMA_ADDRESS);
|
|
|
+ if (host->flags & USE_SDMA) {
|
|
|
+ start_addr &=
|
|
|
+ ~(SDHCI_DEFAULT_BOUNDARY_SIZE - 1);
|
|
|
+ start_addr += SDHCI_DEFAULT_BOUNDARY_SIZE;
|
|
|
+ sdhci_writel(host, start_addr,
|
|
|
+ SDHCI_DMA_ADDRESS);
|
|
|
+ }
|
|
|
}
|
|
|
-#endif
|
|
|
if (timeout-- > 0)
|
|
|
udelay(10);
|
|
|
else {
|
|
@@ -149,10 +258,11 @@ static int sdhci_send_command(struct mmc *mmc, struct mmc_cmd *cmd,
|
|
|
int ret = 0;
|
|
|
int trans_bytes = 0, is_aligned = 1;
|
|
|
u32 mask, flags, mode;
|
|
|
- unsigned int time = 0, start_addr = 0;
|
|
|
+ unsigned int time = 0;
|
|
|
int mmc_dev = mmc_get_blk_desc(mmc)->devnum;
|
|
|
ulong start = get_timer(0);
|
|
|
|
|
|
+ host->start_addr = 0;
|
|
|
/* Timeout unit - ms */
|
|
|
static unsigned int cmd_timeout = SDHCI_CMD_DEFAULT_TIMEOUT;
|
|
|
|
|
@@ -218,33 +328,11 @@ static int sdhci_send_command(struct mmc *mmc, struct mmc_cmd *cmd,
|
|
|
if (data->flags == MMC_DATA_READ)
|
|
|
mode |= SDHCI_TRNS_READ;
|
|
|
|
|
|
-#ifdef CONFIG_MMC_SDHCI_SDMA
|
|
|
- if (data->flags == MMC_DATA_READ)
|
|
|
- start_addr = (unsigned long)data->dest;
|
|
|
- else
|
|
|
- start_addr = (unsigned long)data->src;
|
|
|
- if ((host->quirks & SDHCI_QUIRK_32BIT_DMA_ADDR) &&
|
|
|
- (start_addr & 0x7) != 0x0) {
|
|
|
- is_aligned = 0;
|
|
|
- start_addr = (unsigned long)aligned_buffer;
|
|
|
- if (data->flags != MMC_DATA_READ)
|
|
|
- memcpy(aligned_buffer, data->src, trans_bytes);
|
|
|
+ if (host->flags & USE_DMA) {
|
|
|
+ mode |= SDHCI_TRNS_DMA;
|
|
|
+ sdhci_prepare_dma(host, data, &is_aligned, trans_bytes);
|
|
|
}
|
|
|
|
|
|
-#if defined(CONFIG_FIXED_SDHCI_ALIGNED_BUFFER)
|
|
|
- /*
|
|
|
- * Always use this bounce-buffer when
|
|
|
- * CONFIG_FIXED_SDHCI_ALIGNED_BUFFER is defined
|
|
|
- */
|
|
|
- is_aligned = 0;
|
|
|
- start_addr = (unsigned long)aligned_buffer;
|
|
|
- if (data->flags != MMC_DATA_READ)
|
|
|
- memcpy(aligned_buffer, data->src, trans_bytes);
|
|
|
-#endif
|
|
|
-
|
|
|
- sdhci_writel(host, start_addr, SDHCI_DMA_ADDRESS);
|
|
|
- mode |= SDHCI_TRNS_DMA;
|
|
|
-#endif
|
|
|
sdhci_writew(host, SDHCI_MAKE_BLKSZ(SDHCI_DEFAULT_BOUNDARY_ARG,
|
|
|
data->blocksize),
|
|
|
SDHCI_BLOCK_SIZE);
|
|
@@ -255,12 +343,6 @@ static int sdhci_send_command(struct mmc *mmc, struct mmc_cmd *cmd,
|
|
|
}
|
|
|
|
|
|
sdhci_writel(host, cmd->cmdarg, SDHCI_ARGUMENT);
|
|
|
-#ifdef CONFIG_MMC_SDHCI_SDMA
|
|
|
- if (data) {
|
|
|
- trans_bytes = ALIGN(trans_bytes, CONFIG_SYS_CACHELINE_SIZE);
|
|
|
- flush_cache(start_addr, trans_bytes);
|
|
|
- }
|
|
|
-#endif
|
|
|
sdhci_writew(host, SDHCI_MAKE_CMD(cmd->cmdidx, flags), SDHCI_COMMAND);
|
|
|
start = get_timer(0);
|
|
|
do {
|
|
@@ -286,7 +368,7 @@ static int sdhci_send_command(struct mmc *mmc, struct mmc_cmd *cmd,
|
|
|
ret = -1;
|
|
|
|
|
|
if (!ret && data)
|
|
|
- ret = sdhci_transfer_data(host, data, start_addr);
|
|
|
+ ret = sdhci_transfer_data(host, data);
|
|
|
|
|
|
if (host->quirks & SDHCI_QUIRK_WAIT_SEND_CMD)
|
|
|
udelay(1000);
|
|
@@ -570,6 +652,24 @@ int sdhci_setup_cfg(struct mmc_config *cfg, struct sdhci_host *host,
|
|
|
__func__);
|
|
|
return -EINVAL;
|
|
|
}
|
|
|
+
|
|
|
+ host->flags |= USE_SDMA;
|
|
|
+#endif
|
|
|
+#if CONFIG_IS_ENABLED(MMC_SDHCI_ADMA)
|
|
|
+ if (!(caps & SDHCI_CAN_DO_ADMA2)) {
|
|
|
+ printf("%s: Your controller doesn't support SDMA!!\n",
|
|
|
+ __func__);
|
|
|
+ return -EINVAL;
|
|
|
+ }
|
|
|
+ host->adma_desc_table = (struct sdhci_adma_desc *)
|
|
|
+ memalign(ARCH_DMA_MINALIGN, ADMA_TABLE_SZ);
|
|
|
+
|
|
|
+ host->adma_addr = (dma_addr_t)host->adma_desc_table;
|
|
|
+#ifdef CONFIG_DMA_ADDR_T_64BIT
|
|
|
+ host->flags |= USE_ADMA64;
|
|
|
+#else
|
|
|
+ host->flags |= USE_ADMA;
|
|
|
+#endif
|
|
|
#endif
|
|
|
if (host->quirks & SDHCI_QUIRK_REG32_RW)
|
|
|
host->version =
|