1 // SPDX-License-Identifier: GPL-2.0+
3 * Copyright 2007, 2010-2011 Freescale Semiconductor, Inc
4 * Copyright 2019 NXP Semiconductors
7 * Based vaguely on the pxa mmc code:
9 * Kyle Harris, Nexus Technologies, Inc. kharris@nexus-tech.net
21 #include <fsl_esdhc.h>
22 #include <fdt_support.h>
25 #include <dm/device_compat.h>
27 DECLARE_GLOBAL_DATA_PTR
;
30 uint dsaddr
; /* SDMA system address register */
31 uint blkattr
; /* Block attributes register */
32 uint cmdarg
; /* Command argument register */
33 uint xfertyp
; /* Transfer type register */
34 uint cmdrsp0
; /* Command response 0 register */
35 uint cmdrsp1
; /* Command response 1 register */
36 uint cmdrsp2
; /* Command response 2 register */
37 uint cmdrsp3
; /* Command response 3 register */
38 uint datport
; /* Buffer data port register */
39 uint prsstat
; /* Present state register */
40 uint proctl
; /* Protocol control register */
41 uint sysctl
; /* System Control Register */
42 uint irqstat
; /* Interrupt status register */
43 uint irqstaten
; /* Interrupt status enable register */
44 uint irqsigen
; /* Interrupt signal enable register */
45 uint autoc12err
; /* Auto CMD error status register */
46 uint hostcapblt
; /* Host controller capabilities register */
47 uint wml
; /* Watermark level register */
48 char reserved1
[8]; /* reserved */
49 uint fevt
; /* Force event register */
50 uint admaes
; /* ADMA error status register */
51 uint adsaddr
; /* ADMA system address register */
53 uint hostver
; /* Host controller version register */
54 char reserved3
[4]; /* reserved */
55 uint dmaerraddr
; /* DMA error address register */
56 char reserved4
[4]; /* reserved */
57 uint dmaerrattr
; /* DMA error attribute register */
58 char reserved5
[4]; /* reserved */
59 uint hostcapblt2
; /* Host controller capabilities register 2 */
60 char reserved6
[756]; /* reserved */
61 uint esdhcctl
; /* eSDHC control register */
64 struct fsl_esdhc_plat
{
65 struct mmc_config cfg
;
70 * struct fsl_esdhc_priv
72 * @esdhc_regs: registers of the sdhc controller
73 * @sdhc_clk: Current clk of the sdhc controller
74 * @bus_width: bus width, 1bit, 4bit or 8bit
77 * Following is used when Driver Model is enabled for MMC
78 * @dev: pointer for the device
79 * @cd_gpio: gpio for card detection
80 * @wp_gpio: gpio for write protection
82 struct fsl_esdhc_priv
{
83 struct fsl_esdhc
*esdhc_regs
;
84 unsigned int sdhc_clk
;
87 #if !CONFIG_IS_ENABLED(DM_MMC)
93 /* Return the XFERTYP flags for a given command and data packet */
94 static uint
esdhc_xfertyp(struct mmc_cmd
*cmd
, struct mmc_data
*data
)
99 xfertyp
|= XFERTYP_DPSEL
;
100 #ifndef CONFIG_SYS_FSL_ESDHC_USE_PIO
101 xfertyp
|= XFERTYP_DMAEN
;
103 if (data
->blocks
> 1) {
104 xfertyp
|= XFERTYP_MSBSEL
;
105 xfertyp
|= XFERTYP_BCEN
;
106 #ifdef CONFIG_SYS_FSL_ERRATUM_ESDHC111
107 xfertyp
|= XFERTYP_AC12EN
;
111 if (data
->flags
& MMC_DATA_READ
)
112 xfertyp
|= XFERTYP_DTDSEL
;
115 if (cmd
->resp_type
& MMC_RSP_CRC
)
116 xfertyp
|= XFERTYP_CCCEN
;
117 if (cmd
->resp_type
& MMC_RSP_OPCODE
)
118 xfertyp
|= XFERTYP_CICEN
;
119 if (cmd
->resp_type
& MMC_RSP_136
)
120 xfertyp
|= XFERTYP_RSPTYP_136
;
121 else if (cmd
->resp_type
& MMC_RSP_BUSY
)
122 xfertyp
|= XFERTYP_RSPTYP_48_BUSY
;
123 else if (cmd
->resp_type
& MMC_RSP_PRESENT
)
124 xfertyp
|= XFERTYP_RSPTYP_48
;
126 if (cmd
->cmdidx
== MMC_CMD_STOP_TRANSMISSION
)
127 xfertyp
|= XFERTYP_CMDTYP_ABORT
;
129 return XFERTYP_CMD(cmd
->cmdidx
) | xfertyp
;
132 #ifdef CONFIG_SYS_FSL_ESDHC_USE_PIO
134 * PIO Read/Write Mode reduce the performace as DMA is not used in this mode.
136 static void esdhc_pio_read_write(struct fsl_esdhc_priv
*priv
,
137 struct mmc_data
*data
)
139 struct fsl_esdhc
*regs
= priv
->esdhc_regs
;
147 if (data
->flags
& MMC_DATA_READ
) {
148 blocks
= data
->blocks
;
151 start
= get_timer(0);
152 size
= data
->blocksize
;
153 irqstat
= esdhc_read32(®s
->irqstat
);
154 while (!(esdhc_read32(®s
->prsstat
) & PRSSTAT_BREN
)) {
155 if (get_timer(start
) > PIO_TIMEOUT
) {
156 printf("\nData Read Failed in PIO Mode.");
160 while (size
&& (!(irqstat
& IRQSTAT_TC
))) {
161 udelay(100); /* Wait before last byte transfer complete */
162 irqstat
= esdhc_read32(®s
->irqstat
);
163 databuf
= in_le32(®s
->datport
);
164 *((uint
*)buffer
) = databuf
;
171 blocks
= data
->blocks
;
172 buffer
= (char *)data
->src
;
174 start
= get_timer(0);
175 size
= data
->blocksize
;
176 irqstat
= esdhc_read32(®s
->irqstat
);
177 while (!(esdhc_read32(®s
->prsstat
) & PRSSTAT_BWEN
)) {
178 if (get_timer(start
) > PIO_TIMEOUT
) {
179 printf("\nData Write Failed in PIO Mode.");
183 while (size
&& (!(irqstat
& IRQSTAT_TC
))) {
184 udelay(100); /* Wait before last byte transfer complete */
185 databuf
= *((uint
*)buffer
);
188 irqstat
= esdhc_read32(®s
->irqstat
);
189 out_le32(®s
->datport
, databuf
);
197 static int esdhc_setup_data(struct fsl_esdhc_priv
*priv
, struct mmc
*mmc
,
198 struct mmc_data
*data
)
201 struct fsl_esdhc
*regs
= priv
->esdhc_regs
;
202 #if defined(CONFIG_FSL_LAYERSCAPE)
207 wml_value
= data
->blocksize
/4;
209 if (data
->flags
& MMC_DATA_READ
) {
210 if (wml_value
> WML_RD_WML_MAX
)
211 wml_value
= WML_RD_WML_MAX_VAL
;
213 esdhc_clrsetbits32(®s
->wml
, WML_RD_WML_MASK
, wml_value
);
214 #ifndef CONFIG_SYS_FSL_ESDHC_USE_PIO
215 #if defined(CONFIG_FSL_LAYERSCAPE)
216 addr
= virt_to_phys((void *)(data
->dest
));
217 if (upper_32_bits(addr
))
218 printf("Error found for upper 32 bits\n");
220 esdhc_write32(®s
->dsaddr
, lower_32_bits(addr
));
222 esdhc_write32(®s
->dsaddr
, (u32
)data
->dest
);
226 #ifndef CONFIG_SYS_FSL_ESDHC_USE_PIO
227 flush_dcache_range((ulong
)data
->src
,
228 (ulong
)data
->src
+data
->blocks
231 if (wml_value
> WML_WR_WML_MAX
)
232 wml_value
= WML_WR_WML_MAX_VAL
;
234 if (!(esdhc_read32(®s
->prsstat
) & PRSSTAT_WPSPL
)) {
235 printf("Can not write to locked SD card.\n");
239 esdhc_clrsetbits32(®s
->wml
, WML_WR_WML_MASK
,
241 #ifndef CONFIG_SYS_FSL_ESDHC_USE_PIO
242 #if defined(CONFIG_FSL_LAYERSCAPE)
243 addr
= virt_to_phys((void *)(data
->src
));
244 if (upper_32_bits(addr
))
245 printf("Error found for upper 32 bits\n");
247 esdhc_write32(®s
->dsaddr
, lower_32_bits(addr
));
249 esdhc_write32(®s
->dsaddr
, (u32
)data
->src
);
254 esdhc_write32(®s
->blkattr
, data
->blocks
<< 16 | data
->blocksize
);
256 /* Calculate the timeout period for data transactions */
258 * 1)Timeout period = (2^(timeout+13)) SD Clock cycles
259 * 2)Timeout period should be minimum 0.250sec as per SD Card spec
260 * So, Number of SD Clock cycles for 0.25sec should be minimum
261 * (SD Clock/sec * 0.25 sec) SD Clock cycles
262 * = (mmc->clock * 1/4) SD Clock cycles
264 * => (2^(timeout+13)) >= mmc->clock * 1/4
265 * Taking log2 both the sides
266 * => timeout + 13 >= log2(mmc->clock/4)
267 * Rounding up to next power of 2
268 * => timeout + 13 = log2(mmc->clock/4) + 1
269 * => timeout + 13 = fls(mmc->clock/4)
271 * However, the MMC spec "It is strongly recommended for hosts to
272 * implement more than 500ms timeout value even if the card
273 * indicates the 250ms maximum busy length." Even the previous
274 * value of 300ms is known to be insufficient for some cards.
276 * => timeout + 13 = fls(mmc->clock/2)
278 timeout
= fls(mmc
->clock
/2);
287 #ifdef CONFIG_SYS_FSL_ERRATUM_ESDHC_A001
288 if ((timeout
== 4) || (timeout
== 8) || (timeout
== 12))
292 #ifdef ESDHCI_QUIRK_BROKEN_TIMEOUT_VALUE
295 esdhc_clrsetbits32(®s
->sysctl
, SYSCTL_TIMEOUT_MASK
, timeout
<< 16);
300 static void check_and_invalidate_dcache_range
301 (struct mmc_cmd
*cmd
,
302 struct mmc_data
*data
) {
305 unsigned size
= roundup(ARCH_DMA_MINALIGN
,
306 data
->blocks
*data
->blocksize
);
307 #if defined(CONFIG_FSL_LAYERSCAPE)
310 addr
= virt_to_phys((void *)(data
->dest
));
311 if (upper_32_bits(addr
))
312 printf("Error found for upper 32 bits\n");
314 start
= lower_32_bits(addr
);
316 start
= (unsigned)data
->dest
;
319 invalidate_dcache_range(start
, end
);
323 * Sends a command out on the bus. Takes the mmc pointer,
324 * a command pointer, and an optional data pointer.
326 static int esdhc_send_cmd_common(struct fsl_esdhc_priv
*priv
, struct mmc
*mmc
,
327 struct mmc_cmd
*cmd
, struct mmc_data
*data
)
332 u32 flags
= IRQSTAT_CC
| IRQSTAT_CTOE
;
333 struct fsl_esdhc
*regs
= priv
->esdhc_regs
;
336 #ifdef CONFIG_SYS_FSL_ERRATUM_ESDHC111
337 if (cmd
->cmdidx
== MMC_CMD_STOP_TRANSMISSION
)
341 esdhc_write32(®s
->irqstat
, -1);
345 /* Wait for the bus to be idle */
346 while ((esdhc_read32(®s
->prsstat
) & PRSSTAT_CICHB
) ||
347 (esdhc_read32(®s
->prsstat
) & PRSSTAT_CIDHB
))
350 while (esdhc_read32(®s
->prsstat
) & PRSSTAT_DLA
)
353 /* Wait at least 8 SD clock cycles before the next command */
355 * Note: This is way more than 8 cycles, but 1ms seems to
356 * resolve timing issues with some cards
360 /* Set up for a data transfer if we have one */
362 err
= esdhc_setup_data(priv
, mmc
, data
);
366 if (data
->flags
& MMC_DATA_READ
)
367 check_and_invalidate_dcache_range(cmd
, data
);
370 /* Figure out the transfer arguments */
371 xfertyp
= esdhc_xfertyp(cmd
, data
);
374 esdhc_write32(®s
->irqsigen
, 0);
376 /* Send the command */
377 esdhc_write32(®s
->cmdarg
, cmd
->cmdarg
);
378 esdhc_write32(®s
->xfertyp
, xfertyp
);
380 /* Wait for the command to complete */
381 start
= get_timer(0);
382 while (!(esdhc_read32(®s
->irqstat
) & flags
)) {
383 if (get_timer(start
) > 1000) {
389 irqstat
= esdhc_read32(®s
->irqstat
);
391 if (irqstat
& CMD_ERR
) {
396 if (irqstat
& IRQSTAT_CTOE
) {
401 /* Workaround for ESDHC errata ENGcm03648 */
402 if (!data
&& (cmd
->resp_type
& MMC_RSP_BUSY
)) {
405 /* Poll on DATA0 line for cmd with busy signal for 600 ms */
406 while (timeout
> 0 && !(esdhc_read32(®s
->prsstat
) &
413 printf("Timeout waiting for DAT0 to go high!\n");
419 /* Copy the response to the response buffer */
420 if (cmd
->resp_type
& MMC_RSP_136
) {
421 u32 cmdrsp3
, cmdrsp2
, cmdrsp1
, cmdrsp0
;
423 cmdrsp3
= esdhc_read32(®s
->cmdrsp3
);
424 cmdrsp2
= esdhc_read32(®s
->cmdrsp2
);
425 cmdrsp1
= esdhc_read32(®s
->cmdrsp1
);
426 cmdrsp0
= esdhc_read32(®s
->cmdrsp0
);
427 cmd
->response
[0] = (cmdrsp3
<< 8) | (cmdrsp2
>> 24);
428 cmd
->response
[1] = (cmdrsp2
<< 8) | (cmdrsp1
>> 24);
429 cmd
->response
[2] = (cmdrsp1
<< 8) | (cmdrsp0
>> 24);
430 cmd
->response
[3] = (cmdrsp0
<< 8);
432 cmd
->response
[0] = esdhc_read32(®s
->cmdrsp0
);
434 /* Wait until all of the blocks are transferred */
436 #ifdef CONFIG_SYS_FSL_ESDHC_USE_PIO
437 esdhc_pio_read_write(priv
, data
);
440 irqstat
= esdhc_read32(®s
->irqstat
);
442 if (irqstat
& IRQSTAT_DTOE
) {
447 if (irqstat
& DATA_ERR
) {
451 } while ((irqstat
& DATA_COMPLETE
) != DATA_COMPLETE
);
454 * Need invalidate the dcache here again to avoid any
455 * cache-fill during the DMA operations such as the
456 * speculative pre-fetching etc.
458 if (data
->flags
& MMC_DATA_READ
) {
459 check_and_invalidate_dcache_range(cmd
, data
);
465 /* Reset CMD and DATA portions on error */
467 esdhc_write32(®s
->sysctl
, esdhc_read32(®s
->sysctl
) |
469 while (esdhc_read32(®s
->sysctl
) & SYSCTL_RSTC
)
473 esdhc_write32(®s
->sysctl
,
474 esdhc_read32(®s
->sysctl
) |
476 while ((esdhc_read32(®s
->sysctl
) & SYSCTL_RSTD
))
481 esdhc_write32(®s
->irqstat
, -1);
486 static void set_sysctl(struct fsl_esdhc_priv
*priv
, struct mmc
*mmc
, uint clock
)
488 struct fsl_esdhc
*regs
= priv
->esdhc_regs
;
491 unsigned int sdhc_clk
= priv
->sdhc_clk
;
496 if (clock
< mmc
->cfg
->f_min
)
497 clock
= mmc
->cfg
->f_min
;
499 while (sdhc_clk
/ (16 * pre_div
) > clock
&& pre_div
< 256)
502 while (sdhc_clk
/ (div
* pre_div
) > clock
&& div
< 16)
508 clk
= (pre_div
<< 8) | (div
<< 4);
510 esdhc_clrbits32(®s
->sysctl
, SYSCTL_CKEN
);
512 esdhc_clrsetbits32(®s
->sysctl
, SYSCTL_CLOCK_MASK
, clk
);
515 value
= PRSSTAT_SDSTB
;
516 while (!(esdhc_read32(®s
->prsstat
) & value
)) {
518 printf("fsl_esdhc: Internal clock never stabilised.\n");
525 esdhc_setbits32(®s
->sysctl
, SYSCTL_PEREN
| SYSCTL_CKEN
);
528 static void esdhc_clock_control(struct fsl_esdhc_priv
*priv
, bool enable
)
530 struct fsl_esdhc
*regs
= priv
->esdhc_regs
;
534 value
= esdhc_read32(®s
->sysctl
);
537 value
|= SYSCTL_CKEN
;
539 value
&= ~SYSCTL_CKEN
;
541 esdhc_write32(®s
->sysctl
, value
);
544 value
= PRSSTAT_SDSTB
;
545 while (!(esdhc_read32(®s
->prsstat
) & value
)) {
547 printf("fsl_esdhc: Internal clock never stabilised.\n");
555 static int esdhc_set_ios_common(struct fsl_esdhc_priv
*priv
, struct mmc
*mmc
)
557 struct fsl_esdhc
*regs
= priv
->esdhc_regs
;
559 if (priv
->is_sdhc_per_clk
) {
560 /* Select to use peripheral clock */
561 esdhc_clock_control(priv
, false);
562 esdhc_setbits32(®s
->esdhcctl
, ESDHCCTL_PCS
);
563 esdhc_clock_control(priv
, true);
566 /* Set the clock speed */
567 if (priv
->clock
!= mmc
->clock
)
568 set_sysctl(priv
, mmc
, mmc
->clock
);
570 /* Set the bus width */
571 esdhc_clrbits32(®s
->proctl
, PROCTL_DTW_4
| PROCTL_DTW_8
);
573 if (mmc
->bus_width
== 4)
574 esdhc_setbits32(®s
->proctl
, PROCTL_DTW_4
);
575 else if (mmc
->bus_width
== 8)
576 esdhc_setbits32(®s
->proctl
, PROCTL_DTW_8
);
581 static void esdhc_enable_cache_snooping(struct fsl_esdhc
*regs
)
583 #ifdef CONFIG_ARCH_MPC830X
584 immap_t
*immr
= (immap_t
*)CONFIG_SYS_IMMR
;
585 sysconf83xx_t
*sysconf
= &immr
->sysconf
;
587 setbits_be32(&sysconf
->sdhccr
, 0x02000000);
589 esdhc_write32(®s
->esdhcctl
, 0x00000040);
593 static int esdhc_init_common(struct fsl_esdhc_priv
*priv
, struct mmc
*mmc
)
595 struct fsl_esdhc
*regs
= priv
->esdhc_regs
;
598 /* Reset the entire host controller */
599 esdhc_setbits32(®s
->sysctl
, SYSCTL_RSTA
);
601 /* Wait until the controller is available */
602 start
= get_timer(0);
603 while ((esdhc_read32(®s
->sysctl
) & SYSCTL_RSTA
)) {
604 if (get_timer(start
) > 1000)
608 esdhc_enable_cache_snooping(regs
);
610 esdhc_setbits32(®s
->sysctl
, SYSCTL_HCKEN
| SYSCTL_IPGEN
);
612 /* Set the initial clock speed */
613 mmc_set_clock(mmc
, 400000, MMC_CLK_ENABLE
);
615 /* Disable the BRR and BWR bits in IRQSTAT */
616 esdhc_clrbits32(®s
->irqstaten
, IRQSTATEN_BRR
| IRQSTATEN_BWR
);
618 /* Put the PROCTL reg back to the default */
619 esdhc_write32(®s
->proctl
, PROCTL_INIT
);
621 /* Set timout to the maximum value */
622 esdhc_clrsetbits32(®s
->sysctl
, SYSCTL_TIMEOUT_MASK
, 14 << 16);
627 static int esdhc_getcd_common(struct fsl_esdhc_priv
*priv
)
629 struct fsl_esdhc
*regs
= priv
->esdhc_regs
;
632 #ifdef CONFIG_ESDHC_DETECT_QUIRK
633 if (CONFIG_ESDHC_DETECT_QUIRK
)
636 while (!(esdhc_read32(®s
->prsstat
) & PRSSTAT_CINS
) && --timeout
)
642 static void fsl_esdhc_get_cfg_common(struct fsl_esdhc_priv
*priv
,
643 struct mmc_config
*cfg
)
645 struct fsl_esdhc
*regs
= priv
->esdhc_regs
;
648 caps
= esdhc_read32(®s
->hostcapblt
);
649 #ifdef CONFIG_SYS_FSL_ERRATUM_ESDHC135
650 caps
&= ~(HOSTCAPBLT_SRS
| HOSTCAPBLT_VS18
| HOSTCAPBLT_VS30
);
652 #ifdef CONFIG_SYS_FSL_MMC_HAS_CAPBLT_VS33
653 caps
|= HOSTCAPBLT_VS33
;
655 if (caps
& HOSTCAPBLT_VS18
)
656 cfg
->voltages
|= MMC_VDD_165_195
;
657 if (caps
& HOSTCAPBLT_VS30
)
658 cfg
->voltages
|= MMC_VDD_29_30
| MMC_VDD_30_31
;
659 if (caps
& HOSTCAPBLT_VS33
)
660 cfg
->voltages
|= MMC_VDD_32_33
| MMC_VDD_33_34
;
662 cfg
->name
= "FSL_SDHC";
664 if (caps
& HOSTCAPBLT_HSS
)
665 cfg
->host_caps
|= MMC_MODE_HS_52MHz
| MMC_MODE_HS
;
668 cfg
->f_max
= min(priv
->sdhc_clk
, (u32
)200000000);
669 cfg
->b_max
= CONFIG_SYS_MMC_MAX_BLK_COUNT
;
672 #ifdef CONFIG_FSL_ESDHC_ADAPTER_IDENT
673 void mmc_adapter_card_type_ident(void)
678 card_id
= QIXIS_READ(present
) & QIXIS_SDID_MASK
;
679 gd
->arch
.sdhc_adapter
= card_id
;
682 case QIXIS_ESDHC_ADAPTER_TYPE_EMMC45
:
683 value
= QIXIS_READ(brdcfg
[5]);
684 value
|= (QIXIS_DAT4
| QIXIS_DAT5_6_7
);
685 QIXIS_WRITE(brdcfg
[5], value
);
687 case QIXIS_ESDHC_ADAPTER_TYPE_SDMMC_LEGACY
:
688 value
= QIXIS_READ(pwr_ctl
[1]);
689 value
|= QIXIS_EVDD_BY_SDHC_VS
;
690 QIXIS_WRITE(pwr_ctl
[1], value
);
692 case QIXIS_ESDHC_ADAPTER_TYPE_EMMC44
:
693 value
= QIXIS_READ(brdcfg
[5]);
694 value
|= (QIXIS_SDCLKIN
| QIXIS_SDCLKOUT
);
695 QIXIS_WRITE(brdcfg
[5], value
);
697 case QIXIS_ESDHC_ADAPTER_TYPE_RSV
:
699 case QIXIS_ESDHC_ADAPTER_TYPE_MMC
:
701 case QIXIS_ESDHC_ADAPTER_TYPE_SD
:
703 case QIXIS_ESDHC_NO_ADAPTER
:
711 #ifdef CONFIG_OF_LIBFDT
712 __weak
int esdhc_status_fixup(void *blob
, const char *compat
)
714 #ifdef CONFIG_FSL_ESDHC_PIN_MUX
715 if (!hwconfig("esdhc")) {
716 do_fixup_by_compat(blob
, compat
, "status", "disabled",
717 sizeof("disabled"), 1);
724 void fdt_fixup_esdhc(void *blob
, bd_t
*bd
)
726 const char *compat
= "fsl,esdhc";
728 if (esdhc_status_fixup(blob
, compat
))
731 do_fixup_by_compat_u32(blob
, compat
, "clock-frequency",
732 gd
->arch
.sdhc_clk
, 1);
736 #if !CONFIG_IS_ENABLED(DM_MMC)
737 static int esdhc_getcd(struct mmc
*mmc
)
739 struct fsl_esdhc_priv
*priv
= mmc
->priv
;
741 return esdhc_getcd_common(priv
);
744 static int esdhc_init(struct mmc
*mmc
)
746 struct fsl_esdhc_priv
*priv
= mmc
->priv
;
748 return esdhc_init_common(priv
, mmc
);
751 static int esdhc_send_cmd(struct mmc
*mmc
, struct mmc_cmd
*cmd
,
752 struct mmc_data
*data
)
754 struct fsl_esdhc_priv
*priv
= mmc
->priv
;
756 return esdhc_send_cmd_common(priv
, mmc
, cmd
, data
);
759 static int esdhc_set_ios(struct mmc
*mmc
)
761 struct fsl_esdhc_priv
*priv
= mmc
->priv
;
763 return esdhc_set_ios_common(priv
, mmc
);
766 static const struct mmc_ops esdhc_ops
= {
767 .getcd
= esdhc_getcd
,
769 .send_cmd
= esdhc_send_cmd
,
770 .set_ios
= esdhc_set_ios
,
773 int fsl_esdhc_initialize(bd_t
*bis
, struct fsl_esdhc_cfg
*cfg
)
775 struct fsl_esdhc_plat
*plat
;
776 struct fsl_esdhc_priv
*priv
;
777 struct mmc_config
*mmc_cfg
;
783 priv
= calloc(sizeof(struct fsl_esdhc_priv
), 1);
786 plat
= calloc(sizeof(struct fsl_esdhc_plat
), 1);
792 priv
->esdhc_regs
= (struct fsl_esdhc
*)(unsigned long)(cfg
->esdhc_base
);
793 priv
->sdhc_clk
= cfg
->sdhc_clk
;
794 if (gd
->arch
.sdhc_per_clk
)
795 priv
->is_sdhc_per_clk
= true;
797 mmc_cfg
= &plat
->cfg
;
799 if (cfg
->max_bus_width
== 8) {
800 mmc_cfg
->host_caps
|= MMC_MODE_1BIT
| MMC_MODE_4BIT
|
802 } else if (cfg
->max_bus_width
== 4) {
803 mmc_cfg
->host_caps
|= MMC_MODE_1BIT
| MMC_MODE_4BIT
;
804 } else if (cfg
->max_bus_width
== 1) {
805 mmc_cfg
->host_caps
|= MMC_MODE_1BIT
;
807 mmc_cfg
->host_caps
|= MMC_MODE_1BIT
| MMC_MODE_4BIT
|
809 printf("No max bus width provided. Assume 8-bit supported.\n");
812 #ifdef CONFIG_ESDHC_DETECT_8_BIT_QUIRK
813 if (CONFIG_ESDHC_DETECT_8_BIT_QUIRK
)
814 mmc_cfg
->host_caps
&= ~MMC_MODE_8BIT
;
816 mmc_cfg
->ops
= &esdhc_ops
;
818 fsl_esdhc_get_cfg_common(priv
, mmc_cfg
);
820 mmc
= mmc_create(mmc_cfg
, priv
);
828 int fsl_esdhc_mmc_init(bd_t
*bis
)
830 struct fsl_esdhc_cfg
*cfg
;
832 cfg
= calloc(sizeof(struct fsl_esdhc_cfg
), 1);
833 cfg
->esdhc_base
= CONFIG_SYS_FSL_ESDHC_ADDR
;
834 /* Prefer peripheral clock which provides higher frequency. */
835 if (gd
->arch
.sdhc_per_clk
)
836 cfg
->sdhc_clk
= gd
->arch
.sdhc_per_clk
;
838 cfg
->sdhc_clk
= gd
->arch
.sdhc_clk
;
839 return fsl_esdhc_initialize(bis
, cfg
);
842 static int fsl_esdhc_probe(struct udevice
*dev
)
844 struct mmc_uclass_priv
*upriv
= dev_get_uclass_priv(dev
);
845 struct fsl_esdhc_plat
*plat
= dev_get_platdata(dev
);
846 struct fsl_esdhc_priv
*priv
= dev_get_priv(dev
);
850 addr
= dev_read_addr(dev
);
851 if (addr
== FDT_ADDR_T_NONE
)
854 priv
->esdhc_regs
= (struct fsl_esdhc
*)lower_32_bits(addr
);
856 priv
->esdhc_regs
= (struct fsl_esdhc
*)addr
;
860 if (gd
->arch
.sdhc_per_clk
) {
861 priv
->sdhc_clk
= gd
->arch
.sdhc_per_clk
;
862 priv
->is_sdhc_per_clk
= true;
864 priv
->sdhc_clk
= gd
->arch
.sdhc_clk
;
867 if (priv
->sdhc_clk
<= 0) {
868 dev_err(dev
, "Unable to get clk for %s\n", dev
->name
);
872 fsl_esdhc_get_cfg_common(priv
, &plat
->cfg
);
874 mmc_of_parse(dev
, &plat
->cfg
);
877 mmc
->cfg
= &plat
->cfg
;
882 return esdhc_init_common(priv
, mmc
);
885 static int fsl_esdhc_get_cd(struct udevice
*dev
)
887 struct fsl_esdhc_plat
*plat
= dev_get_platdata(dev
);
888 struct fsl_esdhc_priv
*priv
= dev_get_priv(dev
);
890 if (plat
->cfg
.host_caps
& MMC_CAP_NONREMOVABLE
)
893 return esdhc_getcd_common(priv
);
896 static int fsl_esdhc_send_cmd(struct udevice
*dev
, struct mmc_cmd
*cmd
,
897 struct mmc_data
*data
)
899 struct fsl_esdhc_plat
*plat
= dev_get_platdata(dev
);
900 struct fsl_esdhc_priv
*priv
= dev_get_priv(dev
);
902 return esdhc_send_cmd_common(priv
, &plat
->mmc
, cmd
, data
);
905 static int fsl_esdhc_set_ios(struct udevice
*dev
)
907 struct fsl_esdhc_plat
*plat
= dev_get_platdata(dev
);
908 struct fsl_esdhc_priv
*priv
= dev_get_priv(dev
);
910 return esdhc_set_ios_common(priv
, &plat
->mmc
);
913 static const struct dm_mmc_ops fsl_esdhc_ops
= {
914 .get_cd
= fsl_esdhc_get_cd
,
915 .send_cmd
= fsl_esdhc_send_cmd
,
916 .set_ios
= fsl_esdhc_set_ios
,
917 #ifdef MMC_SUPPORTS_TUNING
918 .execute_tuning
= fsl_esdhc_execute_tuning
,
922 static const struct udevice_id fsl_esdhc_ids
[] = {
923 { .compatible
= "fsl,esdhc", },
927 static int fsl_esdhc_bind(struct udevice
*dev
)
929 struct fsl_esdhc_plat
*plat
= dev_get_platdata(dev
);
931 return mmc_bind(dev
, &plat
->mmc
, &plat
->cfg
);
934 U_BOOT_DRIVER(fsl_esdhc
) = {
935 .name
= "fsl-esdhc-mmc",
937 .of_match
= fsl_esdhc_ids
,
938 .ops
= &fsl_esdhc_ops
,
939 .bind
= fsl_esdhc_bind
,
940 .probe
= fsl_esdhc_probe
,
941 .platdata_auto_alloc_size
= sizeof(struct fsl_esdhc_plat
),
942 .priv_auto_alloc_size
= sizeof(struct fsl_esdhc_priv
),