2 * (C) Copyright 2009 SAMSUNG Electronics
3 * Minkyu Kang <mk7.kang@samsung.com>
4 * Jaehoon Chung <jh80.chung@samsung.com>
5 * Portions Copyright 2011-2016 NVIDIA Corporation
7 * SPDX-License-Identifier: GPL-2.0+
10 #include <bouncebuf.h>
12 #include <dm/device.h>
16 #include <asm/arch-tegra/tegra_mmc.h>
19 DECLARE_GLOBAL_DATA_PTR
;
21 struct tegra_mmc_priv
{
22 struct tegra_mmc
*reg
;
23 struct reset_ctl reset_ctl
;
25 struct gpio_desc cd_gpio
; /* Change Detect GPIO */
26 struct gpio_desc pwr_gpio
; /* Power GPIO */
27 struct gpio_desc wp_gpio
; /* Write Protect GPIO */
28 unsigned int version
; /* SDHCI spec. version */
29 unsigned int clock
; /* Current clock (MHz) */
30 struct mmc_config cfg
; /* mmc configuration */
34 static void tegra_mmc_set_power(struct tegra_mmc_priv
*priv
,
38 debug("%s: power = %x\n", __func__
, power
);
40 if (power
!= (unsigned short)-1) {
43 pwr
= TEGRA_MMC_PWRCTL_SD_BUS_VOLTAGE_V1_8
;
47 pwr
= TEGRA_MMC_PWRCTL_SD_BUS_VOLTAGE_V3_0
;
51 pwr
= TEGRA_MMC_PWRCTL_SD_BUS_VOLTAGE_V3_3
;
55 debug("%s: pwr = %X\n", __func__
, pwr
);
57 /* Set the bus voltage first (if any) */
58 writeb(pwr
, &priv
->reg
->pwrcon
);
62 /* Now enable bus power */
63 pwr
|= TEGRA_MMC_PWRCTL_SD_BUS_POWER
;
64 writeb(pwr
, &priv
->reg
->pwrcon
);
67 static void tegra_mmc_prepare_data(struct tegra_mmc_priv
*priv
,
68 struct mmc_data
*data
,
69 struct bounce_buffer
*bbstate
)
74 debug("buf: %p (%p), data->blocks: %u, data->blocksize: %u\n",
75 bbstate
->bounce_buffer
, bbstate
->user_buffer
, data
->blocks
,
78 writel((u32
)(unsigned long)bbstate
->bounce_buffer
, &priv
->reg
->sysad
);
83 * 10 = Selects 32-bit Address ADMA2
84 * 11 = Selects 64-bit Address ADMA2
86 ctrl
= readb(&priv
->reg
->hostctl
);
87 ctrl
&= ~TEGRA_MMC_HOSTCTL_DMASEL_MASK
;
88 ctrl
|= TEGRA_MMC_HOSTCTL_DMASEL_SDMA
;
89 writeb(ctrl
, &priv
->reg
->hostctl
);
91 /* We do not handle DMA boundaries, so set it to max (512 KiB) */
92 writew((7 << 12) | (data
->blocksize
& 0xFFF), &priv
->reg
->blksize
);
93 writew(data
->blocks
, &priv
->reg
->blkcnt
);
96 static void tegra_mmc_set_transfer_mode(struct tegra_mmc_priv
*priv
,
97 struct mmc_data
*data
)
100 debug(" mmc_set_transfer_mode called\n");
103 * MUL1SIN0[5] : Multi/Single Block Select
104 * RD1WT0[4] : Data Transfer Direction Select
107 * ENACMD12[2] : Auto CMD12 Enable
108 * ENBLKCNT[1] : Block Count Enable
109 * ENDMA[0] : DMA Enable
111 mode
= (TEGRA_MMC_TRNMOD_DMA_ENABLE
|
112 TEGRA_MMC_TRNMOD_BLOCK_COUNT_ENABLE
);
114 if (data
->blocks
> 1)
115 mode
|= TEGRA_MMC_TRNMOD_MULTI_BLOCK_SELECT
;
117 if (data
->flags
& MMC_DATA_READ
)
118 mode
|= TEGRA_MMC_TRNMOD_DATA_XFER_DIR_SEL_READ
;
120 writew(mode
, &priv
->reg
->trnmod
);
123 static int tegra_mmc_wait_inhibit(struct tegra_mmc_priv
*priv
,
125 struct mmc_data
*data
,
126 unsigned int timeout
)
130 * CMDINHDAT[1] : Command Inhibit (DAT)
131 * CMDINHCMD[0] : Command Inhibit (CMD)
133 unsigned int mask
= TEGRA_MMC_PRNSTS_CMD_INHIBIT_CMD
;
136 * We shouldn't wait for data inhibit for stop commands, even
137 * though they might use busy signaling
139 if ((data
== NULL
) && (cmd
->resp_type
& MMC_RSP_BUSY
))
140 mask
|= TEGRA_MMC_PRNSTS_CMD_INHIBIT_DAT
;
142 while (readl(&priv
->reg
->prnsts
) & mask
) {
144 printf("%s: timeout error\n", __func__
);
154 static int tegra_mmc_send_cmd_bounced(struct mmc
*mmc
, struct mmc_cmd
*cmd
,
155 struct mmc_data
*data
,
156 struct bounce_buffer
*bbstate
)
158 struct tegra_mmc_priv
*priv
= mmc
->priv
;
161 unsigned int mask
= 0;
162 unsigned int retry
= 0x100000;
163 debug(" mmc_send_cmd called\n");
165 result
= tegra_mmc_wait_inhibit(priv
, cmd
, data
, 10 /* ms */);
171 tegra_mmc_prepare_data(priv
, data
, bbstate
);
173 debug("cmd->arg: %08x\n", cmd
->cmdarg
);
174 writel(cmd
->cmdarg
, &priv
->reg
->argument
);
177 tegra_mmc_set_transfer_mode(priv
, data
);
179 if ((cmd
->resp_type
& MMC_RSP_136
) && (cmd
->resp_type
& MMC_RSP_BUSY
))
184 * CMDIDX[13:8] : Command index
185 * DATAPRNT[5] : Data Present Select
186 * ENCMDIDX[4] : Command Index Check Enable
187 * ENCMDCRC[3] : Command CRC Check Enable
192 * 11 = Length 48 Check busy after response
194 if (!(cmd
->resp_type
& MMC_RSP_PRESENT
))
195 flags
= TEGRA_MMC_CMDREG_RESP_TYPE_SELECT_NO_RESPONSE
;
196 else if (cmd
->resp_type
& MMC_RSP_136
)
197 flags
= TEGRA_MMC_CMDREG_RESP_TYPE_SELECT_LENGTH_136
;
198 else if (cmd
->resp_type
& MMC_RSP_BUSY
)
199 flags
= TEGRA_MMC_CMDREG_RESP_TYPE_SELECT_LENGTH_48_BUSY
;
201 flags
= TEGRA_MMC_CMDREG_RESP_TYPE_SELECT_LENGTH_48
;
203 if (cmd
->resp_type
& MMC_RSP_CRC
)
204 flags
|= TEGRA_MMC_TRNMOD_CMD_CRC_CHECK
;
205 if (cmd
->resp_type
& MMC_RSP_OPCODE
)
206 flags
|= TEGRA_MMC_TRNMOD_CMD_INDEX_CHECK
;
208 flags
|= TEGRA_MMC_TRNMOD_DATA_PRESENT_SELECT_DATA_TRANSFER
;
210 debug("cmd: %d\n", cmd
->cmdidx
);
212 writew((cmd
->cmdidx
<< 8) | flags
, &priv
->reg
->cmdreg
);
214 for (i
= 0; i
< retry
; i
++) {
215 mask
= readl(&priv
->reg
->norintsts
);
216 /* Command Complete */
217 if (mask
& TEGRA_MMC_NORINTSTS_CMD_COMPLETE
) {
219 writel(mask
, &priv
->reg
->norintsts
);
225 printf("%s: waiting for status update\n", __func__
);
226 writel(mask
, &priv
->reg
->norintsts
);
230 if (mask
& TEGRA_MMC_NORINTSTS_CMD_TIMEOUT
) {
232 debug("timeout: %08x cmd %d\n", mask
, cmd
->cmdidx
);
233 writel(mask
, &priv
->reg
->norintsts
);
235 } else if (mask
& TEGRA_MMC_NORINTSTS_ERR_INTERRUPT
) {
236 /* Error Interrupt */
237 debug("error: %08x cmd %d\n", mask
, cmd
->cmdidx
);
238 writel(mask
, &priv
->reg
->norintsts
);
242 if (cmd
->resp_type
& MMC_RSP_PRESENT
) {
243 if (cmd
->resp_type
& MMC_RSP_136
) {
244 /* CRC is stripped so we need to do some shifting. */
245 for (i
= 0; i
< 4; i
++) {
246 unsigned long offset
= (unsigned long)
247 (&priv
->reg
->rspreg3
- i
);
248 cmd
->response
[i
] = readl(offset
) << 8;
254 debug("cmd->resp[%d]: %08x\n",
255 i
, cmd
->response
[i
]);
257 } else if (cmd
->resp_type
& MMC_RSP_BUSY
) {
258 for (i
= 0; i
< retry
; i
++) {
259 /* PRNTDATA[23:20] : DAT[3:0] Line Signal */
260 if (readl(&priv
->reg
->prnsts
)
261 & (1 << 20)) /* DAT[0] */
266 printf("%s: card is still busy\n", __func__
);
267 writel(mask
, &priv
->reg
->norintsts
);
271 cmd
->response
[0] = readl(&priv
->reg
->rspreg0
);
272 debug("cmd->resp[0]: %08x\n", cmd
->response
[0]);
274 cmd
->response
[0] = readl(&priv
->reg
->rspreg0
);
275 debug("cmd->resp[0]: %08x\n", cmd
->response
[0]);
280 unsigned long start
= get_timer(0);
283 mask
= readl(&priv
->reg
->norintsts
);
285 if (mask
& TEGRA_MMC_NORINTSTS_ERR_INTERRUPT
) {
286 /* Error Interrupt */
287 writel(mask
, &priv
->reg
->norintsts
);
288 printf("%s: error during transfer: 0x%08x\n",
291 } else if (mask
& TEGRA_MMC_NORINTSTS_DMA_INTERRUPT
) {
293 * DMA Interrupt, restart the transfer where
294 * it was interrupted.
296 unsigned int address
= readl(&priv
->reg
->sysad
);
299 writel(TEGRA_MMC_NORINTSTS_DMA_INTERRUPT
,
300 &priv
->reg
->norintsts
);
301 writel(address
, &priv
->reg
->sysad
);
302 } else if (mask
& TEGRA_MMC_NORINTSTS_XFER_COMPLETE
) {
303 /* Transfer Complete */
304 debug("r/w is done\n");
306 } else if (get_timer(start
) > 8000UL) {
307 writel(mask
, &priv
->reg
->norintsts
);
308 printf("%s: MMC Timeout\n"
309 " Interrupt status 0x%08x\n"
310 " Interrupt status enable 0x%08x\n"
311 " Interrupt signal enable 0x%08x\n"
312 " Present status 0x%08x\n",
314 readl(&priv
->reg
->norintstsen
),
315 readl(&priv
->reg
->norintsigen
),
316 readl(&priv
->reg
->prnsts
));
320 writel(mask
, &priv
->reg
->norintsts
);
327 static int tegra_mmc_send_cmd(struct mmc
*mmc
, struct mmc_cmd
*cmd
,
328 struct mmc_data
*data
)
331 unsigned int bbflags
;
333 struct bounce_buffer bbstate
;
337 if (data
->flags
& MMC_DATA_READ
) {
339 bbflags
= GEN_BB_WRITE
;
341 buf
= (void *)data
->src
;
342 bbflags
= GEN_BB_READ
;
344 len
= data
->blocks
* data
->blocksize
;
346 bounce_buffer_start(&bbstate
, buf
, len
, bbflags
);
349 ret
= tegra_mmc_send_cmd_bounced(mmc
, cmd
, data
, &bbstate
);
352 bounce_buffer_stop(&bbstate
);
357 static void tegra_mmc_change_clock(struct tegra_mmc_priv
*priv
, uint clock
)
362 unsigned long timeout
;
364 debug(" mmc_change_clock called\n");
367 * Change Tegra SDMMCx clock divisor here. Source is PLLP_OUT0
372 rate
= clk_set_rate(&priv
->clk
, clock
);
373 div
= (rate
+ clock
- 1) / clock
;
374 debug("div = %d\n", div
);
376 writew(0, &priv
->reg
->clkcon
);
380 * SELFREQ[15:8] : base clock divided by value
381 * ENSDCLK[2] : SD Clock Enable
382 * STBLINTCLK[1] : Internal Clock Stable
383 * ENINTCLK[0] : Internal Clock Enable
386 clk
= ((div
<< TEGRA_MMC_CLKCON_SDCLK_FREQ_SEL_SHIFT
) |
387 TEGRA_MMC_CLKCON_INTERNAL_CLOCK_ENABLE
);
388 writew(clk
, &priv
->reg
->clkcon
);
392 while (!(readw(&priv
->reg
->clkcon
) &
393 TEGRA_MMC_CLKCON_INTERNAL_CLOCK_STABLE
)) {
395 printf("%s: timeout error\n", __func__
);
402 clk
|= TEGRA_MMC_CLKCON_SD_CLOCK_ENABLE
;
403 writew(clk
, &priv
->reg
->clkcon
);
405 debug("mmc_change_clock: clkcon = %08X\n", clk
);
411 static int tegra_mmc_set_ios(struct mmc
*mmc
)
413 struct tegra_mmc_priv
*priv
= mmc
->priv
;
415 debug(" mmc_set_ios called\n");
417 debug("bus_width: %x, clock: %d\n", mmc
->bus_width
, mmc
->clock
);
419 /* Change clock first */
420 tegra_mmc_change_clock(priv
, mmc
->clock
);
422 ctrl
= readb(&priv
->reg
->hostctl
);
426 * 0 = Depend on WIDE4
432 if (mmc
->bus_width
== 8)
434 else if (mmc
->bus_width
== 4)
439 writeb(ctrl
, &priv
->reg
->hostctl
);
440 debug("mmc_set_ios: hostctl = %08X\n", ctrl
);
445 static void tegra_mmc_pad_init(struct tegra_mmc_priv
*priv
)
447 #if defined(CONFIG_TEGRA30)
450 debug("%s: sdmmc address = %08x\n", __func__
, (unsigned int)priv
->reg
);
452 /* Set the pad drive strength for SDMMC1 or 3 only */
453 if (priv
->reg
!= (void *)0x78000000 &&
454 priv
->reg
!= (void *)0x78000400) {
455 debug("%s: settings are only valid for SDMMC1/SDMMC3!\n",
460 val
= readl(&priv
->reg
->sdmemcmppadctl
);
462 val
|= MEMCOMP_PADCTRL_VREF
;
463 writel(val
, &priv
->reg
->sdmemcmppadctl
);
465 val
= readl(&priv
->reg
->autocalcfg
);
467 val
|= AUTO_CAL_PU_OFFSET
| AUTO_CAL_PD_OFFSET
| AUTO_CAL_ENABLED
;
468 writel(val
, &priv
->reg
->autocalcfg
);
472 static void tegra_mmc_reset(struct tegra_mmc_priv
*priv
, struct mmc
*mmc
)
474 unsigned int timeout
;
475 debug(" mmc_reset called\n");
478 * RSTALL[0] : Software reset for all
482 writeb(TEGRA_MMC_SWRST_SW_RESET_FOR_ALL
, &priv
->reg
->swrst
);
486 /* Wait max 100 ms */
489 /* hw clears the bit when it's done */
490 while (readb(&priv
->reg
->swrst
) & TEGRA_MMC_SWRST_SW_RESET_FOR_ALL
) {
492 printf("%s: timeout error\n", __func__
);
499 /* Set SD bus voltage & enable bus power */
500 tegra_mmc_set_power(priv
, fls(mmc
->cfg
->voltages
) - 1);
501 debug("%s: power control = %02X, host control = %02X\n", __func__
,
502 readb(&priv
->reg
->pwrcon
), readb(&priv
->reg
->hostctl
));
504 /* Make sure SDIO pads are set up */
505 tegra_mmc_pad_init(priv
);
508 static int tegra_mmc_init(struct mmc
*mmc
)
510 struct tegra_mmc_priv
*priv
= mmc
->priv
;
512 debug(" tegra_mmc_init called\n");
514 tegra_mmc_reset(priv
, mmc
);
516 priv
->version
= readw(&priv
->reg
->hcver
);
517 debug("host version = %x\n", priv
->version
);
520 writel(0xffffffff, &priv
->reg
->norintstsen
);
521 writel(0xffffffff, &priv
->reg
->norintsigen
);
523 writeb(0xe, &priv
->reg
->timeoutcon
); /* TMCLK * 2^27 */
525 * NORMAL Interrupt Status Enable Register init
526 * [5] ENSTABUFRDRDY : Buffer Read Ready Status Enable
527 * [4] ENSTABUFWTRDY : Buffer write Ready Status Enable
528 * [3] ENSTADMAINT : DMA boundary interrupt
529 * [1] ENSTASTANSCMPLT : Transfre Complete Status Enable
530 * [0] ENSTACMDCMPLT : Command Complete Status Enable
532 mask
= readl(&priv
->reg
->norintstsen
);
534 mask
|= (TEGRA_MMC_NORINTSTSEN_CMD_COMPLETE
|
535 TEGRA_MMC_NORINTSTSEN_XFER_COMPLETE
|
536 TEGRA_MMC_NORINTSTSEN_DMA_INTERRUPT
|
537 TEGRA_MMC_NORINTSTSEN_BUFFER_WRITE_READY
|
538 TEGRA_MMC_NORINTSTSEN_BUFFER_READ_READY
);
539 writel(mask
, &priv
->reg
->norintstsen
);
542 * NORMAL Interrupt Signal Enable Register init
543 * [1] ENSTACMDCMPLT : Transfer Complete Signal Enable
545 mask
= readl(&priv
->reg
->norintsigen
);
547 mask
|= TEGRA_MMC_NORINTSIGEN_XFER_COMPLETE
;
548 writel(mask
, &priv
->reg
->norintsigen
);
553 static int tegra_mmc_getcd(struct mmc
*mmc
)
555 struct tegra_mmc_priv
*priv
= mmc
->priv
;
557 debug("tegra_mmc_getcd called\n");
559 if (dm_gpio_is_valid(&priv
->cd_gpio
))
560 return dm_gpio_get_value(&priv
->cd_gpio
);
565 static const struct mmc_ops tegra_mmc_ops
= {
566 .send_cmd
= tegra_mmc_send_cmd
,
567 .set_ios
= tegra_mmc_set_ios
,
568 .init
= tegra_mmc_init
,
569 .getcd
= tegra_mmc_getcd
,
572 static int tegra_mmc_probe(struct udevice
*dev
)
574 struct mmc_uclass_priv
*upriv
= dev_get_uclass_priv(dev
);
575 struct tegra_mmc_priv
*priv
= dev_get_priv(dev
);
578 priv
->cfg
.name
= "Tegra SD/MMC";
579 priv
->cfg
.ops
= &tegra_mmc_ops
;
581 bus_width
= fdtdec_get_int(gd
->fdt_blob
, dev_of_offset(dev
),
584 priv
->cfg
.voltages
= MMC_VDD_32_33
| MMC_VDD_33_34
| MMC_VDD_165_195
;
585 priv
->cfg
.host_caps
= 0;
587 priv
->cfg
.host_caps
|= MMC_MODE_8BIT
;
589 priv
->cfg
.host_caps
|= MMC_MODE_4BIT
;
590 priv
->cfg
.host_caps
|= MMC_MODE_HS_52MHz
| MMC_MODE_HS
;
593 * min freq is for card identification, and is the highest
594 * low-speed SDIO card frequency (actually 400KHz)
595 * max freq is highest HS eMMC clock as per the SD/MMC spec
598 priv
->cfg
.f_min
= 375000;
599 priv
->cfg
.f_max
= 48000000;
601 priv
->cfg
.b_max
= CONFIG_SYS_MMC_MAX_BLK_COUNT
;
603 priv
->reg
= (void *)dev_get_addr(dev
);
605 ret
= reset_get_by_name(dev
, "sdhci", &priv
->reset_ctl
);
607 debug("reset_get_by_name() failed: %d\n", ret
);
610 ret
= clk_get_by_index(dev
, 0, &priv
->clk
);
612 debug("clk_get_by_index() failed: %d\n", ret
);
616 ret
= reset_assert(&priv
->reset_ctl
);
619 ret
= clk_enable(&priv
->clk
);
622 ret
= clk_set_rate(&priv
->clk
, 20000000);
623 if (IS_ERR_VALUE(ret
))
625 ret
= reset_deassert(&priv
->reset_ctl
);
629 /* These GPIOs are optional */
630 gpio_request_by_name(dev
, "cd-gpios", 0, &priv
->cd_gpio
,
632 gpio_request_by_name(dev
, "wp-gpios", 0, &priv
->wp_gpio
,
634 gpio_request_by_name(dev
, "power-gpios", 0,
635 &priv
->pwr_gpio
, GPIOD_IS_OUT
);
636 if (dm_gpio_is_valid(&priv
->pwr_gpio
))
637 dm_gpio_set_value(&priv
->pwr_gpio
, 1);
639 priv
->mmc
= mmc_create(&priv
->cfg
, priv
);
640 if (priv
->mmc
== NULL
)
643 priv
->mmc
->dev
= dev
;
644 upriv
->mmc
= priv
->mmc
;
649 static const struct udevice_id tegra_mmc_ids
[] = {
650 { .compatible
= "nvidia,tegra20-sdhci" },
651 { .compatible
= "nvidia,tegra30-sdhci" },
652 { .compatible
= "nvidia,tegra114-sdhci" },
653 { .compatible
= "nvidia,tegra124-sdhci" },
654 { .compatible
= "nvidia,tegra210-sdhci" },
655 { .compatible
= "nvidia,tegra186-sdhci" },
659 U_BOOT_DRIVER(tegra_mmc_drv
) = {
662 .of_match
= tegra_mmc_ids
,
663 .probe
= tegra_mmc_probe
,
664 .priv_auto_alloc_size
= sizeof(struct tegra_mmc_priv
),