2 * (C) Copyright 2009 SAMSUNG Electronics
3 * Minkyu Kang <mk7.kang@samsung.com>
4 * Jaehoon Chung <jh80.chung@samsung.com>
5 * Portions Copyright 2011-2013 NVIDIA Corporation
7 * SPDX-License-Identifier: GPL-2.0+
10 #include <bouncebuf.h>
14 #include <asm/arch/clock.h>
15 #include <asm/arch-tegra/clk_rst.h>
16 #include <asm/arch-tegra/tegra_mmc.h>
19 DECLARE_GLOBAL_DATA_PTR;
21 struct mmc_host mmc_host[MAX_HOSTS];
23 #ifndef CONFIG_OF_CONTROL
24 #error "Please enable device tree support to use this driver"
27 static void mmc_set_power(struct mmc_host *host, unsigned short power)
30 debug("%s: power = %x\n", __func__, power);
32 if (power != (unsigned short)-1) {
35 pwr = TEGRA_MMC_PWRCTL_SD_BUS_VOLTAGE_V1_8;
39 pwr = TEGRA_MMC_PWRCTL_SD_BUS_VOLTAGE_V3_0;
43 pwr = TEGRA_MMC_PWRCTL_SD_BUS_VOLTAGE_V3_3;
47 debug("%s: pwr = %X\n", __func__, pwr);
49 /* Set the bus voltage first (if any) */
50 writeb(pwr, &host->reg->pwrcon);
54 /* Now enable bus power */
55 pwr |= TEGRA_MMC_PWRCTL_SD_BUS_POWER;
56 writeb(pwr, &host->reg->pwrcon);
59 static void mmc_prepare_data(struct mmc_host *host, struct mmc_data *data,
60 struct bounce_buffer *bbstate)
65 debug("buf: %p (%p), data->blocks: %u, data->blocksize: %u\n",
66 bbstate->bounce_buffer, bbstate->user_buffer, data->blocks,
69 writel((u32)bbstate->bounce_buffer, &host->reg->sysad);
74 * 10 = Selects 32-bit Address ADMA2
75 * 11 = Selects 64-bit Address ADMA2
77 ctrl = readb(&host->reg->hostctl);
78 ctrl &= ~TEGRA_MMC_HOSTCTL_DMASEL_MASK;
79 ctrl |= TEGRA_MMC_HOSTCTL_DMASEL_SDMA;
80 writeb(ctrl, &host->reg->hostctl);
82 /* We do not handle DMA boundaries, so set it to max (512 KiB) */
83 writew((7 << 12) | (data->blocksize & 0xFFF), &host->reg->blksize);
84 writew(data->blocks, &host->reg->blkcnt);
87 static void mmc_set_transfer_mode(struct mmc_host *host, struct mmc_data *data)
90 debug(" mmc_set_transfer_mode called\n");
93 * MUL1SIN0[5] : Multi/Single Block Select
94 * RD1WT0[4] : Data Transfer Direction Select
97 * ENACMD12[2] : Auto CMD12 Enable
98 * ENBLKCNT[1] : Block Count Enable
99 * ENDMA[0] : DMA Enable
101 mode = (TEGRA_MMC_TRNMOD_DMA_ENABLE |
102 TEGRA_MMC_TRNMOD_BLOCK_COUNT_ENABLE);
104 if (data->blocks > 1)
105 mode |= TEGRA_MMC_TRNMOD_MULTI_BLOCK_SELECT;
107 if (data->flags & MMC_DATA_READ)
108 mode |= TEGRA_MMC_TRNMOD_DATA_XFER_DIR_SEL_READ;
110 writew(mode, &host->reg->trnmod);
113 static int mmc_wait_inhibit(struct mmc_host *host,
115 struct mmc_data *data,
116 unsigned int timeout)
120 * CMDINHDAT[1] : Command Inhibit (DAT)
121 * CMDINHCMD[0] : Command Inhibit (CMD)
123 unsigned int mask = TEGRA_MMC_PRNSTS_CMD_INHIBIT_CMD;
126 * We shouldn't wait for data inhibit for stop commands, even
127 * though they might use busy signaling
129 if ((data == NULL) && (cmd->resp_type & MMC_RSP_BUSY))
130 mask |= TEGRA_MMC_PRNSTS_CMD_INHIBIT_DAT;
132 while (readl(&host->reg->prnsts) & mask) {
134 printf("%s: timeout error\n", __func__);
144 static int mmc_send_cmd_bounced(struct mmc *mmc, struct mmc_cmd *cmd,
145 struct mmc_data *data, struct bounce_buffer *bbstate)
147 struct mmc_host *host = mmc->priv;
150 unsigned int mask = 0;
151 unsigned int retry = 0x100000;
152 debug(" mmc_send_cmd called\n");
154 result = mmc_wait_inhibit(host, cmd, data, 10 /* ms */);
160 mmc_prepare_data(host, data, bbstate);
162 debug("cmd->arg: %08x\n", cmd->cmdarg);
163 writel(cmd->cmdarg, &host->reg->argument);
166 mmc_set_transfer_mode(host, data);
168 if ((cmd->resp_type & MMC_RSP_136) && (cmd->resp_type & MMC_RSP_BUSY))
173 * CMDIDX[13:8] : Command index
174 * DATAPRNT[5] : Data Present Select
175 * ENCMDIDX[4] : Command Index Check Enable
176 * ENCMDCRC[3] : Command CRC Check Enable
181 * 11 = Length 48 Check busy after response
183 if (!(cmd->resp_type & MMC_RSP_PRESENT))
184 flags = TEGRA_MMC_CMDREG_RESP_TYPE_SELECT_NO_RESPONSE;
185 else if (cmd->resp_type & MMC_RSP_136)
186 flags = TEGRA_MMC_CMDREG_RESP_TYPE_SELECT_LENGTH_136;
187 else if (cmd->resp_type & MMC_RSP_BUSY)
188 flags = TEGRA_MMC_CMDREG_RESP_TYPE_SELECT_LENGTH_48_BUSY;
190 flags = TEGRA_MMC_CMDREG_RESP_TYPE_SELECT_LENGTH_48;
192 if (cmd->resp_type & MMC_RSP_CRC)
193 flags |= TEGRA_MMC_TRNMOD_CMD_CRC_CHECK;
194 if (cmd->resp_type & MMC_RSP_OPCODE)
195 flags |= TEGRA_MMC_TRNMOD_CMD_INDEX_CHECK;
197 flags |= TEGRA_MMC_TRNMOD_DATA_PRESENT_SELECT_DATA_TRANSFER;
199 debug("cmd: %d\n", cmd->cmdidx);
201 writew((cmd->cmdidx << 8) | flags, &host->reg->cmdreg);
203 for (i = 0; i < retry; i++) {
204 mask = readl(&host->reg->norintsts);
205 /* Command Complete */
206 if (mask & TEGRA_MMC_NORINTSTS_CMD_COMPLETE) {
208 writel(mask, &host->reg->norintsts);
214 printf("%s: waiting for status update\n", __func__);
215 writel(mask, &host->reg->norintsts);
219 if (mask & TEGRA_MMC_NORINTSTS_CMD_TIMEOUT) {
221 debug("timeout: %08x cmd %d\n", mask, cmd->cmdidx);
222 writel(mask, &host->reg->norintsts);
224 } else if (mask & TEGRA_MMC_NORINTSTS_ERR_INTERRUPT) {
225 /* Error Interrupt */
226 debug("error: %08x cmd %d\n", mask, cmd->cmdidx);
227 writel(mask, &host->reg->norintsts);
231 if (cmd->resp_type & MMC_RSP_PRESENT) {
232 if (cmd->resp_type & MMC_RSP_136) {
233 /* CRC is stripped so we need to do some shifting. */
234 for (i = 0; i < 4; i++) {
235 unsigned int offset =
236 (unsigned int)(&host->reg->rspreg3 - i);
237 cmd->response[i] = readl(offset) << 8;
243 debug("cmd->resp[%d]: %08x\n",
244 i, cmd->response[i]);
246 } else if (cmd->resp_type & MMC_RSP_BUSY) {
247 for (i = 0; i < retry; i++) {
248 /* PRNTDATA[23:20] : DAT[3:0] Line Signal */
249 if (readl(&host->reg->prnsts)
250 & (1 << 20)) /* DAT[0] */
255 printf("%s: card is still busy\n", __func__);
256 writel(mask, &host->reg->norintsts);
260 cmd->response[0] = readl(&host->reg->rspreg0);
261 debug("cmd->resp[0]: %08x\n", cmd->response[0]);
263 cmd->response[0] = readl(&host->reg->rspreg0);
264 debug("cmd->resp[0]: %08x\n", cmd->response[0]);
269 unsigned long start = get_timer(0);
272 mask = readl(&host->reg->norintsts);
274 if (mask & TEGRA_MMC_NORINTSTS_ERR_INTERRUPT) {
275 /* Error Interrupt */
276 writel(mask, &host->reg->norintsts);
277 printf("%s: error during transfer: 0x%08x\n",
280 } else if (mask & TEGRA_MMC_NORINTSTS_DMA_INTERRUPT) {
282 * DMA Interrupt, restart the transfer where
283 * it was interrupted.
285 unsigned int address = readl(&host->reg->sysad);
288 writel(TEGRA_MMC_NORINTSTS_DMA_INTERRUPT,
289 &host->reg->norintsts);
290 writel(address, &host->reg->sysad);
291 } else if (mask & TEGRA_MMC_NORINTSTS_XFER_COMPLETE) {
292 /* Transfer Complete */
293 debug("r/w is done\n");
295 } else if (get_timer(start) > 2000UL) {
296 writel(mask, &host->reg->norintsts);
297 printf("%s: MMC Timeout\n"
298 " Interrupt status 0x%08x\n"
299 " Interrupt status enable 0x%08x\n"
300 " Interrupt signal enable 0x%08x\n"
301 " Present status 0x%08x\n",
303 readl(&host->reg->norintstsen),
304 readl(&host->reg->norintsigen),
305 readl(&host->reg->prnsts));
309 writel(mask, &host->reg->norintsts);
316 static int tegra_mmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd,
317 struct mmc_data *data)
320 unsigned int bbflags;
322 struct bounce_buffer bbstate;
326 if (data->flags & MMC_DATA_READ) {
328 bbflags = GEN_BB_WRITE;
330 buf = (void *)data->src;
331 bbflags = GEN_BB_READ;
333 len = data->blocks * data->blocksize;
335 bounce_buffer_start(&bbstate, buf, len, bbflags);
338 ret = mmc_send_cmd_bounced(mmc, cmd, data, &bbstate);
341 bounce_buffer_stop(&bbstate);
346 static void mmc_change_clock(struct mmc_host *host, uint clock)
350 unsigned long timeout;
352 debug(" mmc_change_clock called\n");
355 * Change Tegra SDMMCx clock divisor here. Source is PLLP_OUT0
359 clock_adjust_periph_pll_div(host->mmc_id, CLOCK_ID_PERIPH, clock,
361 debug("div = %d\n", div);
363 writew(0, &host->reg->clkcon);
367 * SELFREQ[15:8] : base clock divided by value
368 * ENSDCLK[2] : SD Clock Enable
369 * STBLINTCLK[1] : Internal Clock Stable
370 * ENINTCLK[0] : Internal Clock Enable
373 clk = ((div << TEGRA_MMC_CLKCON_SDCLK_FREQ_SEL_SHIFT) |
374 TEGRA_MMC_CLKCON_INTERNAL_CLOCK_ENABLE);
375 writew(clk, &host->reg->clkcon);
379 while (!(readw(&host->reg->clkcon) &
380 TEGRA_MMC_CLKCON_INTERNAL_CLOCK_STABLE)) {
382 printf("%s: timeout error\n", __func__);
389 clk |= TEGRA_MMC_CLKCON_SD_CLOCK_ENABLE;
390 writew(clk, &host->reg->clkcon);
392 debug("mmc_change_clock: clkcon = %08X\n", clk);
398 static void tegra_mmc_set_ios(struct mmc *mmc)
400 struct mmc_host *host = mmc->priv;
402 debug(" mmc_set_ios called\n");
404 debug("bus_width: %x, clock: %d\n", mmc->bus_width, mmc->clock);
406 /* Change clock first */
407 mmc_change_clock(host, mmc->clock);
409 ctrl = readb(&host->reg->hostctl);
413 * 0 = Depend on WIDE4
419 if (mmc->bus_width == 8)
421 else if (mmc->bus_width == 4)
426 writeb(ctrl, &host->reg->hostctl);
427 debug("mmc_set_ios: hostctl = %08X\n", ctrl);
430 static void mmc_reset(struct mmc_host *host, struct mmc *mmc)
432 unsigned int timeout;
433 debug(" mmc_reset called\n");
436 * RSTALL[0] : Software reset for all
440 writeb(TEGRA_MMC_SWRST_SW_RESET_FOR_ALL, &host->reg->swrst);
444 /* Wait max 100 ms */
447 /* hw clears the bit when it's done */
448 while (readb(&host->reg->swrst) & TEGRA_MMC_SWRST_SW_RESET_FOR_ALL) {
450 printf("%s: timeout error\n", __func__);
457 /* Set SD bus voltage & enable bus power */
458 mmc_set_power(host, fls(mmc->cfg->voltages) - 1);
459 debug("%s: power control = %02X, host control = %02X\n", __func__,
460 readb(&host->reg->pwrcon), readb(&host->reg->hostctl));
462 /* Make sure SDIO pads are set up */
466 static int tegra_mmc_core_init(struct mmc *mmc)
468 struct mmc_host *host = mmc->priv;
470 debug(" mmc_core_init called\n");
472 mmc_reset(host, mmc);
474 host->version = readw(&host->reg->hcver);
475 debug("host version = %x\n", host->version);
478 writel(0xffffffff, &host->reg->norintstsen);
479 writel(0xffffffff, &host->reg->norintsigen);
481 writeb(0xe, &host->reg->timeoutcon); /* TMCLK * 2^27 */
483 * NORMAL Interrupt Status Enable Register init
484 * [5] ENSTABUFRDRDY : Buffer Read Ready Status Enable
485 * [4] ENSTABUFWTRDY : Buffer write Ready Status Enable
486 * [3] ENSTADMAINT : DMA boundary interrupt
487 * [1] ENSTASTANSCMPLT : Transfre Complete Status Enable
488 * [0] ENSTACMDCMPLT : Command Complete Status Enable
490 mask = readl(&host->reg->norintstsen);
492 mask |= (TEGRA_MMC_NORINTSTSEN_CMD_COMPLETE |
493 TEGRA_MMC_NORINTSTSEN_XFER_COMPLETE |
494 TEGRA_MMC_NORINTSTSEN_DMA_INTERRUPT |
495 TEGRA_MMC_NORINTSTSEN_BUFFER_WRITE_READY |
496 TEGRA_MMC_NORINTSTSEN_BUFFER_READ_READY);
497 writel(mask, &host->reg->norintstsen);
500 * NORMAL Interrupt Signal Enable Register init
501 * [1] ENSTACMDCMPLT : Transfer Complete Signal Enable
503 mask = readl(&host->reg->norintsigen);
505 mask |= TEGRA_MMC_NORINTSIGEN_XFER_COMPLETE;
506 writel(mask, &host->reg->norintsigen);
511 int tegra_mmc_getcd(struct mmc *mmc)
513 struct mmc_host *host = mmc->priv;
515 debug("tegra_mmc_getcd called\n");
517 if (fdt_gpio_isvalid(&host->cd_gpio))
518 return fdtdec_get_gpio(&host->cd_gpio);
523 static const struct mmc_ops tegra_mmc_ops = {
524 .send_cmd = tegra_mmc_send_cmd,
525 .set_ios = tegra_mmc_set_ios,
526 .init = tegra_mmc_core_init,
527 .getcd = tegra_mmc_getcd,
530 static int do_mmc_init(int dev_index)
532 struct mmc_host *host;
533 char gpusage[12]; /* "SD/MMCn PWR" or "SD/MMCn CD" */
536 /* DT should have been read & host config filled in */
537 host = &mmc_host[dev_index];
541 debug(" do_mmc_init: index %d, bus width %d "
542 "pwr_gpio %d cd_gpio %d\n",
543 dev_index, host->width,
544 host->pwr_gpio.gpio, host->cd_gpio.gpio);
547 clock_start_periph_pll(host->mmc_id, CLOCK_ID_PERIPH, 20000000);
549 if (fdt_gpio_isvalid(&host->pwr_gpio)) {
550 sprintf(gpusage, "SD/MMC%d PWR", dev_index);
551 gpio_request(host->pwr_gpio.gpio, gpusage);
552 gpio_direction_output(host->pwr_gpio.gpio, 1);
553 debug(" Power GPIO name = %s\n", host->pwr_gpio.name);
556 if (fdt_gpio_isvalid(&host->cd_gpio)) {
557 sprintf(gpusage, "SD/MMC%d CD", dev_index);
558 gpio_request(host->cd_gpio.gpio, gpusage);
559 gpio_direction_input(host->cd_gpio.gpio);
560 debug(" CD GPIO name = %s\n", host->cd_gpio.name);
563 memset(&host->cfg, 0, sizeof(host->cfg));
565 host->cfg.name = "Tegra SD/MMC";
566 host->cfg.ops = &tegra_mmc_ops;
568 host->cfg.voltages = MMC_VDD_32_33 | MMC_VDD_33_34 | MMC_VDD_165_195;
569 host->cfg.host_caps = 0;
570 if (host->width == 8)
571 host->cfg.host_caps |= MMC_MODE_8BIT;
572 if (host->width >= 4)
573 host->cfg.host_caps |= MMC_MODE_4BIT;
574 host->cfg.host_caps |= MMC_MODE_HS_52MHz | MMC_MODE_HS | MMC_MODE_HC;
577 * min freq is for card identification, and is the highest
578 * low-speed SDIO card frequency (actually 400KHz)
579 * max freq is highest HS eMMC clock as per the SD/MMC spec
582 host->cfg.f_min = 375000;
583 host->cfg.f_max = 48000000;
585 host->cfg.b_max = CONFIG_SYS_MMC_MAX_BLK_COUNT;
587 mmc = mmc_create(&host->cfg, host);
595 * Get the host address and peripheral ID for a node.
597 * @param blob fdt blob
598 * @param node Device index (0-3)
599 * @param host Structure to fill in (reg, width, mmc_id)
601 static int mmc_get_config(const void *blob, int node, struct mmc_host *host)
603 debug("%s: node = %d\n", __func__, node);
605 host->enabled = fdtdec_get_is_enabled(blob, node);
607 host->reg = (struct tegra_mmc *)fdtdec_get_addr(blob, node, "reg");
608 if ((fdt_addr_t)host->reg == FDT_ADDR_T_NONE) {
609 debug("%s: no sdmmc base reg info found\n", __func__);
610 return -FDT_ERR_NOTFOUND;
613 host->mmc_id = clock_decode_periph_id(blob, node);
614 if (host->mmc_id == PERIPH_ID_NONE) {
615 debug("%s: could not decode periph id\n", __func__);
616 return -FDT_ERR_NOTFOUND;
620 * NOTE: mmc->bus_width is determined by mmc.c dynamically.
621 * TBD: Override it with this value?
623 host->width = fdtdec_get_int(blob, node, "bus-width", 0);
625 debug("%s: no sdmmc width found\n", __func__);
627 /* These GPIOs are optional */
628 fdtdec_decode_gpio(blob, node, "cd-gpios", &host->cd_gpio);
629 fdtdec_decode_gpio(blob, node, "wp-gpios", &host->wp_gpio);
630 fdtdec_decode_gpio(blob, node, "power-gpios", &host->pwr_gpio);
632 debug("%s: found controller at %p, width = %d, periph_id = %d\n",
633 __func__, host->reg, host->width, host->mmc_id);
638 * Process a list of nodes, adding them to our list of SDMMC ports.
640 * @param blob fdt blob
641 * @param node_list list of nodes to process (any <=0 are ignored)
642 * @param count number of nodes to process
643 * @return 0 if ok, -1 on error
645 static int process_nodes(const void *blob, int node_list[], int count)
647 struct mmc_host *host;
650 debug("%s: count = %d\n", __func__, count);
652 /* build mmc_host[] for each controller */
653 for (i = 0; i < count; i++) {
661 if (mmc_get_config(blob, node, host)) {
662 printf("%s: failed to decode dev %d\n", __func__, i);
670 void tegra_mmc_init(void)
672 int node_list[MAX_HOSTS], count;
673 const void *blob = gd->fdt_blob;
674 debug("%s entry\n", __func__);
676 /* See if any Tegra124 MMC controllers are present */
677 count = fdtdec_find_aliases_for_id(blob, "sdhci",
678 COMPAT_NVIDIA_TEGRA124_SDMMC, node_list, MAX_HOSTS);
679 debug("%s: count of Tegra124 sdhci nodes is %d\n", __func__, count);
680 if (process_nodes(blob, node_list, count)) {
681 printf("%s: Error processing T30 mmc node(s)!\n", __func__);
685 /* See if any Tegra30 MMC controllers are present */
686 count = fdtdec_find_aliases_for_id(blob, "sdhci",
687 COMPAT_NVIDIA_TEGRA30_SDMMC, node_list, MAX_HOSTS);
688 debug("%s: count of T30 sdhci nodes is %d\n", __func__, count);
689 if (process_nodes(blob, node_list, count)) {
690 printf("%s: Error processing T30 mmc node(s)!\n", __func__);
694 /* Now look for any Tegra20 MMC controllers */
695 count = fdtdec_find_aliases_for_id(blob, "sdhci",
696 COMPAT_NVIDIA_TEGRA20_SDMMC, node_list, MAX_HOSTS);
697 debug("%s: count of T20 sdhci nodes is %d\n", __func__, count);
698 if (process_nodes(blob, node_list, count)) {
699 printf("%s: Error processing T20 mmc node(s)!\n", __func__);