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