drivers/mmc/fsl_esdhc_imx.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright 2007, 2010-2011 Freescale Semiconductor, Inc
   4  * Copyright 2019, 2021 NXP
   5  * Andy Fleming
   6  * Yangbo Lu <[email protected]>
   7  *
   8  * Based vaguely on the pxa mmc code:
   9  * (C) Copyright 2003
  10  * Kyle Harris, Nexus Technologies, Inc. [email protected]
  11  */
  12
  13 #include <config.h>
  14 #include <common.h>
  15 #include <command.h>
  16 #include <clk.h>
  17 #include <cpu_func.h>
  18 #include <errno.h>
  19 #include <hwconfig.h>
  20 #include <log.h>
  21 #include <mmc.h>
  22 #include <part.h>
  23 #include <asm/cache.h>
  24 #include <asm/global_data.h>
  25 #include <dm/device_compat.h>
  26 #include <linux/bitops.h>
  27 #include <linux/delay.h>
  28 #include <linux/err.h>
  29 #include <power/regulator.h>
  30 #include <malloc.h>
  31 #include <fsl_esdhc_imx.h>
  32 #include <fdt_support.h>
  33 #include <asm/io.h>
  34 #include <dm.h>
  35 #include <asm-generic/gpio.h>
  36 #include <dm/pinctrl.h>
  37 #include <dt-structs.h>
  38 #include <mapmem.h>
  39 #include <dm/ofnode.h>
  40 #include <linux/iopoll.h>
  41
  42 #if !CONFIG_IS_ENABLED(BLK)
  43 #include "mmc_private.h"
  44 #endif
  45
  46 #ifndef ESDHCI_QUIRK_BROKEN_TIMEOUT_VALUE
  47 #ifdef CONFIG_FSL_USDHC
  48 #define ESDHCI_QUIRK_BROKEN_TIMEOUT_VALUE       1
  49 #endif
  50 #endif
  51
  52 DECLARE_GLOBAL_DATA_PTR;
  53
  54 #define SDHCI_IRQ_EN_BITS               (IRQSTATEN_CC | IRQSTATEN_TC | \
  55                                 IRQSTATEN_CINT | \
  56                                 IRQSTATEN_CTOE | IRQSTATEN_CCE | IRQSTATEN_CEBE | \
  57                                 IRQSTATEN_CIE | IRQSTATEN_DTOE | IRQSTATEN_DCE | \
  58                                 IRQSTATEN_DEBE | IRQSTATEN_BRR | IRQSTATEN_BWR | \
  59                                 IRQSTATEN_DINT)
  60 #define MAX_TUNING_LOOP 40
  61 #define ESDHC_DRIVER_STAGE_VALUE 0xffffffff
  62
  63 struct fsl_esdhc {
  64         uint    dsaddr;         /* SDMA system address register */
  65         uint    blkattr;        /* Block attributes register */
  66         uint    cmdarg;         /* Command argument register */
  67         uint    xfertyp;        /* Transfer type register */
  68         uint    cmdrsp0;        /* Command response 0 register */
  69         uint    cmdrsp1;        /* Command response 1 register */
  70         uint    cmdrsp2;        /* Command response 2 register */
  71         uint    cmdrsp3;        /* Command response 3 register */
  72         uint    datport;        /* Buffer data port register */
  73         uint    prsstat;        /* Present state register */
  74         uint    proctl;         /* Protocol control register */
  75         uint    sysctl;         /* System Control Register */
  76         uint    irqstat;        /* Interrupt status register */
  77         uint    irqstaten;      /* Interrupt status enable register */
  78         uint    irqsigen;       /* Interrupt signal enable register */
  79         uint    autoc12err;     /* Auto CMD error status register */
  80         uint    hostcapblt;     /* Host controller capabilities register */
  81         uint    wml;            /* Watermark level register */
  82         uint    mixctrl;        /* For USDHC */
  83         char    reserved1[4];   /* reserved */
  84         uint    fevt;           /* Force event register */
  85         uint    admaes;         /* ADMA error status register */
  86         uint    adsaddr;        /* ADMA system address register */
  87         char    reserved2[4];
  88         uint    dllctrl;
  89         uint    dllstat;
  90         uint    clktunectrlstatus;
  91         char    reserved3[4];
  92         uint    strobe_dllctrl;
  93         uint    strobe_dllstat;
  94         char    reserved4[72];
  95         uint    vendorspec;
  96         uint    mmcboot;
  97         uint    vendorspec2;
  98         uint    tuning_ctrl;    /* on i.MX6/7/8/RT */
  99         char    reserved5[44];
 100         uint    hostver;        /* Host controller version register */
 101         char    reserved6[4];   /* reserved */
 102         uint    dmaerraddr;     /* DMA error address register */
 103         char    reserved7[4];   /* reserved */
 104         uint    dmaerrattr;     /* DMA error attribute register */
 105         char    reserved8[4];   /* reserved */
 106         uint    hostcapblt2;    /* Host controller capabilities register 2 */
 107         char    reserved9[8];   /* reserved */
 108         uint    tcr;            /* Tuning control register */
 109         char    reserved10[28]; /* reserved */
 110         uint    sddirctl;       /* SD direction control register */
 111         char    reserved11[712];/* reserved */
 112         uint    scr;            /* eSDHC control register */
 113 };
 114
 115 struct fsl_esdhc_plat {
 116 #if CONFIG_IS_ENABLED(OF_PLATDATA)
 117         /* Put this first since driver model will copy the data here */
 118         struct dtd_fsl_esdhc dtplat;
 119 #endif
 120
 121         struct mmc_config cfg;
 122         struct mmc mmc;
 123 };
 124
 125 struct esdhc_soc_data {
 126         u32 flags;
 127 };
 128
 129 /**
 130  * struct fsl_esdhc_priv
 131  *
 132  * @esdhc_regs: registers of the sdhc controller
 133  * @sdhc_clk: Current clk of the sdhc controller
 134  * @bus_width: bus width, 1bit, 4bit or 8bit
 135  * @cfg: mmc config
 136  * @mmc: mmc
 137  * Following is used when Driver Model is enabled for MMC
 138  * @dev: pointer for the device
 139  * @non_removable: 0: removable; 1: non-removable
 140  * @broken_cd: 0: use GPIO for card detect; 1: Do not use GPIO for card detect
 141  * @wp_enable: 1: enable checking wp; 0: no check
 142  * @vs18_enable: 1: use 1.8V voltage; 0: use 3.3V
 143  * @flags: ESDHC_FLAG_xx in include/fsl_esdhc_imx.h
 144  * @caps: controller capabilities
 145  * @tuning_step: tuning step setting in tuning_ctrl register
 146  * @start_tuning_tap: the start point for tuning in tuning_ctrl register
 147  * @strobe_dll_delay_target: settings in strobe_dllctrl
 148  * @signal_voltage: indicating the current voltage
 149  * @signal_voltage_switch_extra_delay_ms: extra delay for IO voltage switch
 150  * @cd_gpio: gpio for card detection
 151  * @wp_gpio: gpio for write protection
 152  */
 153 struct fsl_esdhc_priv {
 154         struct fsl_esdhc *esdhc_regs;
 155         unsigned int sdhc_clk;
 156         struct clk per_clk;
 157         unsigned int clock;
 158         unsigned int mode;
 159         unsigned int bus_width;
 160 #if !CONFIG_IS_ENABLED(BLK)
 161         struct mmc *mmc;
 162 #endif
 163         struct udevice *dev;
 164         int non_removable;
 165         int broken_cd;
 166         int wp_enable;
 167         int vs18_enable;
 168         u32 flags;
 169         u32 caps;
 170         u32 tuning_step;
 171         u32 tuning_start_tap;
 172         u32 strobe_dll_delay_target;
 173         u32 signal_voltage;
 174         u32 signal_voltage_switch_extra_delay_ms;
 175 #if CONFIG_IS_ENABLED(DM_REGULATOR)
 176         struct udevice *vqmmc_dev;
 177         struct udevice *vmmc_dev;
 178 #endif
 179 #if CONFIG_IS_ENABLED(DM_GPIO)
 180         struct gpio_desc cd_gpio;
 181         struct gpio_desc wp_gpio;
 182 #endif
 183 };
 184
 185 /* Return the XFERTYP flags for a given command and data packet */
 186 static uint esdhc_xfertyp(struct mmc_cmd *cmd, struct mmc_data *data)
 187 {
 188         uint xfertyp = 0;
 189
 190         if (data) {
 191                 xfertyp |= XFERTYP_DPSEL;
 192 #ifndef CONFIG_SYS_FSL_ESDHC_USE_PIO
 193                 xfertyp |= XFERTYP_DMAEN;
 194 #endif
 195                 if (data->blocks > 1) {
 196                         xfertyp |= XFERTYP_MSBSEL;
 197                         xfertyp |= XFERTYP_BCEN;
 198 #ifdef CONFIG_SYS_FSL_ERRATUM_ESDHC111
 199                         xfertyp |= XFERTYP_AC12EN;
 200 #endif
 201                 }
 202
 203                 if (data->flags & MMC_DATA_READ)
 204                         xfertyp |= XFERTYP_DTDSEL;
 205         }
 206
 207         if (cmd->resp_type & MMC_RSP_CRC)
 208                 xfertyp |= XFERTYP_CCCEN;
 209         if (cmd->resp_type & MMC_RSP_OPCODE)
 210                 xfertyp |= XFERTYP_CICEN;
 211         if (cmd->resp_type & MMC_RSP_136)
 212                 xfertyp |= XFERTYP_RSPTYP_136;
 213         else if (cmd->resp_type & MMC_RSP_BUSY)
 214                 xfertyp |= XFERTYP_RSPTYP_48_BUSY;
 215         else if (cmd->resp_type & MMC_RSP_PRESENT)
 216                 xfertyp |= XFERTYP_RSPTYP_48;
 217
 218         if (cmd->cmdidx == MMC_CMD_STOP_TRANSMISSION)
 219                 xfertyp |= XFERTYP_CMDTYP_ABORT;
 220
 221         return XFERTYP_CMD(cmd->cmdidx) | xfertyp;
 222 }
 223
 224 #ifdef CONFIG_SYS_FSL_ESDHC_USE_PIO
 225 /*
 226  * PIO Read/Write Mode reduce the performace as DMA is not used in this mode.
 227  */
 228 static void esdhc_pio_read_write(struct fsl_esdhc_priv *priv,
 229                                  struct mmc_data *data)
 230 {
 231         struct fsl_esdhc *regs = priv->esdhc_regs;
 232         uint blocks;
 233         char *buffer;
 234         uint databuf;
 235         uint size;
 236         uint irqstat;
 237         ulong start;
 238
 239         if (data->flags & MMC_DATA_READ) {
 240                 blocks = data->blocks;
 241                 buffer = data->dest;
 242                 while (blocks) {
 243                         start = get_timer(0);
 244                         size = data->blocksize;
 245                         irqstat = esdhc_read32(&regs->irqstat);
 246                         while (!(esdhc_read32(&regs->prsstat) & PRSSTAT_BREN)) {
 247                                 if (get_timer(start) > PIO_TIMEOUT) {
 248                                         printf("\nData Read Failed in PIO Mode.");
 249                                         return;
 250                                 }
 251                         }
 252                         while (size && (!(irqstat & IRQSTAT_TC))) {
 253                                 udelay(100); /* Wait before last byte transfer complete */
 254                                 irqstat = esdhc_read32(&regs->irqstat);
 255                                 databuf = in_le32(&regs->datport);
 256                                 *((uint *)buffer) = databuf;
 257                                 buffer += 4;
 258                                 size -= 4;
 259                         }
 260                         blocks--;
 261                 }
 262         } else {
 263                 blocks = data->blocks;
 264                 buffer = (char *)data->src;
 265                 while (blocks) {
 266                         start = get_timer(0);
 267                         size = data->blocksize;
 268                         irqstat = esdhc_read32(&regs->irqstat);
 269                         while (!(esdhc_read32(&regs->prsstat) & PRSSTAT_BWEN)) {
 270                                 if (get_timer(start) > PIO_TIMEOUT) {
 271                                         printf("\nData Write Failed in PIO Mode.");
 272                                         return;
 273                                 }
 274                         }
 275                         while (size && (!(irqstat & IRQSTAT_TC))) {
 276                                 udelay(100); /* Wait before last byte transfer complete */
 277                                 databuf = *((uint *)buffer);
 278                                 buffer += 4;
 279                                 size -= 4;
 280                                 irqstat = esdhc_read32(&regs->irqstat);
 281                                 out_le32(&regs->datport, databuf);
 282                         }
 283                         blocks--;
 284                 }
 285         }
 286 }
 287 #endif
 288
 289 static int esdhc_setup_data(struct fsl_esdhc_priv *priv, struct mmc *mmc,
 290                             struct mmc_data *data)
 291 {
 292         int timeout;
 293         struct fsl_esdhc *regs = priv->esdhc_regs;
 294 #if defined(CONFIG_S32V234) || defined(CONFIG_IMX8) || defined(CONFIG_IMX8M)
 295         dma_addr_t addr;
 296 #endif
 297         uint wml_value;
 298
 299         wml_value = data->blocksize/4;
 300
 301         if (data->flags & MMC_DATA_READ) {
 302                 if (wml_value > WML_RD_WML_MAX)
 303                         wml_value = WML_RD_WML_MAX_VAL;
 304
 305                 esdhc_clrsetbits32(&regs->wml, WML_RD_WML_MASK, wml_value);
 306 #ifndef CONFIG_SYS_FSL_ESDHC_USE_PIO
 307 #if defined(CONFIG_S32V234) || defined(CONFIG_IMX8) || defined(CONFIG_IMX8M)
 308                 addr = virt_to_phys((void *)(data->dest));
 309                 if (upper_32_bits(addr))
 310                         printf("Error found for upper 32 bits\n");
 311                 else
 312                         esdhc_write32(&regs->dsaddr, lower_32_bits(addr));
 313 #else
 314                 esdhc_write32(&regs->dsaddr, (u32)data->dest);
 315 #endif
 316 #endif
 317         } else {
 318 #ifndef CONFIG_SYS_FSL_ESDHC_USE_PIO
 319                 flush_dcache_range((ulong)data->src,
 320                                    (ulong)data->src+data->blocks
 321                                          *data->blocksize);
 322 #endif
 323                 if (wml_value > WML_WR_WML_MAX)
 324                         wml_value = WML_WR_WML_MAX_VAL;
 325                 if (priv->wp_enable) {
 326                         if ((esdhc_read32(&regs->prsstat) &
 327                             PRSSTAT_WPSPL) == 0) {
 328                                 printf("\nThe SD card is locked. Can not write to a locked card.\n\n");
 329                                 return -ETIMEDOUT;
 330                         }
 331                 } else {
 332 #if CONFIG_IS_ENABLED(DM_GPIO)
 333                         if (dm_gpio_is_valid(&priv->wp_gpio) &&
 334                             dm_gpio_get_value(&priv->wp_gpio)) {
 335                                 printf("\nThe SD card is locked. Can not write to a locked card.\n\n");
 336                                 return -ETIMEDOUT;
 337                         }
 338 #endif
 339                 }
 340
 341                 esdhc_clrsetbits32(&regs->wml, WML_WR_WML_MASK,
 342                                         wml_value << 16);
 343 #ifndef CONFIG_SYS_FSL_ESDHC_USE_PIO
 344 #if defined(CONFIG_S32V234) || defined(CONFIG_IMX8) || defined(CONFIG_IMX8M)
 345                 addr = virt_to_phys((void *)(data->src));
 346                 if (upper_32_bits(addr))
 347                         printf("Error found for upper 32 bits\n");
 348                 else
 349                         esdhc_write32(&regs->dsaddr, lower_32_bits(addr));
 350 #else
 351                 esdhc_write32(&regs->dsaddr, (u32)data->src);
 352 #endif
 353 #endif
 354         }
 355
 356         esdhc_write32(&regs->blkattr, data->blocks << 16 | data->blocksize);
 357
 358         /* Calculate the timeout period for data transactions */
 359         /*
 360          * 1)Timeout period = (2^(timeout+13)) SD Clock cycles
 361          * 2)Timeout period should be minimum 0.250sec as per SD Card spec
 362          *  So, Number of SD Clock cycles for 0.25sec should be minimum
 363          *              (SD Clock/sec * 0.25 sec) SD Clock cycles
 364          *              = (mmc->clock * 1/4) SD Clock cycles
 365          * As 1) >=  2)
 366          * => (2^(timeout+13)) >= mmc->clock * 1/4
 367          * Taking log2 both the sides
 368          * => timeout + 13 >= log2(mmc->clock/4)
 369          * Rounding up to next power of 2
 370          * => timeout + 13 = log2(mmc->clock/4) + 1
 371          * => timeout + 13 = fls(mmc->clock/4)
 372          *
 373          * However, the MMC spec "It is strongly recommended for hosts to
 374          * implement more than 500ms timeout value even if the card
 375          * indicates the 250ms maximum busy length."  Even the previous
 376          * value of 300ms is known to be insufficient for some cards.
 377          * So, we use
 378          * => timeout + 13 = fls(mmc->clock/2)
 379          */
 380         timeout = fls(mmc->clock/2);
 381         timeout -= 13;
 382
 383         if (timeout > 14)
 384                 timeout = 14;
 385
 386         if (timeout < 0)
 387                 timeout = 0;
 388
 389 #ifdef CONFIG_SYS_FSL_ERRATUM_ESDHC_A001
 390         if ((timeout == 4) || (timeout == 8) || (timeout == 12))
 391                 timeout++;
 392 #endif
 393
 394 #ifdef ESDHCI_QUIRK_BROKEN_TIMEOUT_VALUE
 395         timeout = 0xE;
 396 #endif
 397         esdhc_clrsetbits32(&regs->sysctl, SYSCTL_TIMEOUT_MASK, timeout << 16);
 398
 399         return 0;
 400 }
 401
 402 static void check_and_invalidate_dcache_range
 403         (struct mmc_cmd *cmd,
 404          struct mmc_data *data) {
 405         unsigned start = 0;
 406         unsigned end = 0;
 407         unsigned size = roundup(ARCH_DMA_MINALIGN,
 408                                 data->blocks*data->blocksize);
 409 #if defined(CONFIG_S32V234) || defined(CONFIG_IMX8) || defined(CONFIG_IMX8M)
 410         dma_addr_t addr;
 411
 412         addr = virt_to_phys((void *)(data->dest));
 413         if (upper_32_bits(addr))
 414                 printf("Error found for upper 32 bits\n");
 415         else
 416                 start = lower_32_bits(addr);
 417 #else
 418         start = (unsigned)data->dest;
 419 #endif
 420         end = start + size;
 421         invalidate_dcache_range(start, end);
 422 }
 423
 424 #ifdef CONFIG_MCF5441x
 425 /*
 426  * Swaps 32-bit words to little-endian byte order.
 427  */
 428 static inline void sd_swap_dma_buff(struct mmc_data *data)
 429 {
 430         int i, size = data->blocksize >> 2;
 431         u32 *buffer = (u32 *)data->dest;
 432         u32 sw;
 433
 434         while (data->blocks--) {
 435                 for (i = 0; i < size; i++) {
 436                         sw = __sw32(*buffer);
 437                         *buffer++ = sw;
 438                 }
 439         }
 440 }
 441 #endif
 442
 443 /*
 444  * Sends a command out on the bus.  Takes the mmc pointer,
 445  * a command pointer, and an optional data pointer.
 446  */
 447 static int esdhc_send_cmd_common(struct fsl_esdhc_priv *priv, struct mmc *mmc,
 448                                  struct mmc_cmd *cmd, struct mmc_data *data)
 449 {
 450         int     err = 0;
 451         uint    xfertyp;
 452         uint    irqstat;
 453         u32     flags = IRQSTAT_CC | IRQSTAT_CTOE;
 454         struct fsl_esdhc *regs = priv->esdhc_regs;
 455         unsigned long start;
 456
 457 #ifdef CONFIG_SYS_FSL_ERRATUM_ESDHC111
 458         if (cmd->cmdidx == MMC_CMD_STOP_TRANSMISSION)
 459                 return 0;
 460 #endif
 461
 462         esdhc_write32(&regs->irqstat, -1);
 463
 464         sync();
 465
 466         /* Wait for the bus to be idle */
 467         while ((esdhc_read32(&regs->prsstat) & PRSSTAT_CICHB) ||
 468                         (esdhc_read32(&regs->prsstat) & PRSSTAT_CIDHB))
 469                 ;
 470
 471         while (esdhc_read32(&regs->prsstat) & PRSSTAT_DLA)
 472                 ;
 473
 474         /* Set up for a data transfer if we have one */
 475         if (data) {
 476                 err = esdhc_setup_data(priv, mmc, data);
 477                 if(err)
 478                         return err;
 479
 480                 if (data->flags & MMC_DATA_READ)
 481                         check_and_invalidate_dcache_range(cmd, data);
 482         }
 483
 484         /* Figure out the transfer arguments */
 485         xfertyp = esdhc_xfertyp(cmd, data);
 486
 487         /* Mask all irqs */
 488         esdhc_write32(&regs->irqsigen, 0);
 489
 490         /* Send the command */
 491         esdhc_write32(&regs->cmdarg, cmd->cmdarg);
 492 #if defined(CONFIG_FSL_USDHC)
 493         esdhc_write32(&regs->mixctrl,
 494         (esdhc_read32(&regs->mixctrl) & 0xFFFFFF80) | (xfertyp & 0x7F)
 495                         | (mmc->ddr_mode ? XFERTYP_DDREN : 0));
 496         esdhc_write32(&regs->xfertyp, xfertyp & 0xFFFF0000);
 497 #else
 498         esdhc_write32(&regs->xfertyp, xfertyp);
 499 #endif
 500
 501         if ((cmd->cmdidx == MMC_CMD_SEND_TUNING_BLOCK) ||
 502             (cmd->cmdidx == MMC_CMD_SEND_TUNING_BLOCK_HS200))
 503                 flags = IRQSTAT_BRR;
 504
 505         /* Wait for the command to complete */
 506         start = get_timer(0);
 507         while (!(esdhc_read32(&regs->irqstat) & flags)) {
 508                 if (get_timer(start) > 1000) {
 509                         err = -ETIMEDOUT;
 510                         goto out;
 511                 }
 512         }
 513
 514         irqstat = esdhc_read32(&regs->irqstat);
 515
 516         if (irqstat & CMD_ERR) {
 517                 err = -ECOMM;
 518                 goto out;
 519         }
 520
 521         if (irqstat & IRQSTAT_CTOE) {
 522                 err = -ETIMEDOUT;
 523                 goto out;
 524         }
 525
 526         /* Workaround for ESDHC errata ENGcm03648 */
 527         if (!data && (cmd->resp_type & MMC_RSP_BUSY)) {
 528                 int timeout = 50000;
 529
 530                 /* Poll on DATA0 line for cmd with busy signal for 5000 ms */
 531                 while (timeout > 0 && !(esdhc_read32(&regs->prsstat) &
 532                                         PRSSTAT_DAT0)) {
 533                         udelay(100);
 534                         timeout--;
 535                 }
 536
 537                 if (timeout <= 0) {
 538                         printf("Timeout waiting for DAT0 to go high!\n");
 539                         err = -ETIMEDOUT;
 540                         goto out;
 541                 }
 542         }
 543
 544         /* Copy the response to the response buffer */
 545         if (cmd->resp_type & MMC_RSP_136) {
 546                 u32 cmdrsp3, cmdrsp2, cmdrsp1, cmdrsp0;
 547
 548                 cmdrsp3 = esdhc_read32(&regs->cmdrsp3);
 549                 cmdrsp2 = esdhc_read32(&regs->cmdrsp2);
 550                 cmdrsp1 = esdhc_read32(&regs->cmdrsp1);
 551                 cmdrsp0 = esdhc_read32(&regs->cmdrsp0);
 552                 cmd->response[0] = (cmdrsp3 << 8) | (cmdrsp2 >> 24);
 553                 cmd->response[1] = (cmdrsp2 << 8) | (cmdrsp1 >> 24);
 554                 cmd->response[2] = (cmdrsp1 << 8) | (cmdrsp0 >> 24);
 555                 cmd->response[3] = (cmdrsp0 << 8);
 556         } else
 557                 cmd->response[0] = esdhc_read32(&regs->cmdrsp0);
 558
 559         /* Wait until all of the blocks are transferred */
 560         if (data) {
 561 #ifdef CONFIG_SYS_FSL_ESDHC_USE_PIO
 562                 esdhc_pio_read_write(priv, data);
 563 #else
 564                 flags = DATA_COMPLETE;
 565                 if ((cmd->cmdidx == MMC_CMD_SEND_TUNING_BLOCK) ||
 566                     (cmd->cmdidx == MMC_CMD_SEND_TUNING_BLOCK_HS200)) {
 567                         flags = IRQSTAT_BRR;
 568                 }
 569
 570                 do {
 571                         irqstat = esdhc_read32(&regs->irqstat);
 572
 573                         if (irqstat & IRQSTAT_DTOE) {
 574                                 err = -ETIMEDOUT;
 575                                 goto out;
 576                         }
 577
 578                         if (irqstat & DATA_ERR) {
 579                                 err = -ECOMM;
 580                                 goto out;
 581                         }
 582                 } while ((irqstat & flags) != flags);
 583
 584                 /*
 585                  * Need invalidate the dcache here again to avoid any
 586                  * cache-fill during the DMA operations such as the
 587                  * speculative pre-fetching etc.
 588                  */
 589                 if (data->flags & MMC_DATA_READ) {
 590                         check_and_invalidate_dcache_range(cmd, data);
 591 #ifdef CONFIG_MCF5441x
 592                         sd_swap_dma_buff(data);
 593 #endif
 594                 }
 595 #endif
 596         }
 597
 598 out:
 599         /* Reset CMD and DATA portions on error */
 600         if (err) {
 601                 esdhc_write32(&regs->sysctl, esdhc_read32(&regs->sysctl) |
 602                               SYSCTL_RSTC);
 603                 while (esdhc_read32(&regs->sysctl) & SYSCTL_RSTC)
 604                         ;
 605
 606                 if (data) {
 607                         esdhc_write32(&regs->sysctl,
 608                                       esdhc_read32(&regs->sysctl) |
 609                                       SYSCTL_RSTD);
 610                         while ((esdhc_read32(&regs->sysctl) & SYSCTL_RSTD))
 611                                 ;
 612                 }
 613
 614                 /* If this was CMD11, then notify that power cycle is needed */
 615                 if (cmd->cmdidx == SD_CMD_SWITCH_UHS18V)
 616                         printf("CMD11 to switch to 1.8V mode failed, card requires power cycle.\n");
 617         }
 618
 619         esdhc_write32(&regs->irqstat, -1);
 620
 621         return err;
 622 }
 623
 624 static void set_sysctl(struct fsl_esdhc_priv *priv, struct mmc *mmc, uint clock)
 625 {
 626         struct fsl_esdhc *regs = priv->esdhc_regs;
 627         int div = 1;
 628         u32 tmp;
 629         int ret;
 630 #ifdef ARCH_MXC
 631 #ifdef CONFIG_MX53
 632         /* For i.MX53 eSDHCv3, SYSCTL.SDCLKFS may not be set to 0. */
 633         int pre_div = (regs == (struct fsl_esdhc *)MMC_SDHC3_BASE_ADDR) ? 2 : 1;
 634 #else
 635         int pre_div = 1;
 636 #endif
 637 #else
 638         int pre_div = 2;
 639 #endif
 640         int ddr_pre_div = mmc->ddr_mode ? 2 : 1;
 641         int sdhc_clk = priv->sdhc_clk;
 642         uint clk;
 643
 644         while (sdhc_clk / (16 * pre_div * ddr_pre_div) > clock && pre_div < 256)
 645                 pre_div *= 2;
 646
 647         while (sdhc_clk / (div * pre_div * ddr_pre_div) > clock && div < 16)
 648                 div++;
 649
 650         pre_div >>= 1;
 651         div -= 1;
 652
 653         clk = (pre_div << 8) | (div << 4);
 654
 655 #ifdef CONFIG_FSL_USDHC
 656         esdhc_clrbits32(&regs->vendorspec, VENDORSPEC_FRC_SDCLK_ON);
 657         ret = readx_poll_timeout(esdhc_read32, &regs->prsstat, tmp, tmp & PRSSTAT_SDOFF, 100);
 658         if (ret)
 659                 pr_warn("fsl_esdhc_imx: Internal clock never gate off.\n");
 660 #else
 661         esdhc_clrbits32(&regs->sysctl, SYSCTL_CKEN);
 662 #endif
 663
 664         esdhc_clrsetbits32(&regs->sysctl, SYSCTL_CLOCK_MASK, clk);
 665
 666         ret = readx_poll_timeout(esdhc_read32, &regs->prsstat, tmp, tmp & PRSSTAT_SDSTB, 100);
 667         if (ret)
 668                 pr_warn("fsl_esdhc_imx: Internal clock never stabilised.\n");
 669
 670 #ifdef CONFIG_FSL_USDHC
 671         esdhc_setbits32(&regs->vendorspec, VENDORSPEC_FRC_SDCLK_ON);
 672 #else
 673         esdhc_setbits32(&regs->sysctl, SYSCTL_PEREN | SYSCTL_CKEN);
 674 #endif
 675
 676         priv->clock = clock;
 677 }
 678
 679 #ifdef MMC_SUPPORTS_TUNING
 680 static int esdhc_change_pinstate(struct udevice *dev)
 681 {
 682         struct fsl_esdhc_priv *priv = dev_get_priv(dev);
 683         int ret;
 684
 685         switch (priv->mode) {
 686         case UHS_SDR50:
 687         case UHS_DDR50:
 688                 ret = pinctrl_select_state(dev, "state_100mhz");
 689                 break;
 690         case UHS_SDR104:
 691         case MMC_HS_200:
 692         case MMC_HS_400:
 693         case MMC_HS_400_ES:
 694                 ret = pinctrl_select_state(dev, "state_200mhz");
 695                 break;
 696         default:
 697                 ret = pinctrl_select_state(dev, "default");
 698                 break;
 699         }
 700
 701         if (ret)
 702                 printf("%s %d error\n", __func__, priv->mode);
 703
 704         return ret;
 705 }
 706
 707 static void esdhc_reset_tuning(struct mmc *mmc)
 708 {
 709         struct fsl_esdhc_priv *priv = dev_get_priv(mmc->dev);
 710         struct fsl_esdhc *regs = priv->esdhc_regs;
 711
 712         if (priv->flags & ESDHC_FLAG_USDHC) {
 713                 if (priv->flags & ESDHC_FLAG_STD_TUNING) {
 714                         esdhc_clrbits32(&regs->autoc12err,
 715                                         MIX_CTRL_SMPCLK_SEL |
 716                                         MIX_CTRL_EXE_TUNE);
 717                 }
 718         }
 719 }
 720
 721 static void esdhc_set_strobe_dll(struct mmc *mmc)
 722 {
 723         struct fsl_esdhc_priv *priv = dev_get_priv(mmc->dev);
 724         struct fsl_esdhc *regs = priv->esdhc_regs;
 725         u32 val;
 726         u32 tmp;
 727         int ret;
 728
 729         if (priv->clock > ESDHC_STROBE_DLL_CLK_FREQ) {
 730                 esdhc_clrbits32(&regs->vendorspec, VENDORSPEC_FRC_SDCLK_ON);
 731                 ret = readx_poll_timeout(esdhc_read32, &regs->prsstat, tmp, tmp & PRSSTAT_SDOFF, 100);
 732                 if (ret)
 733                         pr_warn("fsl_esdhc_imx: Internal clock never gate off.\n");
 734                 esdhc_write32(&regs->strobe_dllctrl, ESDHC_STROBE_DLL_CTRL_RESET);
 735
 736                 /*
 737                  * enable strobe dll ctrl and adjust the delay target
 738                  * for the uSDHC loopback read clock
 739                  */
 740                 val = ESDHC_STROBE_DLL_CTRL_ENABLE |
 741                         (priv->strobe_dll_delay_target <<
 742                          ESDHC_STROBE_DLL_CTRL_SLV_DLY_TARGET_SHIFT);
 743                 esdhc_write32(&regs->strobe_dllctrl, val);
 744                 /* wait 1us to make sure strobe dll status register stable */
 745                 mdelay(1);
 746                 val = esdhc_read32(&regs->strobe_dllstat);
 747                 if (!(val & ESDHC_STROBE_DLL_STS_REF_LOCK))
 748                         pr_warn("HS400 strobe DLL status REF not lock!\n");
 749                 if (!(val & ESDHC_STROBE_DLL_STS_SLV_LOCK))
 750                         pr_warn("HS400 strobe DLL status SLV not lock!\n");
 751                 esdhc_setbits32(&regs->vendorspec, VENDORSPEC_FRC_SDCLK_ON);
 752         }
 753 }
 754
 755 static int esdhc_set_timing(struct mmc *mmc)
 756 {
 757         struct fsl_esdhc_priv *priv = dev_get_priv(mmc->dev);
 758         struct fsl_esdhc *regs = priv->esdhc_regs;
 759         u32 mixctrl;
 760
 761         mixctrl = esdhc_read32(&regs->mixctrl);
 762         mixctrl &= ~(MIX_CTRL_DDREN | MIX_CTRL_HS400_EN);
 763
 764         switch (mmc->selected_mode) {
 765         case MMC_LEGACY:
 766                 esdhc_reset_tuning(mmc);
 767                 esdhc_write32(&regs->mixctrl, mixctrl);
 768                 break;
 769         case MMC_HS_400:
 770         case MMC_HS_400_ES:
 771                 mixctrl |= MIX_CTRL_DDREN | MIX_CTRL_HS400_EN;
 772                 esdhc_write32(&regs->mixctrl, mixctrl);
 773                 break;
 774         case MMC_HS:
 775         case MMC_HS_52:
 776         case MMC_HS_200:
 777         case SD_HS:
 778         case UHS_SDR12:
 779         case UHS_SDR25:
 780         case UHS_SDR50:
 781         case UHS_SDR104:
 782                 esdhc_write32(&regs->mixctrl, mixctrl);
 783                 break;
 784         case UHS_DDR50:
 785         case MMC_DDR_52:
 786                 mixctrl |= MIX_CTRL_DDREN;
 787                 esdhc_write32(&regs->mixctrl, mixctrl);
 788                 break;
 789         default:
 790                 printf("Not supported %d\n", mmc->selected_mode);
 791                 return -EINVAL;
 792         }
 793
 794         priv->mode = mmc->selected_mode;
 795
 796         return esdhc_change_pinstate(mmc->dev);
 797 }
 798
 799 static int esdhc_set_voltage(struct mmc *mmc)
 800 {
 801         struct fsl_esdhc_priv *priv = dev_get_priv(mmc->dev);
 802         struct fsl_esdhc *regs = priv->esdhc_regs;
 803 #if CONFIG_IS_ENABLED(DM_REGULATOR)
 804         int ret;
 805 #endif
 806
 807         priv->signal_voltage = mmc->signal_voltage;
 808         switch (mmc->signal_voltage) {
 809         case MMC_SIGNAL_VOLTAGE_330:
 810                 if (priv->vs18_enable)
 811                         return -ENOTSUPP;
 812 #if CONFIG_IS_ENABLED(DM_REGULATOR)
 813                 if (!IS_ERR_OR_NULL(priv->vqmmc_dev)) {
 814                         ret = regulator_set_value(priv->vqmmc_dev, 3300000);
 815                         if (ret) {
 816                                 printf("Setting to 3.3V error");
 817                                 return -EIO;
 818                         }
 819                         /* Wait for 5ms */
 820                         mdelay(5);
 821                 }
 822 #endif
 823
 824                 esdhc_clrbits32(&regs->vendorspec, ESDHC_VENDORSPEC_VSELECT);
 825                 if (!(esdhc_read32(&regs->vendorspec) &
 826                     ESDHC_VENDORSPEC_VSELECT))
 827                         return 0;
 828
 829                 return -EAGAIN;
 830         case MMC_SIGNAL_VOLTAGE_180:
 831 #if CONFIG_IS_ENABLED(DM_REGULATOR)
 832                 if (!IS_ERR_OR_NULL(priv->vqmmc_dev)) {
 833                         ret = regulator_set_value(priv->vqmmc_dev, 1800000);
 834                         if (ret) {
 835                                 printf("Setting to 1.8V error");
 836                                 return -EIO;
 837                         }
 838                 }
 839 #endif
 840                 esdhc_setbits32(&regs->vendorspec, ESDHC_VENDORSPEC_VSELECT);
 841                 /*
 842                  * some board like imx8mm-evk need about 18ms to switch
 843                  * the IO voltage from 3.3v to 1.8v, common code only
 844                  * delay 10ms, so need to delay extra time to make sure
 845                  * the IO voltage change to 1.8v.
 846                  */
 847                 if (priv->signal_voltage_switch_extra_delay_ms)
 848                         mdelay(priv->signal_voltage_switch_extra_delay_ms);
 849                 if (esdhc_read32(&regs->vendorspec) & ESDHC_VENDORSPEC_VSELECT)
 850                         return 0;
 851
 852                 return -EAGAIN;
 853         case MMC_SIGNAL_VOLTAGE_120:
 854                 return -ENOTSUPP;
 855         default:
 856                 return 0;
 857         }
 858 }
 859
 860 static void esdhc_stop_tuning(struct mmc *mmc)
 861 {
 862         struct mmc_cmd cmd;
 863
 864         cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION;
 865         cmd.cmdarg = 0;
 866         cmd.resp_type = MMC_RSP_R1b;
 867
 868         mmc_send_cmd(mmc, &cmd, NULL);
 869 }
 870
 871 static int fsl_esdhc_execute_tuning(struct udevice *dev, uint32_t opcode)
 872 {
 873         struct fsl_esdhc_plat *plat = dev_get_plat(dev);
 874         struct fsl_esdhc_priv *priv = dev_get_priv(dev);
 875         struct fsl_esdhc *regs = priv->esdhc_regs;
 876         struct mmc *mmc = &plat->mmc;
 877         u32 irqstaten = esdhc_read32(&regs->irqstaten);
 878         u32 irqsigen = esdhc_read32(&regs->irqsigen);
 879         int i, ret = -ETIMEDOUT;
 880         u32 val, mixctrl;
 881
 882         /* clock tuning is not needed for upto 52MHz */
 883         if (mmc->clock <= 52000000)
 884                 return 0;
 885
 886         /* This is readw/writew SDHCI_HOST_CONTROL2 when tuning */
 887         if (priv->flags & ESDHC_FLAG_STD_TUNING) {
 888                 val = esdhc_read32(&regs->autoc12err);
 889                 mixctrl = esdhc_read32(&regs->mixctrl);
 890                 val &= ~MIX_CTRL_SMPCLK_SEL;
 891                 mixctrl &= ~(MIX_CTRL_FBCLK_SEL | MIX_CTRL_AUTO_TUNE_EN);
 892
 893                 val |= MIX_CTRL_EXE_TUNE;
 894                 mixctrl |= MIX_CTRL_FBCLK_SEL | MIX_CTRL_AUTO_TUNE_EN;
 895
 896                 esdhc_write32(&regs->autoc12err, val);
 897                 esdhc_write32(&regs->mixctrl, mixctrl);
 898         }
 899
 900         /* sdhci_writew(host, SDHCI_TRNS_READ, SDHCI_TRANSFER_MODE); */
 901         mixctrl = esdhc_read32(&regs->mixctrl);
 902         mixctrl = MIX_CTRL_DTDSEL_READ | (mixctrl & ~MIX_CTRL_SDHCI_MASK);
 903         esdhc_write32(&regs->mixctrl, mixctrl);
 904
 905         esdhc_write32(&regs->irqstaten, IRQSTATEN_BRR);
 906         esdhc_write32(&regs->irqsigen, IRQSTATEN_BRR);
 907
 908         /*
 909          * Issue opcode repeatedly till Execute Tuning is set to 0 or the number
 910          * of loops reaches 40 times.
 911          */
 912         for (i = 0; i < MAX_TUNING_LOOP; i++) {
 913                 u32 ctrl;
 914
 915                 if (opcode == MMC_CMD_SEND_TUNING_BLOCK_HS200) {
 916                         if (mmc->bus_width == 8)
 917                                 esdhc_write32(&regs->blkattr, 0x7080);
 918                         else if (mmc->bus_width == 4)
 919                                 esdhc_write32(&regs->blkattr, 0x7040);
 920                 } else {
 921                         esdhc_write32(&regs->blkattr, 0x7040);
 922                 }
 923
 924                 /* sdhci_writew(host, SDHCI_TRNS_READ, SDHCI_TRANSFER_MODE) */
 925                 val = esdhc_read32(&regs->mixctrl);
 926                 val = MIX_CTRL_DTDSEL_READ | (val & ~MIX_CTRL_SDHCI_MASK);
 927                 esdhc_write32(&regs->mixctrl, val);
 928
 929                 /* We are using STD tuning, no need to check return value */
 930                 mmc_send_tuning(mmc, opcode, NULL);
 931
 932                 ctrl = esdhc_read32(&regs->autoc12err);
 933                 if ((!(ctrl & MIX_CTRL_EXE_TUNE)) &&
 934                     (ctrl & MIX_CTRL_SMPCLK_SEL)) {
 935                         ret = 0;
 936                         break;
 937                 }
 938         }
 939
 940         esdhc_write32(&regs->irqstaten, irqstaten);
 941         esdhc_write32(&regs->irqsigen, irqsigen);
 942
 943         esdhc_stop_tuning(mmc);
 944
 945         return ret;
 946 }
 947 #endif
 948
 949 static int esdhc_set_ios_common(struct fsl_esdhc_priv *priv, struct mmc *mmc)
 950 {
 951         struct fsl_esdhc *regs = priv->esdhc_regs;
 952         int ret __maybe_unused;
 953         u32 clock;
 954
 955 #ifdef MMC_SUPPORTS_TUNING
 956         /*
 957          * call esdhc_set_timing() before update the clock rate,
 958          * This is because current we support DDR and SDR mode,
 959          * Once the DDR_EN bit is set, the card clock will be
 960          * divide by 2 automatically. So need to do this before
 961          * setting clock rate.
 962          */
 963         if (priv->mode != mmc->selected_mode) {
 964                 ret = esdhc_set_timing(mmc);
 965                 if (ret) {
 966                         printf("esdhc_set_timing error %d\n", ret);
 967                         return ret;
 968                 }
 969         }
 970 #endif
 971
 972         /* Set the clock speed */
 973         clock = mmc->clock;
 974         if (clock < mmc->cfg->f_min)
 975                 clock = mmc->cfg->f_min;
 976
 977         if (priv->clock != clock)
 978                 set_sysctl(priv, mmc, clock);
 979
 980 #ifdef MMC_SUPPORTS_TUNING
 981         if (mmc->clk_disable) {
 982 #ifdef CONFIG_FSL_USDHC
 983                 u32 tmp;
 984
 985                 esdhc_clrbits32(&regs->vendorspec, VENDORSPEC_FRC_SDCLK_ON);
 986                 ret = readx_poll_timeout(esdhc_read32, &regs->prsstat, tmp, tmp & PRSSTAT_SDOFF, 100);
 987                 if (ret)
 988                         pr_warn("fsl_esdhc_imx: Internal clock never gate off.\n");
 989 #else
 990                 esdhc_clrbits32(&regs->sysctl, SYSCTL_CKEN);
 991 #endif
 992         } else {
 993 #ifdef CONFIG_FSL_USDHC
 994                 esdhc_setbits32(&regs->vendorspec, VENDORSPEC_FRC_SDCLK_ON);
 995 #else
 996                 esdhc_setbits32(&regs->sysctl, SYSCTL_PEREN | SYSCTL_CKEN);
 997 #endif
 998         }
 999
1000         /*
1001          * For HS400/HS400ES mode, make sure set the strobe dll in the
1002          * target clock rate. So call esdhc_set_strobe_dll() after the
1003          * clock updated.
1004          */
1005         if (mmc->selected_mode == MMC_HS_400 || mmc->selected_mode == MMC_HS_400_ES)
1006                 esdhc_set_strobe_dll(mmc);
1007
1008         if (priv->signal_voltage != mmc->signal_voltage) {
1009                 ret = esdhc_set_voltage(mmc);
1010                 if (ret) {
1011                         if (ret != -ENOTSUPP)
1012                                 printf("esdhc_set_voltage error %d\n", ret);
1013                         return ret;
1014                 }
1015         }
1016 #endif
1017
1018         /* Set the bus width */
1019         esdhc_clrbits32(&regs->proctl, PROCTL_DTW_4 | PROCTL_DTW_8);
1020
1021         if (mmc->bus_width == 4)
1022                 esdhc_setbits32(&regs->proctl, PROCTL_DTW_4);
1023         else if (mmc->bus_width == 8)
1024                 esdhc_setbits32(&regs->proctl, PROCTL_DTW_8);
1025
1026         return 0;
1027 }
1028
1029 static int esdhc_init_common(struct fsl_esdhc_priv *priv, struct mmc *mmc)
1030 {
1031         struct fsl_esdhc *regs = priv->esdhc_regs;
1032         ulong start;
1033
1034         /* Reset the entire host controller */
1035         esdhc_setbits32(&regs->sysctl, SYSCTL_RSTA);
1036
1037         /* Wait until the controller is available */
1038         start = get_timer(0);
1039         while ((esdhc_read32(&regs->sysctl) & SYSCTL_RSTA)) {
1040                 if (get_timer(start) > 1000)
1041                         return -ETIMEDOUT;
1042         }
1043
1044 #if defined(CONFIG_FSL_USDHC)
1045         /* RSTA doesn't reset MMC_BOOT register, so manually reset it */
1046         esdhc_write32(&regs->mmcboot, 0x0);
1047         /* Reset MIX_CTRL and CLK_TUNE_CTRL_STATUS regs to 0 */
1048         esdhc_write32(&regs->mixctrl, 0x0);
1049         esdhc_write32(&regs->clktunectrlstatus, 0x0);
1050
1051         /* Put VEND_SPEC to default value */
1052         if (priv->vs18_enable)
1053                 esdhc_write32(&regs->vendorspec, (VENDORSPEC_INIT |
1054                               ESDHC_VENDORSPEC_VSELECT));
1055         else
1056                 esdhc_write32(&regs->vendorspec, VENDORSPEC_INIT);
1057
1058         /* Disable DLL_CTRL delay line */
1059         esdhc_write32(&regs->dllctrl, 0x0);
1060 #endif
1061
1062 #ifndef ARCH_MXC
1063         /* Enable cache snooping */
1064         esdhc_write32(&regs->scr, 0x00000040);
1065 #endif
1066
1067 #ifndef CONFIG_FSL_USDHC
1068         esdhc_setbits32(&regs->sysctl, SYSCTL_HCKEN | SYSCTL_IPGEN);
1069 #else
1070         esdhc_setbits32(&regs->vendorspec, VENDORSPEC_FRC_SDCLK_ON);
1071 #endif
1072
1073         /* Set the initial clock speed */
1074         mmc_set_clock(mmc, 400000, MMC_CLK_ENABLE);
1075
1076         /* Disable the BRR and BWR bits in IRQSTAT */
1077         esdhc_clrbits32(&regs->irqstaten, IRQSTATEN_BRR | IRQSTATEN_BWR);
1078
1079 #ifdef CONFIG_MCF5441x
1080         esdhc_write32(&regs->proctl, PROCTL_INIT | PROCTL_D3CD);
1081 #else
1082         /* Put the PROCTL reg back to the default */
1083         esdhc_write32(&regs->proctl, PROCTL_INIT);
1084 #endif
1085
1086         /* Set timout to the maximum value */
1087         esdhc_clrsetbits32(&regs->sysctl, SYSCTL_TIMEOUT_MASK, 14 << 16);
1088
1089         return 0;
1090 }
1091
1092 static int esdhc_getcd_common(struct fsl_esdhc_priv *priv)
1093 {
1094         struct fsl_esdhc *regs = priv->esdhc_regs;
1095         int timeout = 1000;
1096
1097 #ifdef CONFIG_ESDHC_DETECT_QUIRK
1098         if (CONFIG_ESDHC_DETECT_QUIRK)
1099                 return 1;
1100 #endif
1101
1102 #if CONFIG_IS_ENABLED(DM_MMC)
1103         if (priv->non_removable)
1104                 return 1;
1105
1106         if (priv->broken_cd)
1107                 return 1;
1108 #if CONFIG_IS_ENABLED(DM_GPIO)
1109         if (dm_gpio_is_valid(&priv->cd_gpio))
1110                 return dm_gpio_get_value(&priv->cd_gpio);
1111 #endif
1112 #endif
1113
1114         while (!(esdhc_read32(&regs->prsstat) & PRSSTAT_CINS) && --timeout)
1115                 udelay(1000);
1116
1117         return timeout > 0;
1118 }
1119
1120 static int esdhc_reset(struct fsl_esdhc *regs)
1121 {
1122         ulong start;
1123
1124         /* reset the controller */
1125         esdhc_setbits32(&regs->sysctl, SYSCTL_RSTA);
1126
1127         /* hardware clears the bit when it is done */
1128         start = get_timer(0);
1129         while ((esdhc_read32(&regs->sysctl) & SYSCTL_RSTA)) {
1130                 if (get_timer(start) > 100) {
1131                         printf("MMC/SD: Reset never completed.\n");
1132                         return -ETIMEDOUT;
1133                 }
1134         }
1135
1136         return 0;
1137 }
1138
1139 #if !CONFIG_IS_ENABLED(DM_MMC)
1140 static int esdhc_getcd(struct mmc *mmc)
1141 {
1142         struct fsl_esdhc_priv *priv = mmc->priv;
1143
1144         return esdhc_getcd_common(priv);
1145 }
1146
1147 static int esdhc_init(struct mmc *mmc)
1148 {
1149         struct fsl_esdhc_priv *priv = mmc->priv;
1150
1151         return esdhc_init_common(priv, mmc);
1152 }
1153
1154 static int esdhc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd,
1155                           struct mmc_data *data)
1156 {
1157         struct fsl_esdhc_priv *priv = mmc->priv;
1158
1159         return esdhc_send_cmd_common(priv, mmc, cmd, data);
1160 }
1161
1162 static int esdhc_set_ios(struct mmc *mmc)
1163 {
1164         struct fsl_esdhc_priv *priv = mmc->priv;
1165
1166         return esdhc_set_ios_common(priv, mmc);
1167 }
1168
1169 static const struct mmc_ops esdhc_ops = {
1170         .getcd          = esdhc_getcd,
1171         .init           = esdhc_init,
1172         .send_cmd       = esdhc_send_cmd,
1173         .set_ios        = esdhc_set_ios,
1174 };
1175 #endif
1176
1177 static int fsl_esdhc_init(struct fsl_esdhc_priv *priv,
1178                           struct fsl_esdhc_plat *plat)
1179 {
1180         struct mmc_config *cfg;
1181         struct fsl_esdhc *regs;
1182         u32 caps, voltage_caps;
1183         int ret;
1184
1185         if (!priv)
1186                 return -EINVAL;
1187
1188         regs = priv->esdhc_regs;
1189
1190         /* First reset the eSDHC controller */
1191         ret = esdhc_reset(regs);
1192         if (ret)
1193                 return ret;
1194
1195 #ifdef CONFIG_MCF5441x
1196         /* ColdFire, using SDHC_DATA[3] for card detection */
1197         esdhc_write32(&regs->proctl, PROCTL_INIT | PROCTL_D3CD);
1198 #endif
1199
1200 #ifndef CONFIG_FSL_USDHC
1201         esdhc_setbits32(&regs->sysctl, SYSCTL_PEREN | SYSCTL_HCKEN
1202                                 | SYSCTL_IPGEN | SYSCTL_CKEN);
1203         /* Clearing tuning bits in case ROM has set it already */
1204         esdhc_write32(&regs->mixctrl, 0);
1205         esdhc_write32(&regs->autoc12err, 0);
1206         esdhc_write32(&regs->clktunectrlstatus, 0);
1207 #else
1208         esdhc_setbits32(&regs->vendorspec, VENDORSPEC_FRC_SDCLK_ON);
1209 #endif
1210
1211         if (priv->vs18_enable)
1212                 esdhc_setbits32(&regs->vendorspec, ESDHC_VENDORSPEC_VSELECT);
1213
1214         esdhc_write32(&regs->irqstaten, SDHCI_IRQ_EN_BITS);
1215         cfg = &plat->cfg;
1216 #ifndef CONFIG_DM_MMC
1217         memset(cfg, '\0', sizeof(*cfg));
1218 #endif
1219
1220         voltage_caps = 0;
1221         caps = esdhc_read32(&regs->hostcapblt);
1222
1223 #ifdef CONFIG_MCF5441x
1224         /*
1225          * MCF5441x RM declares in more points that sdhc clock speed must
1226          * never exceed 25 Mhz. From this, the HS bit needs to be disabled
1227          * from host capabilities.
1228          */
1229         caps &= ~ESDHC_HOSTCAPBLT_HSS;
1230 #endif
1231
1232 #ifdef CONFIG_SYS_FSL_ERRATUM_ESDHC135
1233         caps = caps & ~(ESDHC_HOSTCAPBLT_SRS |
1234                         ESDHC_HOSTCAPBLT_VS18 | ESDHC_HOSTCAPBLT_VS30);
1235 #endif
1236
1237         if (caps & ESDHC_HOSTCAPBLT_VS18)
1238                 voltage_caps |= MMC_VDD_165_195;
1239         if (caps & ESDHC_HOSTCAPBLT_VS30)
1240                 voltage_caps |= MMC_VDD_29_30 | MMC_VDD_30_31;
1241         if (caps & ESDHC_HOSTCAPBLT_VS33)
1242                 voltage_caps |= MMC_VDD_32_33 | MMC_VDD_33_34;
1243
1244         cfg->name = "FSL_SDHC";
1245 #if !CONFIG_IS_ENABLED(DM_MMC)
1246         cfg->ops = &esdhc_ops;
1247 #endif
1248 #ifdef CONFIG_SYS_SD_VOLTAGE
1249         cfg->voltages = CONFIG_SYS_SD_VOLTAGE;
1250 #else
1251         cfg->voltages = MMC_VDD_32_33 | MMC_VDD_33_34;
1252 #endif
1253         if ((cfg->voltages & voltage_caps) == 0) {
1254                 printf("voltage not supported by controller\n");
1255                 return -1;
1256         }
1257
1258         if (priv->bus_width == 8)
1259                 cfg->host_caps = MMC_MODE_4BIT | MMC_MODE_8BIT;
1260         else if (priv->bus_width == 4)
1261                 cfg->host_caps = MMC_MODE_4BIT;
1262
1263         cfg->host_caps = MMC_MODE_4BIT | MMC_MODE_8BIT;
1264 #ifdef CONFIG_SYS_FSL_ESDHC_HAS_DDR_MODE
1265         cfg->host_caps |= MMC_MODE_DDR_52MHz;
1266 #endif
1267
1268         if (priv->bus_width > 0) {
1269                 if (priv->bus_width < 8)
1270                         cfg->host_caps &= ~MMC_MODE_8BIT;
1271                 if (priv->bus_width < 4)
1272                         cfg->host_caps &= ~MMC_MODE_4BIT;
1273         }
1274
1275         if (caps & ESDHC_HOSTCAPBLT_HSS)
1276                 cfg->host_caps |= MMC_MODE_HS_52MHz | MMC_MODE_HS;
1277
1278 #ifdef CONFIG_ESDHC_DETECT_8_BIT_QUIRK
1279         if (CONFIG_ESDHC_DETECT_8_BIT_QUIRK)
1280                 cfg->host_caps &= ~MMC_MODE_8BIT;
1281 #endif
1282
1283         cfg->host_caps |= priv->caps;
1284
1285         cfg->f_min = 400000;
1286         cfg->f_max = min(priv->sdhc_clk, (u32)200000000);
1287
1288         cfg->b_max = CONFIG_SYS_MMC_MAX_BLK_COUNT;
1289
1290         esdhc_write32(&regs->dllctrl, 0);
1291         if (priv->flags & ESDHC_FLAG_USDHC) {
1292                 if (priv->flags & ESDHC_FLAG_STD_TUNING) {
1293                         u32 val = esdhc_read32(&regs->tuning_ctrl);
1294
1295                         val |= ESDHC_STD_TUNING_EN;
1296                         val &= ~ESDHC_TUNING_START_TAP_MASK;
1297                         val |= priv->tuning_start_tap;
1298                         val &= ~ESDHC_TUNING_STEP_MASK;
1299                         val |= (priv->tuning_step) << ESDHC_TUNING_STEP_SHIFT;
1300
1301                         /* Disable the CMD CRC check for tuning, if not, need to
1302                          * add some delay after every tuning command, because
1303                          * hardware standard tuning logic will directly go to next
1304                          * step once it detect the CMD CRC error, will not wait for
1305                          * the card side to finally send out the tuning data, trigger
1306                          * the buffer read ready interrupt immediately. If usdhc send
1307                          * the next tuning command some eMMC card will stuck, can't
1308                          * response, block the tuning procedure or the first command
1309                          * after the whole tuning procedure always can't get any response.
1310                          */
1311                         val |= ESDHC_TUNING_CMD_CRC_CHECK_DISABLE;
1312                         esdhc_write32(&regs->tuning_ctrl, val);
1313                 }
1314         }
1315
1316         return 0;
1317 }
1318
1319 #if !CONFIG_IS_ENABLED(DM_MMC)
1320 static int fsl_esdhc_cfg_to_priv(struct fsl_esdhc_cfg *cfg,
1321                                  struct fsl_esdhc_priv *priv)
1322 {
1323         if (!cfg || !priv)
1324                 return -EINVAL;
1325
1326         priv->esdhc_regs = (struct fsl_esdhc *)(unsigned long)(cfg->esdhc_base);
1327         priv->bus_width = cfg->max_bus_width;
1328         priv->sdhc_clk = cfg->sdhc_clk;
1329         priv->wp_enable  = cfg->wp_enable;
1330         priv->vs18_enable  = cfg->vs18_enable;
1331
1332         return 0;
1333 };
1334
1335 int fsl_esdhc_initialize(struct bd_info *bis, struct fsl_esdhc_cfg *cfg)
1336 {
1337         struct fsl_esdhc_plat *plat;
1338         struct fsl_esdhc_priv *priv;
1339         struct mmc *mmc;
1340         int ret;
1341
1342         if (!cfg)
1343                 return -EINVAL;
1344
1345         priv = calloc(sizeof(struct fsl_esdhc_priv), 1);
1346         if (!priv)
1347                 return -ENOMEM;
1348         plat = calloc(sizeof(struct fsl_esdhc_plat), 1);
1349         if (!plat) {
1350                 free(priv);
1351                 return -ENOMEM;
1352         }
1353
1354         ret = fsl_esdhc_cfg_to_priv(cfg, priv);
1355         if (ret) {
1356                 debug("%s xlate failure\n", __func__);
1357                 free(plat);
1358                 free(priv);
1359                 return ret;
1360         }
1361
1362         ret = fsl_esdhc_init(priv, plat);
1363         if (ret) {
1364                 debug("%s init failure\n", __func__);
1365                 free(plat);
1366                 free(priv);
1367                 return ret;
1368         }
1369
1370         mmc = mmc_create(&plat->cfg, priv);
1371         if (!mmc)
1372                 return -EIO;
1373
1374         priv->mmc = mmc;
1375
1376         return 0;
1377 }
1378
1379 int fsl_esdhc_mmc_init(struct bd_info *bis)
1380 {
1381         struct fsl_esdhc_cfg *cfg;
1382
1383         cfg = calloc(sizeof(struct fsl_esdhc_cfg), 1);
1384         cfg->esdhc_base = CONFIG_SYS_FSL_ESDHC_ADDR;
1385         cfg->sdhc_clk = gd->arch.sdhc_clk;
1386         return fsl_esdhc_initialize(bis, cfg);
1387 }
1388 #endif
1389
1390 #ifdef CONFIG_OF_LIBFDT
1391 __weak int esdhc_status_fixup(void *blob, const char *compat)
1392 {
1393 #ifdef CONFIG_FSL_ESDHC_PIN_MUX
1394         if (!hwconfig("esdhc")) {
1395                 do_fixup_by_compat(blob, compat, "status", "disabled",
1396                                 sizeof("disabled"), 1);
1397                 return 1;
1398         }
1399 #endif
1400         return 0;
1401 }
1402
1403 void fdt_fixup_esdhc(void *blob, struct bd_info *bd)
1404 {
1405         const char *compat = "fsl,esdhc";
1406
1407         if (esdhc_status_fixup(blob, compat))
1408                 return;
1409
1410         do_fixup_by_compat_u32(blob, compat, "clock-frequency",
1411                                gd->arch.sdhc_clk, 1);
1412 }
1413 #endif
1414
1415 #if CONFIG_IS_ENABLED(DM_MMC)
1416 #include <asm/arch/clock.h>
1417 __weak void init_clk_usdhc(u32 index)
1418 {
1419 }
1420
1421 static int fsl_esdhc_of_to_plat(struct udevice *dev)
1422 {
1423 #if !CONFIG_IS_ENABLED(OF_PLATDATA)
1424         struct fsl_esdhc_priv *priv = dev_get_priv(dev);
1425 #if CONFIG_IS_ENABLED(DM_REGULATOR)
1426         struct udevice *vqmmc_dev;
1427         int ret;
1428 #endif
1429         const void *fdt = gd->fdt_blob;
1430         int node = dev_of_offset(dev);
1431
1432         fdt_addr_t addr;
1433         unsigned int val;
1434
1435         addr = dev_read_addr(dev);
1436         if (addr == FDT_ADDR_T_NONE)
1437                 return -EINVAL;
1438         priv->esdhc_regs = (struct fsl_esdhc *)addr;
1439         priv->dev = dev;
1440         priv->mode = -1;
1441
1442         val = dev_read_u32_default(dev, "bus-width", -1);
1443         if (val == 8)
1444                 priv->bus_width = 8;
1445         else if (val == 4)
1446                 priv->bus_width = 4;
1447         else
1448                 priv->bus_width = 1;
1449
1450         val = fdtdec_get_int(fdt, node, "fsl,tuning-step", 1);
1451         priv->tuning_step = val;
1452         val = fdtdec_get_int(fdt, node, "fsl,tuning-start-tap",
1453                              ESDHC_TUNING_START_TAP_DEFAULT);
1454         priv->tuning_start_tap = val;
1455         val = fdtdec_get_int(fdt, node, "fsl,strobe-dll-delay-target",
1456                              ESDHC_STROBE_DLL_CTRL_SLV_DLY_TARGET_DEFAULT);
1457         priv->strobe_dll_delay_target = val;
1458         val = fdtdec_get_int(fdt, node, "fsl,signal-voltage-switch-extra-delay-ms", 0);
1459         priv->signal_voltage_switch_extra_delay_ms = val;
1460
1461         if (dev_read_bool(dev, "broken-cd"))
1462                 priv->broken_cd = 1;
1463
1464         if (dev_read_bool(dev, "non-removable")) {
1465                 priv->non_removable = 1;
1466          } else {
1467                 priv->non_removable = 0;
1468 #if CONFIG_IS_ENABLED(DM_GPIO)
1469                 gpio_request_by_name(dev, "cd-gpios", 0, &priv->cd_gpio,
1470                                      GPIOD_IS_IN);
1471 #endif
1472         }
1473
1474         if (dev_read_prop(dev, "fsl,wp-controller", NULL)) {
1475                 priv->wp_enable = 1;
1476         } else {
1477                 priv->wp_enable = 0;
1478 #if CONFIG_IS_ENABLED(DM_GPIO)
1479                 gpio_request_by_name(dev, "wp-gpios", 0, &priv->wp_gpio,
1480                                    GPIOD_IS_IN);
1481 #endif
1482         }
1483
1484         priv->vs18_enable = 0;
1485
1486 #if CONFIG_IS_ENABLED(DM_REGULATOR)
1487         /*
1488          * If emmc I/O has a fixed voltage at 1.8V, this must be provided,
1489          * otherwise, emmc will work abnormally.
1490          */
1491         ret = device_get_supply_regulator(dev, "vqmmc-supply", &vqmmc_dev);
1492         if (ret) {
1493                 dev_dbg(dev, "no vqmmc-supply\n");
1494         } else {
1495                 priv->vqmmc_dev = vqmmc_dev;
1496                 ret = regulator_set_enable(vqmmc_dev, true);
1497                 if (ret) {
1498                         dev_err(dev, "fail to enable vqmmc-supply\n");
1499                         return ret;
1500                 }
1501
1502                 if (regulator_get_value(vqmmc_dev) == 1800000)
1503                         priv->vs18_enable = 1;
1504         }
1505 #endif
1506 #endif
1507         return 0;
1508 }
1509
1510 static int fsl_esdhc_probe(struct udevice *dev)
1511 {
1512         struct mmc_uclass_priv *upriv = dev_get_uclass_priv(dev);
1513         struct fsl_esdhc_plat *plat = dev_get_plat(dev);
1514         struct fsl_esdhc_priv *priv = dev_get_priv(dev);
1515         struct esdhc_soc_data *data =
1516                 (struct esdhc_soc_data *)dev_get_driver_data(dev);
1517         struct mmc *mmc;
1518 #if !CONFIG_IS_ENABLED(BLK)
1519         struct blk_desc *bdesc;
1520 #endif
1521         int ret;
1522
1523 #if CONFIG_IS_ENABLED(OF_PLATDATA)
1524         struct dtd_fsl_esdhc *dtplat = &plat->dtplat;
1525         unsigned int val;
1526
1527         priv->esdhc_regs = map_sysmem(dtplat->reg[0], dtplat->reg[1]);
1528         val = plat->dtplat.bus_width;
1529         if (val == 8)
1530                 priv->bus_width = 8;
1531         else if (val == 4)
1532                 priv->bus_width = 4;
1533         else
1534                 priv->bus_width = 1;
1535
1536         if (dtplat->non_removable)
1537                 priv->non_removable = 1;
1538         else
1539                 priv->non_removable = 0;
1540
1541         if (CONFIG_IS_ENABLED(DM_GPIO) && !priv->non_removable) {
1542                 struct udevice *gpiodev;
1543
1544                 ret = device_get_by_ofplat_idx(dtplat->cd_gpios->idx, &gpiodev);
1545                 if (ret)
1546                         return ret;
1547
1548                 ret = gpio_dev_request_index(gpiodev, gpiodev->name, "cd-gpios",
1549                                              dtplat->cd_gpios->arg[0], GPIOD_IS_IN,
1550                                              dtplat->cd_gpios->arg[1], &priv->cd_gpio);
1551
1552                 if (ret)
1553                         return ret;
1554         }
1555 #endif
1556
1557         if (data)
1558                 priv->flags = data->flags;
1559
1560         /*
1561          * TODO:
1562          * Because lack of clk driver, if SDHC clk is not enabled,
1563          * need to enable it first before this driver is invoked.
1564          *
1565          * we use MXC_ESDHC_CLK to get clk freq.
1566          * If one would like to make this function work,
1567          * the aliases should be provided in dts as this:
1568          *
1569          *  aliases {
1570          *      mmc0 = &usdhc1;
1571          *      mmc1 = &usdhc2;
1572          *      mmc2 = &usdhc3;
1573          *      mmc3 = &usdhc4;
1574          *      };
1575          * Then if your board only supports mmc2 and mmc3, but we can
1576          * correctly get the seq as 2 and 3, then let mxc_get_clock
1577          * work as expected.
1578          */
1579
1580         init_clk_usdhc(dev_seq(dev));
1581
1582 #if CONFIG_IS_ENABLED(CLK)
1583         /* Assigned clock already set clock */
1584         ret = clk_get_by_name(dev, "per", &priv->per_clk);
1585         if (ret) {
1586                 printf("Failed to get per_clk\n");
1587                 return ret;
1588         }
1589         ret = clk_enable(&priv->per_clk);
1590         if (ret) {
1591                 printf("Failed to enable per_clk\n");
1592                 return ret;
1593         }
1594
1595         priv->sdhc_clk = clk_get_rate(&priv->per_clk);
1596 #else
1597         priv->sdhc_clk = mxc_get_clock(MXC_ESDHC_CLK + dev_seq(dev));
1598         if (priv->sdhc_clk <= 0) {
1599                 dev_err(dev, "Unable to get clk for %s\n", dev->name);
1600                 return -EINVAL;
1601         }
1602 #endif
1603
1604         ret = fsl_esdhc_init(priv, plat);
1605         if (ret) {
1606                 dev_err(dev, "fsl_esdhc_init failure\n");
1607                 return ret;
1608         }
1609
1610 #if !CONFIG_IS_ENABLED(OF_PLATDATA)
1611         ret = mmc_of_parse(dev, &plat->cfg);
1612         if (ret)
1613                 return ret;
1614 #endif
1615
1616         mmc = &plat->mmc;
1617         mmc->cfg = &plat->cfg;
1618         mmc->dev = dev;
1619 #if !CONFIG_IS_ENABLED(BLK)
1620         mmc->priv = priv;
1621
1622         /* Setup dsr related values */
1623         mmc->dsr_imp = 0;
1624         mmc->dsr = ESDHC_DRIVER_STAGE_VALUE;
1625         /* Setup the universal parts of the block interface just once */
1626         bdesc = mmc_get_blk_desc(mmc);
1627         bdesc->if_type = IF_TYPE_MMC;
1628         bdesc->removable = 1;
1629         bdesc->devnum = mmc_get_next_devnum();
1630         bdesc->block_read = mmc_bread;
1631         bdesc->block_write = mmc_bwrite;
1632         bdesc->block_erase = mmc_berase;
1633
1634         /* setup initial part type */
1635         bdesc->part_type = mmc->cfg->part_type;
1636         mmc_list_add(mmc);
1637 #endif
1638
1639         upriv->mmc = mmc;
1640
1641         return esdhc_init_common(priv, mmc);
1642 }
1643
1644 #if CONFIG_IS_ENABLED(DM_MMC)
1645 static int fsl_esdhc_get_cd(struct udevice *dev)
1646 {
1647         struct fsl_esdhc_priv *priv = dev_get_priv(dev);
1648
1649         return esdhc_getcd_common(priv);
1650 }
1651
1652 static int fsl_esdhc_send_cmd(struct udevice *dev, struct mmc_cmd *cmd,
1653                               struct mmc_data *data)
1654 {
1655         struct fsl_esdhc_plat *plat = dev_get_plat(dev);
1656         struct fsl_esdhc_priv *priv = dev_get_priv(dev);
1657
1658         return esdhc_send_cmd_common(priv, &plat->mmc, cmd, data);
1659 }
1660
1661 static int fsl_esdhc_set_ios(struct udevice *dev)
1662 {
1663         struct fsl_esdhc_plat *plat = dev_get_plat(dev);
1664         struct fsl_esdhc_priv *priv = dev_get_priv(dev);
1665
1666         return esdhc_set_ios_common(priv, &plat->mmc);
1667 }
1668
1669 #if CONFIG_IS_ENABLED(MMC_HS400_ES_SUPPORT)
1670 static int fsl_esdhc_set_enhanced_strobe(struct udevice *dev)
1671 {
1672         struct fsl_esdhc_priv *priv = dev_get_priv(dev);
1673         struct fsl_esdhc *regs = priv->esdhc_regs;
1674         u32 m;
1675
1676         m = esdhc_read32(&regs->mixctrl);
1677         m |= MIX_CTRL_HS400_ES;
1678         esdhc_write32(&regs->mixctrl, m);
1679
1680         return 0;
1681 }
1682 #endif
1683
1684 static int fsl_esdhc_wait_dat0(struct udevice *dev, int state,
1685                                 int timeout_us)
1686 {
1687         int ret;
1688         u32 tmp;
1689         struct fsl_esdhc_priv *priv = dev_get_priv(dev);
1690         struct fsl_esdhc *regs = priv->esdhc_regs;
1691
1692         ret = readx_poll_timeout(esdhc_read32, &regs->prsstat, tmp,
1693                                 !!(tmp & PRSSTAT_DAT0) == !!state,
1694                                 timeout_us);
1695         return ret;
1696 }
1697
1698 static const struct dm_mmc_ops fsl_esdhc_ops = {
1699         .get_cd         = fsl_esdhc_get_cd,
1700         .send_cmd       = fsl_esdhc_send_cmd,
1701         .set_ios        = fsl_esdhc_set_ios,
1702 #ifdef MMC_SUPPORTS_TUNING
1703         .execute_tuning = fsl_esdhc_execute_tuning,
1704 #endif
1705 #if CONFIG_IS_ENABLED(MMC_HS400_ES_SUPPORT)
1706         .set_enhanced_strobe = fsl_esdhc_set_enhanced_strobe,
1707 #endif
1708         .wait_dat0 = fsl_esdhc_wait_dat0,
1709 };
1710 #endif
1711
1712 static struct esdhc_soc_data usdhc_imx7d_data = {
1713         .flags = ESDHC_FLAG_USDHC | ESDHC_FLAG_STD_TUNING
1714                         | ESDHC_FLAG_HAVE_CAP1 | ESDHC_FLAG_HS200
1715                         | ESDHC_FLAG_HS400,
1716 };
1717
1718 static struct esdhc_soc_data usdhc_imx8qm_data = {
1719         .flags = ESDHC_FLAG_USDHC | ESDHC_FLAG_STD_TUNING |
1720                 ESDHC_FLAG_HAVE_CAP1 | ESDHC_FLAG_HS200 |
1721                 ESDHC_FLAG_HS400 | ESDHC_FLAG_HS400_ES,
1722 };
1723
1724 static const struct udevice_id fsl_esdhc_ids[] = {
1725         { .compatible = "fsl,imx51-esdhc", },
1726         { .compatible = "fsl,imx53-esdhc", },
1727         { .compatible = "fsl,imx6ul-usdhc", },
1728         { .compatible = "fsl,imx6sx-usdhc", },
1729         { .compatible = "fsl,imx6sl-usdhc", },
1730         { .compatible = "fsl,imx6q-usdhc", },
1731         { .compatible = "fsl,imx7d-usdhc", .data = (ulong)&usdhc_imx7d_data,},
1732         { .compatible = "fsl,imx7ulp-usdhc", },
1733         { .compatible = "fsl,imx8qm-usdhc", .data = (ulong)&usdhc_imx8qm_data,},
1734         { .compatible = "fsl,imx8mm-usdhc", .data = (ulong)&usdhc_imx8qm_data,},
1735         { .compatible = "fsl,imx8mn-usdhc", .data = (ulong)&usdhc_imx8qm_data,},
1736         { .compatible = "fsl,imx8mq-usdhc", .data = (ulong)&usdhc_imx8qm_data,},
1737         { .compatible = "fsl,imxrt-usdhc", },
1738         { .compatible = "fsl,esdhc", },
1739         { /* sentinel */ }
1740 };
1741
1742 #if CONFIG_IS_ENABLED(BLK)
1743 static int fsl_esdhc_bind(struct udevice *dev)
1744 {
1745         struct fsl_esdhc_plat *plat = dev_get_plat(dev);
1746
1747         return mmc_bind(dev, &plat->mmc, &plat->cfg);
1748 }
1749 #endif
1750
1751 U_BOOT_DRIVER(fsl_esdhc) = {
1752         .name   = "fsl_esdhc",
1753         .id     = UCLASS_MMC,
1754         .of_match = fsl_esdhc_ids,
1755         .of_to_plat = fsl_esdhc_of_to_plat,
1756         .ops    = &fsl_esdhc_ops,
1757 #if CONFIG_IS_ENABLED(BLK)
1758         .bind   = fsl_esdhc_bind,
1759 #endif
1760         .probe  = fsl_esdhc_probe,
1761         .plat_auto      = sizeof(struct fsl_esdhc_plat),
1762         .priv_auto      = sizeof(struct fsl_esdhc_priv),
1763 };
1764
1765 DM_DRIVER_ALIAS(fsl_esdhc, fsl_imx6q_usdhc)
1766 #endif