drivers/mmc/fsl_esdhc.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright 2007, 2010-2011 Freescale Semiconductor, Inc
   4  * Copyright 2019 NXP Semiconductors
   5  * Andy Fleming
   6  *
   7  * Based vaguely on the pxa mmc code:
   8  * (C) Copyright 2003
   9  * Kyle Harris, Nexus Technologies, Inc. kharris@nexus-tech.net
  10  */
  11
  12 #include <config.h>
  13 #include <common.h>
  14 #include <command.h>
  15 #include <cpu_func.h>
  16 #include <errno.h>
  17 #include <hwconfig.h>
  18 #include <mmc.h>
  19 #include <part.h>
  20 #include <malloc.h>
  21 #include <fsl_esdhc.h>
  22 #include <fdt_support.h>
  23 #include <asm/cache.h>
  24 #include <asm/io.h>
  25 #include <dm.h>
  26 #include <dm/device_compat.h>
  27
  28 DECLARE_GLOBAL_DATA_PTR;
  29
  30 struct fsl_esdhc {
  31         uint    dsaddr;         /* SDMA system address register */
  32         uint    blkattr;        /* Block attributes register */
  33         uint    cmdarg;         /* Command argument register */
  34         uint    xfertyp;        /* Transfer type register */
  35         uint    cmdrsp0;        /* Command response 0 register */
  36         uint    cmdrsp1;        /* Command response 1 register */
  37         uint    cmdrsp2;        /* Command response 2 register */
  38         uint    cmdrsp3;        /* Command response 3 register */
  39         uint    datport;        /* Buffer data port register */
  40         uint    prsstat;        /* Present state register */
  41         uint    proctl;         /* Protocol control register */
  42         uint    sysctl;         /* System Control Register */
  43         uint    irqstat;        /* Interrupt status register */
  44         uint    irqstaten;      /* Interrupt status enable register */
  45         uint    irqsigen;       /* Interrupt signal enable register */
  46         uint    autoc12err;     /* Auto CMD error status register */
  47         uint    hostcapblt;     /* Host controller capabilities register */
  48         uint    wml;            /* Watermark level register */
  49         char    reserved1[8];   /* reserved */
  50         uint    fevt;           /* Force event register */
  51         uint    admaes;         /* ADMA error status register */
  52         uint    adsaddr;        /* ADMA system address register */
  53         char    reserved2[160];
  54         uint    hostver;        /* Host controller version register */
  55         char    reserved3[4];   /* reserved */
  56         uint    dmaerraddr;     /* DMA error address register */
  57         char    reserved4[4];   /* reserved */
  58         uint    dmaerrattr;     /* DMA error attribute register */
  59         char    reserved5[4];   /* reserved */
  60         uint    hostcapblt2;    /* Host controller capabilities register 2 */
  61         char    reserved6[756]; /* reserved */
  62         uint    esdhcctl;       /* eSDHC control register */
  63 };
  64
  65 struct fsl_esdhc_plat {
  66         struct mmc_config cfg;
  67         struct mmc mmc;
  68 };
  69
  70 /**
  71  * struct fsl_esdhc_priv
  72  *
  73  * @esdhc_regs: registers of the sdhc controller
  74  * @sdhc_clk: Current clk of the sdhc controller
  75  * @bus_width: bus width, 1bit, 4bit or 8bit
  76  * @cfg: mmc config
  77  * @mmc: mmc
  78  * Following is used when Driver Model is enabled for MMC
  79  * @dev: pointer for the device
  80  * @cd_gpio: gpio for card detection
  81  * @wp_gpio: gpio for write protection
  82  */
  83 struct fsl_esdhc_priv {
  84         struct fsl_esdhc *esdhc_regs;
  85         unsigned int sdhc_clk;
  86         bool is_sdhc_per_clk;
  87         unsigned int clock;
  88 #if !CONFIG_IS_ENABLED(DM_MMC)
  89         struct mmc *mmc;
  90 #endif
  91         struct udevice *dev;
  92 };
  93
  94 /* Return the XFERTYP flags for a given command and data packet */
  95 static uint esdhc_xfertyp(struct mmc_cmd *cmd, struct mmc_data *data)
  96 {
  97         uint xfertyp = 0;
  98
  99         if (data) {
 100                 xfertyp |= XFERTYP_DPSEL;
 101 #ifndef CONFIG_SYS_FSL_ESDHC_USE_PIO
 102                 xfertyp |= XFERTYP_DMAEN;
 103 #endif
 104                 if (data->blocks > 1) {
 105                         xfertyp |= XFERTYP_MSBSEL;
 106                         xfertyp |= XFERTYP_BCEN;
 107 #ifdef CONFIG_SYS_FSL_ERRATUM_ESDHC111
 108                         xfertyp |= XFERTYP_AC12EN;
 109 #endif
 110                 }
 111
 112                 if (data->flags & MMC_DATA_READ)
 113                         xfertyp |= XFERTYP_DTDSEL;
 114         }
 115
 116         if (cmd->resp_type & MMC_RSP_CRC)
 117                 xfertyp |= XFERTYP_CCCEN;
 118         if (cmd->resp_type & MMC_RSP_OPCODE)
 119                 xfertyp |= XFERTYP_CICEN;
 120         if (cmd->resp_type & MMC_RSP_136)
 121                 xfertyp |= XFERTYP_RSPTYP_136;
 122         else if (cmd->resp_type & MMC_RSP_BUSY)
 123                 xfertyp |= XFERTYP_RSPTYP_48_BUSY;
 124         else if (cmd->resp_type & MMC_RSP_PRESENT)
 125                 xfertyp |= XFERTYP_RSPTYP_48;
 126
 127         if (cmd->cmdidx == MMC_CMD_STOP_TRANSMISSION)
 128                 xfertyp |= XFERTYP_CMDTYP_ABORT;
 129
 130         return XFERTYP_CMD(cmd->cmdidx) | xfertyp;
 131 }
 132
 133 #ifdef CONFIG_SYS_FSL_ESDHC_USE_PIO
 134 /*
 135  * PIO Read/Write Mode reduce the performace as DMA is not used in this mode.
 136  */
 137 static void esdhc_pio_read_write(struct fsl_esdhc_priv *priv,
 138                                  struct mmc_data *data)
 139 {
 140         struct fsl_esdhc *regs = priv->esdhc_regs;
 141         uint blocks;
 142         char *buffer;
 143         uint databuf;
 144         uint size;
 145         uint irqstat;
 146         ulong start;
 147
 148         if (data->flags & MMC_DATA_READ) {
 149                 blocks = data->blocks;
 150                 buffer = data->dest;
 151                 while (blocks) {
 152                         start = get_timer(0);
 153                         size = data->blocksize;
 154                         irqstat = esdhc_read32(&regs->irqstat);
 155                         while (!(esdhc_read32(&regs->prsstat) & PRSSTAT_BREN)) {
 156                                 if (get_timer(start) > PIO_TIMEOUT) {
 157                                         printf("\nData Read Failed in PIO Mode.");
 158                                         return;
 159                                 }
 160                         }
 161                         while (size && (!(irqstat & IRQSTAT_TC))) {
 162                                 udelay(100); /* Wait before last byte transfer complete */
 163                                 irqstat = esdhc_read32(&regs->irqstat);
 164                                 databuf = in_le32(&regs->datport);
 165                                 *((uint *)buffer) = databuf;
 166                                 buffer += 4;
 167                                 size -= 4;
 168                         }
 169                         blocks--;
 170                 }
 171         } else {
 172                 blocks = data->blocks;
 173                 buffer = (char *)data->src;
 174                 while (blocks) {
 175                         start = get_timer(0);
 176                         size = data->blocksize;
 177                         irqstat = esdhc_read32(&regs->irqstat);
 178                         while (!(esdhc_read32(&regs->prsstat) & PRSSTAT_BWEN)) {
 179                                 if (get_timer(start) > PIO_TIMEOUT) {
 180                                         printf("\nData Write Failed in PIO Mode.");
 181                                         return;
 182                                 }
 183                         }
 184                         while (size && (!(irqstat & IRQSTAT_TC))) {
 185                                 udelay(100); /* Wait before last byte transfer complete */
 186                                 databuf = *((uint *)buffer);
 187                                 buffer += 4;
 188                                 size -= 4;
 189                                 irqstat = esdhc_read32(&regs->irqstat);
 190                                 out_le32(&regs->datport, databuf);
 191                         }
 192                         blocks--;
 193                 }
 194         }
 195 }
 196 #endif
 197
 198 static int esdhc_setup_data(struct fsl_esdhc_priv *priv, struct mmc *mmc,
 199                             struct mmc_data *data)
 200 {
 201         int timeout;
 202         struct fsl_esdhc *regs = priv->esdhc_regs;
 203 #if defined(CONFIG_FSL_LAYERSCAPE)
 204         dma_addr_t addr;
 205 #endif
 206         uint wml_value;
 207
 208         wml_value = data->blocksize/4;
 209
 210         if (data->flags & MMC_DATA_READ) {
 211                 if (wml_value > WML_RD_WML_MAX)
 212                         wml_value = WML_RD_WML_MAX_VAL;
 213
 214                 esdhc_clrsetbits32(&regs->wml, WML_RD_WML_MASK, wml_value);
 215 #ifndef CONFIG_SYS_FSL_ESDHC_USE_PIO
 216 #if defined(CONFIG_FSL_LAYERSCAPE)
 217                 addr = virt_to_phys((void *)(data->dest));
 218                 if (upper_32_bits(addr))
 219                         printf("Error found for upper 32 bits\n");
 220                 else
 221                         esdhc_write32(&regs->dsaddr, lower_32_bits(addr));
 222 #else
 223                 esdhc_write32(&regs->dsaddr, (u32)data->dest);
 224 #endif
 225 #endif
 226         } else {
 227 #ifndef CONFIG_SYS_FSL_ESDHC_USE_PIO
 228                 flush_dcache_range((ulong)data->src,
 229                                    (ulong)data->src+data->blocks
 230                                          *data->blocksize);
 231 #endif
 232                 if (wml_value > WML_WR_WML_MAX)
 233                         wml_value = WML_WR_WML_MAX_VAL;
 234
 235                 if (!(esdhc_read32(&regs->prsstat) & PRSSTAT_WPSPL)) {
 236                         printf("Can not write to locked SD card.\n");
 237                         return -EINVAL;
 238                 }
 239
 240                 esdhc_clrsetbits32(&regs->wml, WML_WR_WML_MASK,
 241                                         wml_value << 16);
 242 #ifndef CONFIG_SYS_FSL_ESDHC_USE_PIO
 243 #if defined(CONFIG_FSL_LAYERSCAPE)
 244                 addr = virt_to_phys((void *)(data->src));
 245                 if (upper_32_bits(addr))
 246                         printf("Error found for upper 32 bits\n");
 247                 else
 248                         esdhc_write32(&regs->dsaddr, lower_32_bits(addr));
 249 #else
 250                 esdhc_write32(&regs->dsaddr, (u32)data->src);
 251 #endif
 252 #endif
 253         }
 254
 255         esdhc_write32(&regs->blkattr, data->blocks << 16 | data->blocksize);
 256
 257         /* Calculate the timeout period for data transactions */
 258         /*
 259          * 1)Timeout period = (2^(timeout+13)) SD Clock cycles
 260          * 2)Timeout period should be minimum 0.250sec as per SD Card spec
 261          *  So, Number of SD Clock cycles for 0.25sec should be minimum
 262          *              (SD Clock/sec * 0.25 sec) SD Clock cycles
 263          *              = (mmc->clock * 1/4) SD Clock cycles
 264          * As 1) >=  2)
 265          * => (2^(timeout+13)) >= mmc->clock * 1/4
 266          * Taking log2 both the sides
 267          * => timeout + 13 >= log2(mmc->clock/4)
 268          * Rounding up to next power of 2
 269          * => timeout + 13 = log2(mmc->clock/4) + 1
 270          * => timeout + 13 = fls(mmc->clock/4)
 271          *
 272          * However, the MMC spec "It is strongly recommended for hosts to
 273          * implement more than 500ms timeout value even if the card
 274          * indicates the 250ms maximum busy length."  Even the previous
 275          * value of 300ms is known to be insufficient for some cards.
 276          * So, we use
 277          * => timeout + 13 = fls(mmc->clock/2)
 278          */
 279         timeout = fls(mmc->clock/2);
 280         timeout -= 13;
 281
 282         if (timeout > 14)
 283                 timeout = 14;
 284
 285         if (timeout < 0)
 286                 timeout = 0;
 287
 288 #ifdef CONFIG_SYS_FSL_ERRATUM_ESDHC_A001
 289         if ((timeout == 4) || (timeout == 8) || (timeout == 12))
 290                 timeout++;
 291 #endif
 292
 293 #ifdef ESDHCI_QUIRK_BROKEN_TIMEOUT_VALUE
 294         timeout = 0xE;
 295 #endif
 296         esdhc_clrsetbits32(&regs->sysctl, SYSCTL_TIMEOUT_MASK, timeout << 16);
 297
 298         return 0;
 299 }
 300
 301 static void check_and_invalidate_dcache_range
 302         (struct mmc_cmd *cmd,
 303          struct mmc_data *data) {
 304         unsigned start = 0;
 305         unsigned end = 0;
 306         unsigned size = roundup(ARCH_DMA_MINALIGN,
 307                                 data->blocks*data->blocksize);
 308 #if defined(CONFIG_FSL_LAYERSCAPE)
 309         dma_addr_t addr;
 310
 311         addr = virt_to_phys((void *)(data->dest));
 312         if (upper_32_bits(addr))
 313                 printf("Error found for upper 32 bits\n");
 314         else
 315                 start = lower_32_bits(addr);
 316 #else
 317         start = (unsigned)data->dest;
 318 #endif
 319         end = start + size;
 320         invalidate_dcache_range(start, end);
 321 }
 322
 323 /*
 324  * Sends a command out on the bus.  Takes the mmc pointer,
 325  * a command pointer, and an optional data pointer.
 326  */
 327 static int esdhc_send_cmd_common(struct fsl_esdhc_priv *priv, struct mmc *mmc,
 328                                  struct mmc_cmd *cmd, struct mmc_data *data)
 329 {
 330         int     err = 0;
 331         uint    xfertyp;
 332         uint    irqstat;
 333         u32     flags = IRQSTAT_CC | IRQSTAT_CTOE;
 334         struct fsl_esdhc *regs = priv->esdhc_regs;
 335         unsigned long start;
 336
 337 #ifdef CONFIG_SYS_FSL_ERRATUM_ESDHC111
 338         if (cmd->cmdidx == MMC_CMD_STOP_TRANSMISSION)
 339                 return 0;
 340 #endif
 341
 342         esdhc_write32(&regs->irqstat, -1);
 343
 344         sync();
 345
 346         /* Wait for the bus to be idle */
 347         while ((esdhc_read32(&regs->prsstat) & PRSSTAT_CICHB) ||
 348                         (esdhc_read32(&regs->prsstat) & PRSSTAT_CIDHB))
 349                 ;
 350
 351         while (esdhc_read32(&regs->prsstat) & PRSSTAT_DLA)
 352                 ;
 353
 354         /* Wait at least 8 SD clock cycles before the next command */
 355         /*
 356          * Note: This is way more than 8 cycles, but 1ms seems to
 357          * resolve timing issues with some cards
 358          */
 359         udelay(1000);
 360
 361         /* Set up for a data transfer if we have one */
 362         if (data) {
 363                 err = esdhc_setup_data(priv, mmc, data);
 364                 if(err)
 365                         return err;
 366
 367                 if (data->flags & MMC_DATA_READ)
 368                         check_and_invalidate_dcache_range(cmd, data);
 369         }
 370
 371         /* Figure out the transfer arguments */
 372         xfertyp = esdhc_xfertyp(cmd, data);
 373
 374         /* Mask all irqs */
 375         esdhc_write32(&regs->irqsigen, 0);
 376
 377         /* Send the command */
 378         esdhc_write32(&regs->cmdarg, cmd->cmdarg);
 379         esdhc_write32(&regs->xfertyp, xfertyp);
 380
 381         /* Wait for the command to complete */
 382         start = get_timer(0);
 383         while (!(esdhc_read32(&regs->irqstat) & flags)) {
 384                 if (get_timer(start) > 1000) {
 385                         err = -ETIMEDOUT;
 386                         goto out;
 387                 }
 388         }
 389
 390         irqstat = esdhc_read32(&regs->irqstat);
 391
 392         if (irqstat & CMD_ERR) {
 393                 err = -ECOMM;
 394                 goto out;
 395         }
 396
 397         if (irqstat & IRQSTAT_CTOE) {
 398                 err = -ETIMEDOUT;
 399                 goto out;
 400         }
 401
 402         /* Workaround for ESDHC errata ENGcm03648 */
 403         if (!data && (cmd->resp_type & MMC_RSP_BUSY)) {
 404                 int timeout = 6000;
 405
 406                 /* Poll on DATA0 line for cmd with busy signal for 600 ms */
 407                 while (timeout > 0 && !(esdhc_read32(&regs->prsstat) &
 408                                         PRSSTAT_DAT0)) {
 409                         udelay(100);
 410                         timeout--;
 411                 }
 412
 413                 if (timeout <= 0) {
 414                         printf("Timeout waiting for DAT0 to go high!\n");
 415                         err = -ETIMEDOUT;
 416                         goto out;
 417                 }
 418         }
 419
 420         /* Copy the response to the response buffer */
 421         if (cmd->resp_type & MMC_RSP_136) {
 422                 u32 cmdrsp3, cmdrsp2, cmdrsp1, cmdrsp0;
 423
 424                 cmdrsp3 = esdhc_read32(&regs->cmdrsp3);
 425                 cmdrsp2 = esdhc_read32(&regs->cmdrsp2);
 426                 cmdrsp1 = esdhc_read32(&regs->cmdrsp1);
 427                 cmdrsp0 = esdhc_read32(&regs->cmdrsp0);
 428                 cmd->response[0] = (cmdrsp3 << 8) | (cmdrsp2 >> 24);
 429                 cmd->response[1] = (cmdrsp2 << 8) | (cmdrsp1 >> 24);
 430                 cmd->response[2] = (cmdrsp1 << 8) | (cmdrsp0 >> 24);
 431                 cmd->response[3] = (cmdrsp0 << 8);
 432         } else
 433                 cmd->response[0] = esdhc_read32(&regs->cmdrsp0);
 434
 435         /* Wait until all of the blocks are transferred */
 436         if (data) {
 437 #ifdef CONFIG_SYS_FSL_ESDHC_USE_PIO
 438                 esdhc_pio_read_write(priv, data);
 439 #else
 440                 do {
 441                         irqstat = esdhc_read32(&regs->irqstat);
 442
 443                         if (irqstat & IRQSTAT_DTOE) {
 444                                 err = -ETIMEDOUT;
 445                                 goto out;
 446                         }
 447
 448                         if (irqstat & DATA_ERR) {
 449                                 err = -ECOMM;
 450                                 goto out;
 451                         }
 452                 } while ((irqstat & DATA_COMPLETE) != DATA_COMPLETE);
 453
 454                 /*
 455                  * Need invalidate the dcache here again to avoid any
 456                  * cache-fill during the DMA operations such as the
 457                  * speculative pre-fetching etc.
 458                  */
 459                 if (data->flags & MMC_DATA_READ) {
 460                         check_and_invalidate_dcache_range(cmd, data);
 461                 }
 462 #endif
 463         }
 464
 465 out:
 466         /* Reset CMD and DATA portions on error */
 467         if (err) {
 468                 esdhc_write32(&regs->sysctl, esdhc_read32(&regs->sysctl) |
 469                               SYSCTL_RSTC);
 470                 while (esdhc_read32(&regs->sysctl) & SYSCTL_RSTC)
 471                         ;
 472
 473                 if (data) {
 474                         esdhc_write32(&regs->sysctl,
 475                                       esdhc_read32(&regs->sysctl) |
 476                                       SYSCTL_RSTD);
 477                         while ((esdhc_read32(&regs->sysctl) & SYSCTL_RSTD))
 478                                 ;
 479                 }
 480         }
 481
 482         esdhc_write32(&regs->irqstat, -1);
 483
 484         return err;
 485 }
 486
 487 static void set_sysctl(struct fsl_esdhc_priv *priv, struct mmc *mmc, uint clock)
 488 {
 489         struct fsl_esdhc *regs = priv->esdhc_regs;
 490         int div = 1;
 491         int pre_div = 2;
 492         unsigned int sdhc_clk = priv->sdhc_clk;
 493         u32 time_out;
 494         u32 value;
 495         uint clk;
 496
 497         if (clock < mmc->cfg->f_min)
 498                 clock = mmc->cfg->f_min;
 499
 500         while (sdhc_clk / (16 * pre_div) > clock && pre_div < 256)
 501                 pre_div *= 2;
 502
 503         while (sdhc_clk / (div * pre_div) > clock && div < 16)
 504                 div++;
 505
 506         pre_div >>= 1;
 507         div -= 1;
 508
 509         clk = (pre_div << 8) | (div << 4);
 510
 511         esdhc_clrbits32(&regs->sysctl, SYSCTL_CKEN);
 512
 513         esdhc_clrsetbits32(&regs->sysctl, SYSCTL_CLOCK_MASK, clk);
 514
 515         time_out = 20;
 516         value = PRSSTAT_SDSTB;
 517         while (!(esdhc_read32(&regs->prsstat) & value)) {
 518                 if (time_out == 0) {
 519                         printf("fsl_esdhc: Internal clock never stabilised.\n");
 520                         break;
 521                 }
 522                 time_out--;
 523                 mdelay(1);
 524         }
 525
 526         esdhc_setbits32(&regs->sysctl, SYSCTL_PEREN | SYSCTL_CKEN);
 527 }
 528
 529 static void esdhc_clock_control(struct fsl_esdhc_priv *priv, bool enable)
 530 {
 531         struct fsl_esdhc *regs = priv->esdhc_regs;
 532         u32 value;
 533         u32 time_out;
 534
 535         value = esdhc_read32(&regs->sysctl);
 536
 537         if (enable)
 538                 value |= SYSCTL_CKEN;
 539         else
 540                 value &= ~SYSCTL_CKEN;
 541
 542         esdhc_write32(&regs->sysctl, value);
 543
 544         time_out = 20;
 545         value = PRSSTAT_SDSTB;
 546         while (!(esdhc_read32(&regs->prsstat) & value)) {
 547                 if (time_out == 0) {
 548                         printf("fsl_esdhc: Internal clock never stabilised.\n");
 549                         break;
 550                 }
 551                 time_out--;
 552                 mdelay(1);
 553         }
 554 }
 555
 556 static int esdhc_set_ios_common(struct fsl_esdhc_priv *priv, struct mmc *mmc)
 557 {
 558         struct fsl_esdhc *regs = priv->esdhc_regs;
 559
 560         if (priv->is_sdhc_per_clk) {
 561                 /* Select to use peripheral clock */
 562                 esdhc_clock_control(priv, false);
 563                 esdhc_setbits32(&regs->esdhcctl, ESDHCCTL_PCS);
 564                 esdhc_clock_control(priv, true);
 565         }
 566
 567         /* Set the clock speed */
 568         if (priv->clock != mmc->clock)
 569                 set_sysctl(priv, mmc, mmc->clock);
 570
 571         /* Set the bus width */
 572         esdhc_clrbits32(&regs->proctl, PROCTL_DTW_4 | PROCTL_DTW_8);
 573
 574         if (mmc->bus_width == 4)
 575                 esdhc_setbits32(&regs->proctl, PROCTL_DTW_4);
 576         else if (mmc->bus_width == 8)
 577                 esdhc_setbits32(&regs->proctl, PROCTL_DTW_8);
 578
 579         return 0;
 580 }
 581
 582 static void esdhc_enable_cache_snooping(struct fsl_esdhc *regs)
 583 {
 584 #ifdef CONFIG_ARCH_MPC830X
 585         immap_t *immr = (immap_t *)CONFIG_SYS_IMMR;
 586         sysconf83xx_t *sysconf = &immr->sysconf;
 587
 588         setbits_be32(&sysconf->sdhccr, 0x02000000);
 589 #else
 590         esdhc_write32(&regs->esdhcctl, 0x00000040);
 591 #endif
 592 }
 593
 594 static int esdhc_init_common(struct fsl_esdhc_priv *priv, struct mmc *mmc)
 595 {
 596         struct fsl_esdhc *regs = priv->esdhc_regs;
 597         ulong start;
 598
 599         /* Reset the entire host controller */
 600         esdhc_setbits32(&regs->sysctl, SYSCTL_RSTA);
 601
 602         /* Wait until the controller is available */
 603         start = get_timer(0);
 604         while ((esdhc_read32(&regs->sysctl) & SYSCTL_RSTA)) {
 605                 if (get_timer(start) > 1000)
 606                         return -ETIMEDOUT;
 607         }
 608
 609         esdhc_enable_cache_snooping(regs);
 610
 611         esdhc_setbits32(&regs->sysctl, SYSCTL_HCKEN | SYSCTL_IPGEN);
 612
 613         /* Set the initial clock speed */
 614         mmc_set_clock(mmc, 400000, MMC_CLK_ENABLE);
 615
 616         /* Disable the BRR and BWR bits in IRQSTAT */
 617         esdhc_clrbits32(&regs->irqstaten, IRQSTATEN_BRR | IRQSTATEN_BWR);
 618
 619         /* Put the PROCTL reg back to the default */
 620         esdhc_write32(&regs->proctl, PROCTL_INIT);
 621
 622         /* Set timout to the maximum value */
 623         esdhc_clrsetbits32(&regs->sysctl, SYSCTL_TIMEOUT_MASK, 14 << 16);
 624
 625         return 0;
 626 }
 627
 628 static int esdhc_getcd_common(struct fsl_esdhc_priv *priv)
 629 {
 630         struct fsl_esdhc *regs = priv->esdhc_regs;
 631         int timeout = 1000;
 632
 633 #ifdef CONFIG_ESDHC_DETECT_QUIRK
 634         if (CONFIG_ESDHC_DETECT_QUIRK)
 635                 return 1;
 636 #endif
 637         while (!(esdhc_read32(&regs->prsstat) & PRSSTAT_CINS) && --timeout)
 638                 udelay(1000);
 639
 640         return timeout > 0;
 641 }
 642
 643 static void fsl_esdhc_get_cfg_common(struct fsl_esdhc_priv *priv,
 644                                      struct mmc_config *cfg)
 645 {
 646         struct fsl_esdhc *regs = priv->esdhc_regs;
 647         u32 caps;
 648
 649         caps = esdhc_read32(&regs->hostcapblt);
 650 #ifdef CONFIG_SYS_FSL_ERRATUM_ESDHC135
 651         caps &= ~(HOSTCAPBLT_SRS | HOSTCAPBLT_VS18 | HOSTCAPBLT_VS30);
 652 #endif
 653 #ifdef CONFIG_SYS_FSL_MMC_HAS_CAPBLT_VS33
 654         caps |= HOSTCAPBLT_VS33;
 655 #endif
 656         if (caps & HOSTCAPBLT_VS18)
 657                 cfg->voltages |= MMC_VDD_165_195;
 658         if (caps & HOSTCAPBLT_VS30)
 659                 cfg->voltages |= MMC_VDD_29_30 | MMC_VDD_30_31;
 660         if (caps & HOSTCAPBLT_VS33)
 661                 cfg->voltages |= MMC_VDD_32_33 | MMC_VDD_33_34;
 662
 663         cfg->name = "FSL_SDHC";
 664
 665         if (caps & HOSTCAPBLT_HSS)
 666                 cfg->host_caps |= MMC_MODE_HS_52MHz | MMC_MODE_HS;
 667
 668         cfg->f_min = 400000;
 669         cfg->f_max = min(priv->sdhc_clk, (u32)200000000);
 670         cfg->b_max = CONFIG_SYS_MMC_MAX_BLK_COUNT;
 671 }
 672
 673 #ifdef CONFIG_FSL_ESDHC_ADAPTER_IDENT
 674 void mmc_adapter_card_type_ident(void)
 675 {
 676         u8 card_id;
 677         u8 value;
 678
 679         card_id = QIXIS_READ(present) & QIXIS_SDID_MASK;
 680         gd->arch.sdhc_adapter = card_id;
 681
 682         switch (card_id) {
 683         case QIXIS_ESDHC_ADAPTER_TYPE_EMMC45:
 684                 value = QIXIS_READ(brdcfg[5]);
 685                 value |= (QIXIS_DAT4 | QIXIS_DAT5_6_7);
 686                 QIXIS_WRITE(brdcfg[5], value);
 687                 break;
 688         case QIXIS_ESDHC_ADAPTER_TYPE_SDMMC_LEGACY:
 689                 value = QIXIS_READ(pwr_ctl[1]);
 690                 value |= QIXIS_EVDD_BY_SDHC_VS;
 691                 QIXIS_WRITE(pwr_ctl[1], value);
 692                 break;
 693         case QIXIS_ESDHC_ADAPTER_TYPE_EMMC44:
 694                 value = QIXIS_READ(brdcfg[5]);
 695                 value |= (QIXIS_SDCLKIN | QIXIS_SDCLKOUT);
 696                 QIXIS_WRITE(brdcfg[5], value);
 697                 break;
 698         case QIXIS_ESDHC_ADAPTER_TYPE_RSV:
 699                 break;
 700         case QIXIS_ESDHC_ADAPTER_TYPE_MMC:
 701                 break;
 702         case QIXIS_ESDHC_ADAPTER_TYPE_SD:
 703                 break;
 704         case QIXIS_ESDHC_NO_ADAPTER:
 705                 break;
 706         default:
 707                 break;
 708         }
 709 }
 710 #endif
 711
 712 #ifdef CONFIG_OF_LIBFDT
 713 __weak int esdhc_status_fixup(void *blob, const char *compat)
 714 {
 715 #ifdef CONFIG_FSL_ESDHC_PIN_MUX
 716         if (!hwconfig("esdhc")) {
 717                 do_fixup_by_compat(blob, compat, "status", "disabled",
 718                                 sizeof("disabled"), 1);
 719                 return 1;
 720         }
 721 #endif
 722         return 0;
 723 }
 724
 725 void fdt_fixup_esdhc(void *blob, bd_t *bd)
 726 {
 727         const char *compat = "fsl,esdhc";
 728
 729         if (esdhc_status_fixup(blob, compat))
 730                 return;
 731
 732         do_fixup_by_compat_u32(blob, compat, "clock-frequency",
 733                                gd->arch.sdhc_clk, 1);
 734 }
 735 #endif
 736
 737 #if !CONFIG_IS_ENABLED(DM_MMC)
 738 static int esdhc_getcd(struct mmc *mmc)
 739 {
 740         struct fsl_esdhc_priv *priv = mmc->priv;
 741
 742         return esdhc_getcd_common(priv);
 743 }
 744
 745 static int esdhc_init(struct mmc *mmc)
 746 {
 747         struct fsl_esdhc_priv *priv = mmc->priv;
 748
 749         return esdhc_init_common(priv, mmc);
 750 }
 751
 752 static int esdhc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd,
 753                           struct mmc_data *data)
 754 {
 755         struct fsl_esdhc_priv *priv = mmc->priv;
 756
 757         return esdhc_send_cmd_common(priv, mmc, cmd, data);
 758 }
 759
 760 static int esdhc_set_ios(struct mmc *mmc)
 761 {
 762         struct fsl_esdhc_priv *priv = mmc->priv;
 763
 764         return esdhc_set_ios_common(priv, mmc);
 765 }
 766
 767 static const struct mmc_ops esdhc_ops = {
 768         .getcd          = esdhc_getcd,
 769         .init           = esdhc_init,
 770         .send_cmd       = esdhc_send_cmd,
 771         .set_ios        = esdhc_set_ios,
 772 };
 773
 774 int fsl_esdhc_initialize(bd_t *bis, struct fsl_esdhc_cfg *cfg)
 775 {
 776         struct fsl_esdhc_plat *plat;
 777         struct fsl_esdhc_priv *priv;
 778         struct mmc_config *mmc_cfg;
 779         struct mmc *mmc;
 780
 781         if (!cfg)
 782                 return -EINVAL;
 783
 784         priv = calloc(sizeof(struct fsl_esdhc_priv), 1);
 785         if (!priv)
 786                 return -ENOMEM;
 787         plat = calloc(sizeof(struct fsl_esdhc_plat), 1);
 788         if (!plat) {
 789                 free(priv);
 790                 return -ENOMEM;
 791         }
 792
 793         priv->esdhc_regs = (struct fsl_esdhc *)(unsigned long)(cfg->esdhc_base);
 794         priv->sdhc_clk = cfg->sdhc_clk;
 795         if (gd->arch.sdhc_per_clk)
 796                 priv->is_sdhc_per_clk = true;
 797
 798         mmc_cfg = &plat->cfg;
 799
 800         if (cfg->max_bus_width == 8) {
 801                 mmc_cfg->host_caps |= MMC_MODE_1BIT | MMC_MODE_4BIT |
 802                                       MMC_MODE_8BIT;
 803         } else if (cfg->max_bus_width == 4) {
 804                 mmc_cfg->host_caps |= MMC_MODE_1BIT | MMC_MODE_4BIT;
 805         } else if (cfg->max_bus_width == 1) {
 806                 mmc_cfg->host_caps |= MMC_MODE_1BIT;
 807         } else {
 808                 mmc_cfg->host_caps |= MMC_MODE_1BIT | MMC_MODE_4BIT |
 809                                       MMC_MODE_8BIT;
 810                 printf("No max bus width provided. Assume 8-bit supported.\n");
 811         }
 812
 813 #ifdef CONFIG_ESDHC_DETECT_8_BIT_QUIRK
 814         if (CONFIG_ESDHC_DETECT_8_BIT_QUIRK)
 815                 mmc_cfg->host_caps &= ~MMC_MODE_8BIT;
 816 #endif
 817         mmc_cfg->ops = &esdhc_ops;
 818
 819         fsl_esdhc_get_cfg_common(priv, mmc_cfg);
 820
 821         mmc = mmc_create(mmc_cfg, priv);
 822         if (!mmc)
 823                 return -EIO;
 824
 825         priv->mmc = mmc;
 826         return 0;
 827 }
 828
 829 int fsl_esdhc_mmc_init(bd_t *bis)
 830 {
 831         struct fsl_esdhc_cfg *cfg;
 832
 833         cfg = calloc(sizeof(struct fsl_esdhc_cfg), 1);
 834         cfg->esdhc_base = CONFIG_SYS_FSL_ESDHC_ADDR;
 835         /* Prefer peripheral clock which provides higher frequency. */
 836         if (gd->arch.sdhc_per_clk)
 837                 cfg->sdhc_clk = gd->arch.sdhc_per_clk;
 838         else
 839                 cfg->sdhc_clk = gd->arch.sdhc_clk;
 840         return fsl_esdhc_initialize(bis, cfg);
 841 }
 842 #else /* DM_MMC */
 843 static int fsl_esdhc_probe(struct udevice *dev)
 844 {
 845         struct mmc_uclass_priv *upriv = dev_get_uclass_priv(dev);
 846         struct fsl_esdhc_plat *plat = dev_get_platdata(dev);
 847         struct fsl_esdhc_priv *priv = dev_get_priv(dev);
 848         fdt_addr_t addr;
 849         struct mmc *mmc;
 850
 851         addr = dev_read_addr(dev);
 852         if (addr == FDT_ADDR_T_NONE)
 853                 return -EINVAL;
 854 #ifdef CONFIG_PPC
 855         priv->esdhc_regs = (struct fsl_esdhc *)lower_32_bits(addr);
 856 #else
 857         priv->esdhc_regs = (struct fsl_esdhc *)addr;
 858 #endif
 859         priv->dev = dev;
 860
 861         if (gd->arch.sdhc_per_clk) {
 862                 priv->sdhc_clk = gd->arch.sdhc_per_clk;
 863                 priv->is_sdhc_per_clk = true;
 864         } else {
 865                 priv->sdhc_clk = gd->arch.sdhc_clk;
 866         }
 867
 868         if (priv->sdhc_clk <= 0) {
 869                 dev_err(dev, "Unable to get clk for %s\n", dev->name);
 870                 return -EINVAL;
 871         }
 872
 873         fsl_esdhc_get_cfg_common(priv, &plat->cfg);
 874
 875         mmc_of_parse(dev, &plat->cfg);
 876
 877         mmc = &plat->mmc;
 878         mmc->cfg = &plat->cfg;
 879         mmc->dev = dev;
 880
 881         upriv->mmc = mmc;
 882
 883         return esdhc_init_common(priv, mmc);
 884 }
 885
 886 static int fsl_esdhc_get_cd(struct udevice *dev)
 887 {
 888         struct fsl_esdhc_plat *plat = dev_get_platdata(dev);
 889         struct fsl_esdhc_priv *priv = dev_get_priv(dev);
 890
 891         if (plat->cfg.host_caps & MMC_CAP_NONREMOVABLE)
 892                 return 1;
 893
 894         return esdhc_getcd_common(priv);
 895 }
 896
 897 static int fsl_esdhc_send_cmd(struct udevice *dev, struct mmc_cmd *cmd,
 898                               struct mmc_data *data)
 899 {
 900         struct fsl_esdhc_plat *plat = dev_get_platdata(dev);
 901         struct fsl_esdhc_priv *priv = dev_get_priv(dev);
 902
 903         return esdhc_send_cmd_common(priv, &plat->mmc, cmd, data);
 904 }
 905
 906 static int fsl_esdhc_set_ios(struct udevice *dev)
 907 {
 908         struct fsl_esdhc_plat *plat = dev_get_platdata(dev);
 909         struct fsl_esdhc_priv *priv = dev_get_priv(dev);
 910
 911         return esdhc_set_ios_common(priv, &plat->mmc);
 912 }
 913
 914 static const struct dm_mmc_ops fsl_esdhc_ops = {
 915         .get_cd         = fsl_esdhc_get_cd,
 916         .send_cmd       = fsl_esdhc_send_cmd,
 917         .set_ios        = fsl_esdhc_set_ios,
 918 #ifdef MMC_SUPPORTS_TUNING
 919         .execute_tuning = fsl_esdhc_execute_tuning,
 920 #endif
 921 };
 922
 923 static const struct udevice_id fsl_esdhc_ids[] = {
 924         { .compatible = "fsl,esdhc", },
 925         { /* sentinel */ }
 926 };
 927
 928 static int fsl_esdhc_bind(struct udevice *dev)
 929 {
 930         struct fsl_esdhc_plat *plat = dev_get_platdata(dev);
 931
 932         return mmc_bind(dev, &plat->mmc, &plat->cfg);
 933 }
 934
 935 U_BOOT_DRIVER(fsl_esdhc) = {
 936         .name   = "fsl-esdhc-mmc",
 937         .id     = UCLASS_MMC,
 938         .of_match = fsl_esdhc_ids,
 939         .ops    = &fsl_esdhc_ops,
 940         .bind   = fsl_esdhc_bind,
 941         .probe  = fsl_esdhc_probe,
 942         .platdata_auto_alloc_size = sizeof(struct fsl_esdhc_plat),
 943         .priv_auto_alloc_size = sizeof(struct fsl_esdhc_priv),
 944 };
 945 #endif