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 int esdhc_init_common(struct fsl_esdhc_priv
*priv
, struct mmc
*mmc
)
583 struct fsl_esdhc
*regs
= priv
->esdhc_regs
;
586 /* Reset the entire host controller */
587 esdhc_setbits32(®s
->sysctl
, SYSCTL_RSTA
);
589 /* Wait until the controller is available */
590 start
= get_timer(0);
591 while ((esdhc_read32(®s
->sysctl
) & SYSCTL_RSTA
)) {
592 if (get_timer(start
) > 1000)
596 /* Enable cache snooping */
597 esdhc_write32(®s
->esdhcctl
, 0x00000040);
599 esdhc_setbits32(®s
->sysctl
, SYSCTL_HCKEN
| SYSCTL_IPGEN
);
601 /* Set the initial clock speed */
602 mmc_set_clock(mmc
, 400000, MMC_CLK_ENABLE
);
604 /* Disable the BRR and BWR bits in IRQSTAT */
605 esdhc_clrbits32(®s
->irqstaten
, IRQSTATEN_BRR
| IRQSTATEN_BWR
);
607 /* Put the PROCTL reg back to the default */
608 esdhc_write32(®s
->proctl
, PROCTL_INIT
);
610 /* Set timout to the maximum value */
611 esdhc_clrsetbits32(®s
->sysctl
, SYSCTL_TIMEOUT_MASK
, 14 << 16);
616 static int esdhc_getcd_common(struct fsl_esdhc_priv
*priv
)
618 struct fsl_esdhc
*regs
= priv
->esdhc_regs
;
621 #ifdef CONFIG_ESDHC_DETECT_QUIRK
622 if (CONFIG_ESDHC_DETECT_QUIRK
)
625 while (!(esdhc_read32(®s
->prsstat
) & PRSSTAT_CINS
) && --timeout
)
631 static void fsl_esdhc_get_cfg_common(struct fsl_esdhc_priv
*priv
,
632 struct mmc_config
*cfg
)
634 struct fsl_esdhc
*regs
= priv
->esdhc_regs
;
637 caps
= esdhc_read32(®s
->hostcapblt
);
638 #ifdef CONFIG_SYS_FSL_ERRATUM_ESDHC135
639 caps
&= ~(HOSTCAPBLT_SRS
| HOSTCAPBLT_VS18
| HOSTCAPBLT_VS30
);
641 #ifdef CONFIG_SYS_FSL_MMC_HAS_CAPBLT_VS33
642 caps
|= HOSTCAPBLT_VS33
;
644 if (caps
& HOSTCAPBLT_VS18
)
645 cfg
->voltages
|= MMC_VDD_165_195
;
646 if (caps
& HOSTCAPBLT_VS30
)
647 cfg
->voltages
|= MMC_VDD_29_30
| MMC_VDD_30_31
;
648 if (caps
& HOSTCAPBLT_VS33
)
649 cfg
->voltages
|= MMC_VDD_32_33
| MMC_VDD_33_34
;
651 cfg
->name
= "FSL_SDHC";
653 if (caps
& HOSTCAPBLT_HSS
)
654 cfg
->host_caps
|= MMC_MODE_HS_52MHz
| MMC_MODE_HS
;
657 cfg
->f_max
= min(priv
->sdhc_clk
, (u32
)200000000);
658 cfg
->b_max
= CONFIG_SYS_MMC_MAX_BLK_COUNT
;
661 #ifdef CONFIG_FSL_ESDHC_ADAPTER_IDENT
662 void mmc_adapter_card_type_ident(void)
667 card_id
= QIXIS_READ(present
) & QIXIS_SDID_MASK
;
668 gd
->arch
.sdhc_adapter
= card_id
;
671 case QIXIS_ESDHC_ADAPTER_TYPE_EMMC45
:
672 value
= QIXIS_READ(brdcfg
[5]);
673 value
|= (QIXIS_DAT4
| QIXIS_DAT5_6_7
);
674 QIXIS_WRITE(brdcfg
[5], value
);
676 case QIXIS_ESDHC_ADAPTER_TYPE_SDMMC_LEGACY
:
677 value
= QIXIS_READ(pwr_ctl
[1]);
678 value
|= QIXIS_EVDD_BY_SDHC_VS
;
679 QIXIS_WRITE(pwr_ctl
[1], value
);
681 case QIXIS_ESDHC_ADAPTER_TYPE_EMMC44
:
682 value
= QIXIS_READ(brdcfg
[5]);
683 value
|= (QIXIS_SDCLKIN
| QIXIS_SDCLKOUT
);
684 QIXIS_WRITE(brdcfg
[5], value
);
686 case QIXIS_ESDHC_ADAPTER_TYPE_RSV
:
688 case QIXIS_ESDHC_ADAPTER_TYPE_MMC
:
690 case QIXIS_ESDHC_ADAPTER_TYPE_SD
:
692 case QIXIS_ESDHC_NO_ADAPTER
:
700 #ifdef CONFIG_OF_LIBFDT
701 __weak
int esdhc_status_fixup(void *blob
, const char *compat
)
703 #ifdef CONFIG_FSL_ESDHC_PIN_MUX
704 if (!hwconfig("esdhc")) {
705 do_fixup_by_compat(blob
, compat
, "status", "disabled",
706 sizeof("disabled"), 1);
713 void fdt_fixup_esdhc(void *blob
, bd_t
*bd
)
715 const char *compat
= "fsl,esdhc";
717 if (esdhc_status_fixup(blob
, compat
))
720 do_fixup_by_compat_u32(blob
, compat
, "clock-frequency",
721 gd
->arch
.sdhc_clk
, 1);
725 #if !CONFIG_IS_ENABLED(DM_MMC)
726 static int esdhc_getcd(struct mmc
*mmc
)
728 struct fsl_esdhc_priv
*priv
= mmc
->priv
;
730 return esdhc_getcd_common(priv
);
733 static int esdhc_init(struct mmc
*mmc
)
735 struct fsl_esdhc_priv
*priv
= mmc
->priv
;
737 return esdhc_init_common(priv
, mmc
);
740 static int esdhc_send_cmd(struct mmc
*mmc
, struct mmc_cmd
*cmd
,
741 struct mmc_data
*data
)
743 struct fsl_esdhc_priv
*priv
= mmc
->priv
;
745 return esdhc_send_cmd_common(priv
, mmc
, cmd
, data
);
748 static int esdhc_set_ios(struct mmc
*mmc
)
750 struct fsl_esdhc_priv
*priv
= mmc
->priv
;
752 return esdhc_set_ios_common(priv
, mmc
);
755 static const struct mmc_ops esdhc_ops
= {
756 .getcd
= esdhc_getcd
,
758 .send_cmd
= esdhc_send_cmd
,
759 .set_ios
= esdhc_set_ios
,
762 int fsl_esdhc_initialize(bd_t
*bis
, struct fsl_esdhc_cfg
*cfg
)
764 struct fsl_esdhc_plat
*plat
;
765 struct fsl_esdhc_priv
*priv
;
766 struct mmc_config
*mmc_cfg
;
772 priv
= calloc(sizeof(struct fsl_esdhc_priv
), 1);
775 plat
= calloc(sizeof(struct fsl_esdhc_plat
), 1);
781 priv
->esdhc_regs
= (struct fsl_esdhc
*)(unsigned long)(cfg
->esdhc_base
);
782 priv
->sdhc_clk
= cfg
->sdhc_clk
;
783 if (gd
->arch
.sdhc_per_clk
)
784 priv
->is_sdhc_per_clk
= true;
786 mmc_cfg
= &plat
->cfg
;
788 if (cfg
->max_bus_width
== 8) {
789 mmc_cfg
->host_caps
|= MMC_MODE_1BIT
| MMC_MODE_4BIT
|
791 } else if (cfg
->max_bus_width
== 4) {
792 mmc_cfg
->host_caps
|= MMC_MODE_1BIT
| MMC_MODE_4BIT
;
793 } else if (cfg
->max_bus_width
== 1) {
794 mmc_cfg
->host_caps
|= MMC_MODE_1BIT
;
796 mmc_cfg
->host_caps
|= MMC_MODE_1BIT
| MMC_MODE_4BIT
|
798 printf("No max bus width provided. Assume 8-bit supported.\n");
801 #ifdef CONFIG_ESDHC_DETECT_8_BIT_QUIRK
802 if (CONFIG_ESDHC_DETECT_8_BIT_QUIRK
)
803 mmc_cfg
->host_caps
&= ~MMC_MODE_8BIT
;
805 mmc_cfg
->ops
= &esdhc_ops
;
807 fsl_esdhc_get_cfg_common(priv
, mmc_cfg
);
809 mmc
= mmc_create(mmc_cfg
, priv
);
817 int fsl_esdhc_mmc_init(bd_t
*bis
)
819 struct fsl_esdhc_cfg
*cfg
;
821 cfg
= calloc(sizeof(struct fsl_esdhc_cfg
), 1);
822 cfg
->esdhc_base
= CONFIG_SYS_FSL_ESDHC_ADDR
;
823 /* Prefer peripheral clock which provides higher frequency. */
824 if (gd
->arch
.sdhc_per_clk
)
825 cfg
->sdhc_clk
= gd
->arch
.sdhc_per_clk
;
827 cfg
->sdhc_clk
= gd
->arch
.sdhc_clk
;
828 return fsl_esdhc_initialize(bis
, cfg
);
831 static int fsl_esdhc_probe(struct udevice
*dev
)
833 struct mmc_uclass_priv
*upriv
= dev_get_uclass_priv(dev
);
834 struct fsl_esdhc_plat
*plat
= dev_get_platdata(dev
);
835 struct fsl_esdhc_priv
*priv
= dev_get_priv(dev
);
839 addr
= dev_read_addr(dev
);
840 if (addr
== FDT_ADDR_T_NONE
)
843 priv
->esdhc_regs
= (struct fsl_esdhc
*)lower_32_bits(addr
);
845 priv
->esdhc_regs
= (struct fsl_esdhc
*)addr
;
849 if (gd
->arch
.sdhc_per_clk
) {
850 priv
->sdhc_clk
= gd
->arch
.sdhc_per_clk
;
851 priv
->is_sdhc_per_clk
= true;
853 priv
->sdhc_clk
= gd
->arch
.sdhc_clk
;
856 if (priv
->sdhc_clk
<= 0) {
857 dev_err(dev
, "Unable to get clk for %s\n", dev
->name
);
861 fsl_esdhc_get_cfg_common(priv
, &plat
->cfg
);
863 mmc_of_parse(dev
, &plat
->cfg
);
866 mmc
->cfg
= &plat
->cfg
;
871 return esdhc_init_common(priv
, mmc
);
874 static int fsl_esdhc_get_cd(struct udevice
*dev
)
876 struct fsl_esdhc_plat
*plat
= dev_get_platdata(dev
);
877 struct fsl_esdhc_priv
*priv
= dev_get_priv(dev
);
879 if (plat
->cfg
.host_caps
& MMC_CAP_NONREMOVABLE
)
882 return esdhc_getcd_common(priv
);
885 static int fsl_esdhc_send_cmd(struct udevice
*dev
, struct mmc_cmd
*cmd
,
886 struct mmc_data
*data
)
888 struct fsl_esdhc_plat
*plat
= dev_get_platdata(dev
);
889 struct fsl_esdhc_priv
*priv
= dev_get_priv(dev
);
891 return esdhc_send_cmd_common(priv
, &plat
->mmc
, cmd
, data
);
894 static int fsl_esdhc_set_ios(struct udevice
*dev
)
896 struct fsl_esdhc_plat
*plat
= dev_get_platdata(dev
);
897 struct fsl_esdhc_priv
*priv
= dev_get_priv(dev
);
899 return esdhc_set_ios_common(priv
, &plat
->mmc
);
902 static const struct dm_mmc_ops fsl_esdhc_ops
= {
903 .get_cd
= fsl_esdhc_get_cd
,
904 .send_cmd
= fsl_esdhc_send_cmd
,
905 .set_ios
= fsl_esdhc_set_ios
,
906 #ifdef MMC_SUPPORTS_TUNING
907 .execute_tuning
= fsl_esdhc_execute_tuning
,
911 static const struct udevice_id fsl_esdhc_ids
[] = {
912 { .compatible
= "fsl,esdhc", },
916 static int fsl_esdhc_bind(struct udevice
*dev
)
918 struct fsl_esdhc_plat
*plat
= dev_get_platdata(dev
);
920 return mmc_bind(dev
, &plat
->mmc
, &plat
->cfg
);
923 U_BOOT_DRIVER(fsl_esdhc
) = {
924 .name
= "fsl-esdhc-mmc",
926 .of_match
= fsl_esdhc_ids
,
927 .ops
= &fsl_esdhc_ops
,
928 .bind
= fsl_esdhc_bind
,
929 .probe
= fsl_esdhc_probe
,
930 .platdata_auto_alloc_size
= sizeof(struct fsl_esdhc_plat
),
931 .priv_auto_alloc_size
= sizeof(struct fsl_esdhc_priv
),