drivers/mmc/host/sdhci-of-dwcmshc.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Driver for Synopsys DesignWare Cores Mobile Storage Host Controller
   4  *
   5  * Copyright (C) 2018 Synaptics Incorporated
   6  *
   7  * Author: Jisheng Zhang <jszhang@kernel.org>
   8  */
   9
  10 #include <linux/acpi.h>
  11 #include <linux/clk.h>
  12 #include <linux/dma-mapping.h>
  13 #include <linux/iopoll.h>
  14 #include <linux/kernel.h>
  15 #include <linux/module.h>
  16 #include <linux/of.h>
  17 #include <linux/of_device.h>
  18 #include <linux/reset.h>
  19 #include <linux/sizes.h>
  20
  21 #include "sdhci-pltfm.h"
  22
  23 #define SDHCI_DWCMSHC_ARG2_STUFF        GENMASK(31, 16)
  24
  25 /* DWCMSHC specific Mode Select value */
  26 #define DWCMSHC_CTRL_HS400              0x7
  27
  28 /* DWC IP vendor area 1 pointer */
  29 #define DWCMSHC_P_VENDOR_AREA1          0xe8
  30 #define DWCMSHC_AREA1_MASK              GENMASK(11, 0)
  31 /* Offset inside the  vendor area 1 */
  32 #define DWCMSHC_HOST_CTRL3              0x8
  33 #define DWCMSHC_EMMC_CONTROL            0x2c
  34 #define DWCMSHC_CARD_IS_EMMC            BIT(0)
  35 #define DWCMSHC_ENHANCED_STROBE         BIT(8)
  36 #define DWCMSHC_EMMC_ATCTRL             0x40
  37
  38 /* Rockchip specific Registers */
  39 #define DWCMSHC_EMMC_DLL_CTRL           0x800
  40 #define DWCMSHC_EMMC_DLL_RXCLK          0x804
  41 #define DWCMSHC_EMMC_DLL_TXCLK          0x808
  42 #define DWCMSHC_EMMC_DLL_STRBIN         0x80c
  43 #define DECMSHC_EMMC_DLL_CMDOUT         0x810
  44 #define DWCMSHC_EMMC_DLL_STATUS0        0x840
  45 #define DWCMSHC_EMMC_DLL_START          BIT(0)
  46 #define DWCMSHC_EMMC_DLL_LOCKED         BIT(8)
  47 #define DWCMSHC_EMMC_DLL_TIMEOUT        BIT(9)
  48 #define DWCMSHC_EMMC_DLL_RXCLK_SRCSEL   29
  49 #define DWCMSHC_EMMC_DLL_START_POINT    16
  50 #define DWCMSHC_EMMC_DLL_INC            8
  51 #define DWCMSHC_EMMC_DLL_DLYENA         BIT(27)
  52 #define DLL_TXCLK_TAPNUM_DEFAULT        0x10
  53 #define DLL_TXCLK_TAPNUM_90_DEGREES     0xA
  54 #define DLL_TXCLK_TAPNUM_FROM_SW        BIT(24)
  55 #define DLL_STRBIN_TAPNUM_DEFAULT       0x8
  56 #define DLL_STRBIN_TAPNUM_FROM_SW       BIT(24)
  57 #define DLL_STRBIN_DELAY_NUM_SEL        BIT(26)
  58 #define DLL_STRBIN_DELAY_NUM_OFFSET     16
  59 #define DLL_STRBIN_DELAY_NUM_DEFAULT    0x16
  60 #define DLL_RXCLK_NO_INVERTER           1
  61 #define DLL_RXCLK_INVERTER              0
  62 #define DLL_CMDOUT_TAPNUM_90_DEGREES    0x8
  63 #define DLL_CMDOUT_TAPNUM_FROM_SW       BIT(24)
  64 #define DLL_CMDOUT_SRC_CLK_NEG          BIT(28)
  65 #define DLL_CMDOUT_EN_SRC_CLK_NEG       BIT(29)
  66
  67 #define DLL_LOCK_WO_TMOUT(x) \
  68         ((((x) & DWCMSHC_EMMC_DLL_LOCKED) == DWCMSHC_EMMC_DLL_LOCKED) && \
  69         (((x) & DWCMSHC_EMMC_DLL_TIMEOUT) == 0))
  70 #define RK35xx_MAX_CLKS 3
  71
  72 #define BOUNDARY_OK(addr, len) \
  73         ((addr | (SZ_128M - 1)) == ((addr + len - 1) | (SZ_128M - 1)))
  74
  75 enum dwcmshc_rk_type {
  76         DWCMSHC_RK3568,
  77         DWCMSHC_RK3588,
  78 };
  79
  80 struct rk35xx_priv {
  81         /* Rockchip specified optional clocks */
  82         struct clk_bulk_data rockchip_clks[RK35xx_MAX_CLKS];
  83         struct reset_control *reset;
  84         enum dwcmshc_rk_type devtype;
  85         u8 txclk_tapnum;
  86 };
  87
  88 struct dwcmshc_priv {
  89         struct clk      *bus_clk;
  90         int vendor_specific_area1; /* P_VENDOR_SPECIFIC_AREA reg */
  91         void *priv; /* pointer to SoC private stuff */
  92 };
  93
  94 /*
  95  * If DMA addr spans 128MB boundary, we split the DMA transfer into two
  96  * so that each DMA transfer doesn't exceed the boundary.
  97  */
  98 static void dwcmshc_adma_write_desc(struct sdhci_host *host, void **desc,
  99                                     dma_addr_t addr, int len, unsigned int cmd)
 100 {
 101         int tmplen, offset;
 102
 103         if (likely(!len || BOUNDARY_OK(addr, len))) {
 104                 sdhci_adma_write_desc(host, desc, addr, len, cmd);
 105                 return;
 106         }
 107
 108         offset = addr & (SZ_128M - 1);
 109         tmplen = SZ_128M - offset;
 110         sdhci_adma_write_desc(host, desc, addr, tmplen, cmd);
 111
 112         addr += tmplen;
 113         len -= tmplen;
 114         sdhci_adma_write_desc(host, desc, addr, len, cmd);
 115 }
 116
 117 static unsigned int dwcmshc_get_max_clock(struct sdhci_host *host)
 118 {
 119         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
 120
 121         if (pltfm_host->clk)
 122                 return sdhci_pltfm_clk_get_max_clock(host);
 123         else
 124                 return pltfm_host->clock;
 125 }
 126
 127 static void dwcmshc_check_auto_cmd23(struct mmc_host *mmc,
 128                                      struct mmc_request *mrq)
 129 {
 130         struct sdhci_host *host = mmc_priv(mmc);
 131
 132         /*
 133          * No matter V4 is enabled or not, ARGUMENT2 register is 32-bit
 134          * block count register which doesn't support stuff bits of
 135          * CMD23 argument on dwcmsch host controller.
 136          */
 137         if (mrq->sbc && (mrq->sbc->arg & SDHCI_DWCMSHC_ARG2_STUFF))
 138                 host->flags &= ~SDHCI_AUTO_CMD23;
 139         else
 140                 host->flags |= SDHCI_AUTO_CMD23;
 141 }
 142
 143 static void dwcmshc_request(struct mmc_host *mmc, struct mmc_request *mrq)
 144 {
 145         dwcmshc_check_auto_cmd23(mmc, mrq);
 146
 147         sdhci_request(mmc, mrq);
 148 }
 149
 150 static void dwcmshc_set_uhs_signaling(struct sdhci_host *host,
 151                                       unsigned int timing)
 152 {
 153         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
 154         struct dwcmshc_priv *priv = sdhci_pltfm_priv(pltfm_host);
 155         u16 ctrl, ctrl_2;
 156
 157         ctrl_2 = sdhci_readw(host, SDHCI_HOST_CONTROL2);
 158         /* Select Bus Speed Mode for host */
 159         ctrl_2 &= ~SDHCI_CTRL_UHS_MASK;
 160         if ((timing == MMC_TIMING_MMC_HS200) ||
 161             (timing == MMC_TIMING_UHS_SDR104))
 162                 ctrl_2 |= SDHCI_CTRL_UHS_SDR104;
 163         else if (timing == MMC_TIMING_UHS_SDR12)
 164                 ctrl_2 |= SDHCI_CTRL_UHS_SDR12;
 165         else if ((timing == MMC_TIMING_UHS_SDR25) ||
 166                  (timing == MMC_TIMING_MMC_HS))
 167                 ctrl_2 |= SDHCI_CTRL_UHS_SDR25;
 168         else if (timing == MMC_TIMING_UHS_SDR50)
 169                 ctrl_2 |= SDHCI_CTRL_UHS_SDR50;
 170         else if ((timing == MMC_TIMING_UHS_DDR50) ||
 171                  (timing == MMC_TIMING_MMC_DDR52))
 172                 ctrl_2 |= SDHCI_CTRL_UHS_DDR50;
 173         else if (timing == MMC_TIMING_MMC_HS400) {
 174                 /* set CARD_IS_EMMC bit to enable Data Strobe for HS400 */
 175                 ctrl = sdhci_readw(host, priv->vendor_specific_area1 + DWCMSHC_EMMC_CONTROL);
 176                 ctrl |= DWCMSHC_CARD_IS_EMMC;
 177                 sdhci_writew(host, ctrl, priv->vendor_specific_area1 + DWCMSHC_EMMC_CONTROL);
 178
 179                 ctrl_2 |= DWCMSHC_CTRL_HS400;
 180         }
 181
 182         sdhci_writew(host, ctrl_2, SDHCI_HOST_CONTROL2);
 183 }
 184
 185 static void dwcmshc_hs400_enhanced_strobe(struct mmc_host *mmc,
 186                                           struct mmc_ios *ios)
 187 {
 188         u32 vendor;
 189         struct sdhci_host *host = mmc_priv(mmc);
 190         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
 191         struct dwcmshc_priv *priv = sdhci_pltfm_priv(pltfm_host);
 192         int reg = priv->vendor_specific_area1 + DWCMSHC_EMMC_CONTROL;
 193
 194         vendor = sdhci_readl(host, reg);
 195         if (ios->enhanced_strobe)
 196                 vendor |= DWCMSHC_ENHANCED_STROBE;
 197         else
 198                 vendor &= ~DWCMSHC_ENHANCED_STROBE;
 199
 200         sdhci_writel(host, vendor, reg);
 201 }
 202
 203 static void dwcmshc_rk3568_set_clock(struct sdhci_host *host, unsigned int clock)
 204 {
 205         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
 206         struct dwcmshc_priv *dwc_priv = sdhci_pltfm_priv(pltfm_host);
 207         struct rk35xx_priv *priv = dwc_priv->priv;
 208         u8 txclk_tapnum = DLL_TXCLK_TAPNUM_DEFAULT;
 209         u32 extra, reg;
 210         int err;
 211
 212         host->mmc->actual_clock = 0;
 213
 214         if (clock == 0) {
 215                 /* Disable interface clock at initial state. */
 216                 sdhci_set_clock(host, clock);
 217                 return;
 218         }
 219
 220         /* Rockchip platform only support 375KHz for identify mode */
 221         if (clock <= 400000)
 222                 clock = 375000;
 223
 224         err = clk_set_rate(pltfm_host->clk, clock);
 225         if (err)
 226                 dev_err(mmc_dev(host->mmc), "fail to set clock %d", clock);
 227
 228         sdhci_set_clock(host, clock);
 229
 230         /* Disable cmd conflict check */
 231         reg = dwc_priv->vendor_specific_area1 + DWCMSHC_HOST_CTRL3;
 232         extra = sdhci_readl(host, reg);
 233         extra &= ~BIT(0);
 234         sdhci_writel(host, extra, reg);
 235
 236         if (clock <= 52000000) {
 237                 /* Disable DLL and reset both of sample and drive clock */
 238                 sdhci_writel(host, 0, DWCMSHC_EMMC_DLL_CTRL);
 239                 sdhci_writel(host, 0, DWCMSHC_EMMC_DLL_RXCLK);
 240                 sdhci_writel(host, 0, DWCMSHC_EMMC_DLL_TXCLK);
 241                 sdhci_writel(host, 0, DECMSHC_EMMC_DLL_CMDOUT);
 242                 /*
 243                  * Before switching to hs400es mode, the driver will enable
 244                  * enhanced strobe first. PHY needs to configure the parameters
 245                  * of enhanced strobe first.
 246                  */
 247                 extra = DWCMSHC_EMMC_DLL_DLYENA |
 248                         DLL_STRBIN_DELAY_NUM_SEL |
 249                         DLL_STRBIN_DELAY_NUM_DEFAULT << DLL_STRBIN_DELAY_NUM_OFFSET;
 250                 sdhci_writel(host, extra, DWCMSHC_EMMC_DLL_STRBIN);
 251                 return;
 252         }
 253
 254         /* Reset DLL */
 255         sdhci_writel(host, BIT(1), DWCMSHC_EMMC_DLL_CTRL);
 256         udelay(1);
 257         sdhci_writel(host, 0x0, DWCMSHC_EMMC_DLL_CTRL);
 258
 259         /*
 260          * We shouldn't set DLL_RXCLK_NO_INVERTER for identify mode but
 261          * we must set it in higher speed mode.
 262          */
 263         extra = DWCMSHC_EMMC_DLL_DLYENA;
 264         if (priv->devtype == DWCMSHC_RK3568)
 265                 extra |= DLL_RXCLK_NO_INVERTER << DWCMSHC_EMMC_DLL_RXCLK_SRCSEL;
 266         sdhci_writel(host, extra, DWCMSHC_EMMC_DLL_RXCLK);
 267
 268         /* Init DLL settings */
 269         extra = 0x5 << DWCMSHC_EMMC_DLL_START_POINT |
 270                 0x2 << DWCMSHC_EMMC_DLL_INC |
 271                 DWCMSHC_EMMC_DLL_START;
 272         sdhci_writel(host, extra, DWCMSHC_EMMC_DLL_CTRL);
 273         err = readl_poll_timeout(host->ioaddr + DWCMSHC_EMMC_DLL_STATUS0,
 274                                  extra, DLL_LOCK_WO_TMOUT(extra), 1,
 275                                  500 * USEC_PER_MSEC);
 276         if (err) {
 277                 dev_err(mmc_dev(host->mmc), "DLL lock timeout!\n");
 278                 return;
 279         }
 280
 281         extra = 0x1 << 16 | /* tune clock stop en */
 282                 0x2 << 17 | /* pre-change delay */
 283                 0x3 << 19;  /* post-change delay */
 284         sdhci_writel(host, extra, dwc_priv->vendor_specific_area1 + DWCMSHC_EMMC_ATCTRL);
 285
 286         if (host->mmc->ios.timing == MMC_TIMING_MMC_HS200 ||
 287             host->mmc->ios.timing == MMC_TIMING_MMC_HS400)
 288                 txclk_tapnum = priv->txclk_tapnum;
 289
 290         if ((priv->devtype == DWCMSHC_RK3588) && host->mmc->ios.timing == MMC_TIMING_MMC_HS400) {
 291                 txclk_tapnum = DLL_TXCLK_TAPNUM_90_DEGREES;
 292
 293                 extra = DLL_CMDOUT_SRC_CLK_NEG |
 294                         DLL_CMDOUT_EN_SRC_CLK_NEG |
 295                         DWCMSHC_EMMC_DLL_DLYENA |
 296                         DLL_CMDOUT_TAPNUM_90_DEGREES |
 297                         DLL_CMDOUT_TAPNUM_FROM_SW;
 298                 sdhci_writel(host, extra, DECMSHC_EMMC_DLL_CMDOUT);
 299         }
 300
 301         extra = DWCMSHC_EMMC_DLL_DLYENA |
 302                 DLL_TXCLK_TAPNUM_FROM_SW |
 303                 DLL_RXCLK_NO_INVERTER << DWCMSHC_EMMC_DLL_RXCLK_SRCSEL |
 304                 txclk_tapnum;
 305         sdhci_writel(host, extra, DWCMSHC_EMMC_DLL_TXCLK);
 306
 307         extra = DWCMSHC_EMMC_DLL_DLYENA |
 308                 DLL_STRBIN_TAPNUM_DEFAULT |
 309                 DLL_STRBIN_TAPNUM_FROM_SW;
 310         sdhci_writel(host, extra, DWCMSHC_EMMC_DLL_STRBIN);
 311 }
 312
 313 static void rk35xx_sdhci_reset(struct sdhci_host *host, u8 mask)
 314 {
 315         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
 316         struct dwcmshc_priv *dwc_priv = sdhci_pltfm_priv(pltfm_host);
 317         struct rk35xx_priv *priv = dwc_priv->priv;
 318
 319         if (mask & SDHCI_RESET_ALL && priv->reset) {
 320                 reset_control_assert(priv->reset);
 321                 udelay(1);
 322                 reset_control_deassert(priv->reset);
 323         }
 324
 325         sdhci_reset(host, mask);
 326 }
 327
 328 static const struct sdhci_ops sdhci_dwcmshc_ops = {
 329         .set_clock              = sdhci_set_clock,
 330         .set_bus_width          = sdhci_set_bus_width,
 331         .set_uhs_signaling      = dwcmshc_set_uhs_signaling,
 332         .get_max_clock          = dwcmshc_get_max_clock,
 333         .reset                  = sdhci_reset,
 334         .adma_write_desc        = dwcmshc_adma_write_desc,
 335 };
 336
 337 static const struct sdhci_ops sdhci_dwcmshc_rk35xx_ops = {
 338         .set_clock              = dwcmshc_rk3568_set_clock,
 339         .set_bus_width          = sdhci_set_bus_width,
 340         .set_uhs_signaling      = dwcmshc_set_uhs_signaling,
 341         .get_max_clock          = sdhci_pltfm_clk_get_max_clock,
 342         .reset                  = rk35xx_sdhci_reset,
 343         .adma_write_desc        = dwcmshc_adma_write_desc,
 344 };
 345
 346 static const struct sdhci_pltfm_data sdhci_dwcmshc_pdata = {
 347         .ops = &sdhci_dwcmshc_ops,
 348         .quirks = SDHCI_QUIRK_CAP_CLOCK_BASE_BROKEN,
 349         .quirks2 = SDHCI_QUIRK2_PRESET_VALUE_BROKEN,
 350 };
 351
 352 #ifdef CONFIG_ACPI
 353 static const struct sdhci_pltfm_data sdhci_dwcmshc_bf3_pdata = {
 354         .ops = &sdhci_dwcmshc_ops,
 355         .quirks = SDHCI_QUIRK_CAP_CLOCK_BASE_BROKEN,
 356         .quirks2 = SDHCI_QUIRK2_PRESET_VALUE_BROKEN |
 357                    SDHCI_QUIRK2_ACMD23_BROKEN,
 358 };
 359 #endif
 360
 361 static const struct sdhci_pltfm_data sdhci_dwcmshc_rk35xx_pdata = {
 362         .ops = &sdhci_dwcmshc_rk35xx_ops,
 363         .quirks = SDHCI_QUIRK_CAP_CLOCK_BASE_BROKEN |
 364                   SDHCI_QUIRK_BROKEN_TIMEOUT_VAL,
 365         .quirks2 = SDHCI_QUIRK2_PRESET_VALUE_BROKEN |
 366                    SDHCI_QUIRK2_CLOCK_DIV_ZERO_BROKEN,
 367 };
 368
 369 static int dwcmshc_rk35xx_init(struct sdhci_host *host, struct dwcmshc_priv *dwc_priv)
 370 {
 371         int err;
 372         struct rk35xx_priv *priv = dwc_priv->priv;
 373
 374         priv->reset = devm_reset_control_array_get_optional_exclusive(mmc_dev(host->mmc));
 375         if (IS_ERR(priv->reset)) {
 376                 err = PTR_ERR(priv->reset);
 377                 dev_err(mmc_dev(host->mmc), "failed to get reset control %d\n", err);
 378                 return err;
 379         }
 380
 381         priv->rockchip_clks[0].id = "axi";
 382         priv->rockchip_clks[1].id = "block";
 383         priv->rockchip_clks[2].id = "timer";
 384         err = devm_clk_bulk_get_optional(mmc_dev(host->mmc), RK35xx_MAX_CLKS,
 385                                          priv->rockchip_clks);
 386         if (err) {
 387                 dev_err(mmc_dev(host->mmc), "failed to get clocks %d\n", err);
 388                 return err;
 389         }
 390
 391         err = clk_bulk_prepare_enable(RK35xx_MAX_CLKS, priv->rockchip_clks);
 392         if (err) {
 393                 dev_err(mmc_dev(host->mmc), "failed to enable clocks %d\n", err);
 394                 return err;
 395         }
 396
 397         if (of_property_read_u8(mmc_dev(host->mmc)->of_node, "rockchip,txclk-tapnum",
 398                                 &priv->txclk_tapnum))
 399                 priv->txclk_tapnum = DLL_TXCLK_TAPNUM_DEFAULT;
 400
 401         /* Disable cmd conflict check */
 402         sdhci_writel(host, 0x0, dwc_priv->vendor_specific_area1 + DWCMSHC_HOST_CTRL3);
 403         /* Reset previous settings */
 404         sdhci_writel(host, 0, DWCMSHC_EMMC_DLL_TXCLK);
 405         sdhci_writel(host, 0, DWCMSHC_EMMC_DLL_STRBIN);
 406
 407         return 0;
 408 }
 409
 410 static void dwcmshc_rk35xx_postinit(struct sdhci_host *host, struct dwcmshc_priv *dwc_priv)
 411 {
 412         /*
 413          * Don't support highspeed bus mode with low clk speed as we
 414          * cannot use DLL for this condition.
 415          */
 416         if (host->mmc->f_max <= 52000000) {
 417                 dev_info(mmc_dev(host->mmc), "Disabling HS200/HS400, frequency too low (%d)\n",
 418                          host->mmc->f_max);
 419                 host->mmc->caps2 &= ~(MMC_CAP2_HS200 | MMC_CAP2_HS400);
 420                 host->mmc->caps &= ~(MMC_CAP_3_3V_DDR | MMC_CAP_1_8V_DDR);
 421         }
 422 }
 423
 424 static const struct of_device_id sdhci_dwcmshc_dt_ids[] = {
 425         {
 426                 .compatible = "rockchip,rk3588-dwcmshc",
 427                 .data = &sdhci_dwcmshc_rk35xx_pdata,
 428         },
 429         {
 430                 .compatible = "rockchip,rk3568-dwcmshc",
 431                 .data = &sdhci_dwcmshc_rk35xx_pdata,
 432         },
 433         {
 434                 .compatible = "snps,dwcmshc-sdhci",
 435                 .data = &sdhci_dwcmshc_pdata,
 436         },
 437         {},
 438 };
 439 MODULE_DEVICE_TABLE(of, sdhci_dwcmshc_dt_ids);
 440
 441 #ifdef CONFIG_ACPI
 442 static const struct acpi_device_id sdhci_dwcmshc_acpi_ids[] = {
 443         {
 444                 .id = "MLNXBF30",
 445                 .driver_data = (kernel_ulong_t)&sdhci_dwcmshc_bf3_pdata,
 446         },
 447         {}
 448 };
 449 #endif
 450
 451 static int dwcmshc_probe(struct platform_device *pdev)
 452 {
 453         struct device *dev = &pdev->dev;
 454         struct sdhci_pltfm_host *pltfm_host;
 455         struct sdhci_host *host;
 456         struct dwcmshc_priv *priv;
 457         struct rk35xx_priv *rk_priv = NULL;
 458         const struct sdhci_pltfm_data *pltfm_data;
 459         int err;
 460         u32 extra;
 461
 462         pltfm_data = device_get_match_data(&pdev->dev);
 463         if (!pltfm_data) {
 464                 dev_err(&pdev->dev, "Error: No device match data found\n");
 465                 return -ENODEV;
 466         }
 467
 468         host = sdhci_pltfm_init(pdev, pltfm_data,
 469                                 sizeof(struct dwcmshc_priv));
 470         if (IS_ERR(host))
 471                 return PTR_ERR(host);
 472
 473         /*
 474          * extra adma table cnt for cross 128M boundary handling.
 475          */
 476         extra = DIV_ROUND_UP_ULL(dma_get_required_mask(dev), SZ_128M);
 477         if (extra > SDHCI_MAX_SEGS)
 478                 extra = SDHCI_MAX_SEGS;
 479         host->adma_table_cnt += extra;
 480
 481         pltfm_host = sdhci_priv(host);
 482         priv = sdhci_pltfm_priv(pltfm_host);
 483
 484         if (dev->of_node) {
 485                 pltfm_host->clk = devm_clk_get(dev, "core");
 486                 if (IS_ERR(pltfm_host->clk)) {
 487                         err = PTR_ERR(pltfm_host->clk);
 488                         dev_err(dev, "failed to get core clk: %d\n", err);
 489                         goto free_pltfm;
 490                 }
 491                 err = clk_prepare_enable(pltfm_host->clk);
 492                 if (err)
 493                         goto free_pltfm;
 494
 495                 priv->bus_clk = devm_clk_get(dev, "bus");
 496                 if (!IS_ERR(priv->bus_clk))
 497                         clk_prepare_enable(priv->bus_clk);
 498         }
 499
 500         err = mmc_of_parse(host->mmc);
 501         if (err)
 502                 goto err_clk;
 503
 504         sdhci_get_of_property(pdev);
 505
 506         priv->vendor_specific_area1 =
 507                 sdhci_readl(host, DWCMSHC_P_VENDOR_AREA1) & DWCMSHC_AREA1_MASK;
 508
 509         host->mmc_host_ops.request = dwcmshc_request;
 510         host->mmc_host_ops.hs400_enhanced_strobe = dwcmshc_hs400_enhanced_strobe;
 511
 512         if (pltfm_data == &sdhci_dwcmshc_rk35xx_pdata) {
 513                 rk_priv = devm_kzalloc(&pdev->dev, sizeof(struct rk35xx_priv), GFP_KERNEL);
 514                 if (!rk_priv) {
 515                         err = -ENOMEM;
 516                         goto err_clk;
 517                 }
 518
 519                 if (of_device_is_compatible(pdev->dev.of_node, "rockchip,rk3588-dwcmshc"))
 520                         rk_priv->devtype = DWCMSHC_RK3588;
 521                 else
 522                         rk_priv->devtype = DWCMSHC_RK3568;
 523
 524                 priv->priv = rk_priv;
 525
 526                 err = dwcmshc_rk35xx_init(host, priv);
 527                 if (err)
 528                         goto err_clk;
 529         }
 530
 531         host->mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY;
 532
 533         err = sdhci_setup_host(host);
 534         if (err)
 535                 goto err_clk;
 536
 537         if (rk_priv)
 538                 dwcmshc_rk35xx_postinit(host, priv);
 539
 540         err = __sdhci_add_host(host);
 541         if (err)
 542                 goto err_setup_host;
 543
 544         return 0;
 545
 546 err_setup_host:
 547         sdhci_cleanup_host(host);
 548 err_clk:
 549         clk_disable_unprepare(pltfm_host->clk);
 550         clk_disable_unprepare(priv->bus_clk);
 551         if (rk_priv)
 552                 clk_bulk_disable_unprepare(RK35xx_MAX_CLKS,
 553                                            rk_priv->rockchip_clks);
 554 free_pltfm:
 555         sdhci_pltfm_free(pdev);
 556         return err;
 557 }
 558
 559 static int dwcmshc_remove(struct platform_device *pdev)
 560 {
 561         struct sdhci_host *host = platform_get_drvdata(pdev);
 562         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
 563         struct dwcmshc_priv *priv = sdhci_pltfm_priv(pltfm_host);
 564         struct rk35xx_priv *rk_priv = priv->priv;
 565
 566         sdhci_remove_host(host, 0);
 567
 568         clk_disable_unprepare(pltfm_host->clk);
 569         clk_disable_unprepare(priv->bus_clk);
 570         if (rk_priv)
 571                 clk_bulk_disable_unprepare(RK35xx_MAX_CLKS,
 572                                            rk_priv->rockchip_clks);
 573         sdhci_pltfm_free(pdev);
 574
 575         return 0;
 576 }
 577
 578 #ifdef CONFIG_PM_SLEEP
 579 static int dwcmshc_suspend(struct device *dev)
 580 {
 581         struct sdhci_host *host = dev_get_drvdata(dev);
 582         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
 583         struct dwcmshc_priv *priv = sdhci_pltfm_priv(pltfm_host);
 584         struct rk35xx_priv *rk_priv = priv->priv;
 585         int ret;
 586
 587         ret = sdhci_suspend_host(host);
 588         if (ret)
 589                 return ret;
 590
 591         clk_disable_unprepare(pltfm_host->clk);
 592         if (!IS_ERR(priv->bus_clk))
 593                 clk_disable_unprepare(priv->bus_clk);
 594
 595         if (rk_priv)
 596                 clk_bulk_disable_unprepare(RK35xx_MAX_CLKS,
 597                                            rk_priv->rockchip_clks);
 598
 599         return ret;
 600 }
 601
 602 static int dwcmshc_resume(struct device *dev)
 603 {
 604         struct sdhci_host *host = dev_get_drvdata(dev);
 605         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
 606         struct dwcmshc_priv *priv = sdhci_pltfm_priv(pltfm_host);
 607         struct rk35xx_priv *rk_priv = priv->priv;
 608         int ret;
 609
 610         ret = clk_prepare_enable(pltfm_host->clk);
 611         if (ret)
 612                 return ret;
 613
 614         if (!IS_ERR(priv->bus_clk)) {
 615                 ret = clk_prepare_enable(priv->bus_clk);
 616                 if (ret)
 617                         return ret;
 618         }
 619
 620         if (rk_priv) {
 621                 ret = clk_bulk_prepare_enable(RK35xx_MAX_CLKS,
 622                                               rk_priv->rockchip_clks);
 623                 if (ret)
 624                         return ret;
 625         }
 626
 627         return sdhci_resume_host(host);
 628 }
 629 #endif
 630
 631 static SIMPLE_DEV_PM_OPS(dwcmshc_pmops, dwcmshc_suspend, dwcmshc_resume);
 632
 633 static struct platform_driver sdhci_dwcmshc_driver = {
 634         .driver = {
 635                 .name   = "sdhci-dwcmshc",
 636                 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
 637                 .of_match_table = sdhci_dwcmshc_dt_ids,
 638                 .acpi_match_table = ACPI_PTR(sdhci_dwcmshc_acpi_ids),
 639                 .pm = &dwcmshc_pmops,
 640         },
 641         .probe  = dwcmshc_probe,
 642         .remove = dwcmshc_remove,
 643 };
 644 module_platform_driver(sdhci_dwcmshc_driver);
 645
 646 MODULE_DESCRIPTION("SDHCI platform driver for Synopsys DWC MSHC");
 647 MODULE_AUTHOR("Jisheng Zhang <jszhang@kernel.org>");
 648 MODULE_LICENSE("GPL v2");