drivers/mmc/host/sdhci-xenon.c

   1 /*
   2  * Driver for Marvell Xenon SDHC as a platform device
   3  *
   4  * Copyright (C) 2016 Marvell, All Rights Reserved.
   5  *
   6  * Author:      Hu Ziji <huziji@marvell.com>
   7  * Date:        2016-8-24
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License as
  11  * published by the Free Software Foundation version 2.
  12  *
  13  * Inspired by Jisheng Zhang <jszhang@marvell.com>
  14  * Special thanks to Video BG4 project team.
  15  */
  16
  17 #include <linux/delay.h>
  18 #include <linux/ktime.h>
  19 #include <linux/module.h>
  20 #include <linux/of.h>
  21
  22 #include "sdhci-pltfm.h"
  23 #include "sdhci-xenon.h"
  24
  25 static int xenon_enable_internal_clk(struct sdhci_host *host)
  26 {
  27         u32 reg;
  28         ktime_t timeout;
  29
  30         reg = sdhci_readl(host, SDHCI_CLOCK_CONTROL);
  31         reg |= SDHCI_CLOCK_INT_EN;
  32         sdhci_writel(host, reg, SDHCI_CLOCK_CONTROL);
  33         /* Wait max 20 ms */
  34         timeout = ktime_add_ms(ktime_get(), 20);
  35         while (!((reg = sdhci_readw(host, SDHCI_CLOCK_CONTROL))
  36                         & SDHCI_CLOCK_INT_STABLE)) {
  37                 if (ktime_after(ktime_get(), timeout)) {
  38                         dev_err(mmc_dev(host->mmc), "Internal clock never stabilised.\n");
  39                         return -ETIMEDOUT;
  40                 }
  41                 usleep_range(900, 1100);
  42         }
  43
  44         return 0;
  45 }
  46
  47 /* Set SDCLK-off-while-idle */
  48 static void xenon_set_sdclk_off_idle(struct sdhci_host *host,
  49                                      unsigned char sdhc_id, bool enable)
  50 {
  51         u32 reg;
  52         u32 mask;
  53
  54         reg = sdhci_readl(host, XENON_SYS_OP_CTRL);
  55         /* Get the bit shift basing on the SDHC index */
  56         mask = (0x1 << (XENON_SDCLK_IDLEOFF_ENABLE_SHIFT + sdhc_id));
  57         if (enable)
  58                 reg |= mask;
  59         else
  60                 reg &= ~mask;
  61
  62         sdhci_writel(host, reg, XENON_SYS_OP_CTRL);
  63 }
  64
  65 /* Enable/Disable the Auto Clock Gating function */
  66 static void xenon_set_acg(struct sdhci_host *host, bool enable)
  67 {
  68         u32 reg;
  69
  70         reg = sdhci_readl(host, XENON_SYS_OP_CTRL);
  71         if (enable)
  72                 reg &= ~XENON_AUTO_CLKGATE_DISABLE_MASK;
  73         else
  74                 reg |= XENON_AUTO_CLKGATE_DISABLE_MASK;
  75         sdhci_writel(host, reg, XENON_SYS_OP_CTRL);
  76 }
  77
  78 /* Enable this SDHC */
  79 static void xenon_enable_sdhc(struct sdhci_host *host,
  80                               unsigned char sdhc_id)
  81 {
  82         u32 reg;
  83
  84         reg = sdhci_readl(host, XENON_SYS_OP_CTRL);
  85         reg |= (BIT(sdhc_id) << XENON_SLOT_ENABLE_SHIFT);
  86         sdhci_writel(host, reg, XENON_SYS_OP_CTRL);
  87
  88         host->mmc->caps |= MMC_CAP_WAIT_WHILE_BUSY;
  89         /*
  90          * Force to clear BUS_TEST to
  91          * skip bus_test_pre and bus_test_post
  92          */
  93         host->mmc->caps &= ~MMC_CAP_BUS_WIDTH_TEST;
  94 }
  95
  96 /* Disable this SDHC */
  97 static void xenon_disable_sdhc(struct sdhci_host *host,
  98                                unsigned char sdhc_id)
  99 {
 100         u32 reg;
 101
 102         reg = sdhci_readl(host, XENON_SYS_OP_CTRL);
 103         reg &= ~(BIT(sdhc_id) << XENON_SLOT_ENABLE_SHIFT);
 104         sdhci_writel(host, reg, XENON_SYS_OP_CTRL);
 105 }
 106
 107 /* Enable Parallel Transfer Mode */
 108 static void xenon_enable_sdhc_parallel_tran(struct sdhci_host *host,
 109                                             unsigned char sdhc_id)
 110 {
 111         u32 reg;
 112
 113         reg = sdhci_readl(host, XENON_SYS_EXT_OP_CTRL);
 114         reg |= BIT(sdhc_id);
 115         sdhci_writel(host, reg, XENON_SYS_EXT_OP_CTRL);
 116 }
 117
 118 /* Mask command conflict error */
 119 static void xenon_mask_cmd_conflict_err(struct sdhci_host *host)
 120 {
 121         u32  reg;
 122
 123         reg = sdhci_readl(host, XENON_SYS_EXT_OP_CTRL);
 124         reg |= XENON_MASK_CMD_CONFLICT_ERR;
 125         sdhci_writel(host, reg, XENON_SYS_EXT_OP_CTRL);
 126 }
 127
 128 static void xenon_retune_setup(struct sdhci_host *host)
 129 {
 130         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
 131         struct xenon_priv *priv = sdhci_pltfm_priv(pltfm_host);
 132         u32 reg;
 133
 134         /* Disable the Re-Tuning Request functionality */
 135         reg = sdhci_readl(host, XENON_SLOT_RETUNING_REQ_CTRL);
 136         reg &= ~XENON_RETUNING_COMPATIBLE;
 137         sdhci_writel(host, reg, XENON_SLOT_RETUNING_REQ_CTRL);
 138
 139         /* Disable the Re-tuning Interrupt */
 140         reg = sdhci_readl(host, SDHCI_SIGNAL_ENABLE);
 141         reg &= ~SDHCI_INT_RETUNE;
 142         sdhci_writel(host, reg, SDHCI_SIGNAL_ENABLE);
 143         reg = sdhci_readl(host, SDHCI_INT_ENABLE);
 144         reg &= ~SDHCI_INT_RETUNE;
 145         sdhci_writel(host, reg, SDHCI_INT_ENABLE);
 146
 147         /* Force to use Tuning Mode 1 */
 148         host->tuning_mode = SDHCI_TUNING_MODE_1;
 149         /* Set re-tuning period */
 150         host->tuning_count = 1 << (priv->tuning_count - 1);
 151 }
 152
 153 /*
 154  * Operations inside struct sdhci_ops
 155  */
 156 /* Recover the Register Setting cleared during SOFTWARE_RESET_ALL */
 157 static void xenon_reset_exit(struct sdhci_host *host,
 158                              unsigned char sdhc_id, u8 mask)
 159 {
 160         /* Only SOFTWARE RESET ALL will clear the register setting */
 161         if (!(mask & SDHCI_RESET_ALL))
 162                 return;
 163
 164         /* Disable tuning request and auto-retuning again */
 165         xenon_retune_setup(host);
 166
 167         xenon_set_acg(host, true);
 168
 169         xenon_set_sdclk_off_idle(host, sdhc_id, false);
 170
 171         xenon_mask_cmd_conflict_err(host);
 172 }
 173
 174 static void xenon_reset(struct sdhci_host *host, u8 mask)
 175 {
 176         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
 177         struct xenon_priv *priv = sdhci_pltfm_priv(pltfm_host);
 178
 179         sdhci_reset(host, mask);
 180         xenon_reset_exit(host, priv->sdhc_id, mask);
 181 }
 182
 183 /*
 184  * Xenon defines different values for HS200 and HS400
 185  * in Host_Control_2
 186  */
 187 static void xenon_set_uhs_signaling(struct sdhci_host *host,
 188                                     unsigned int timing)
 189 {
 190         u16 ctrl_2;
 191
 192         ctrl_2 = sdhci_readw(host, SDHCI_HOST_CONTROL2);
 193         /* Select Bus Speed Mode for host */
 194         ctrl_2 &= ~SDHCI_CTRL_UHS_MASK;
 195         if (timing == MMC_TIMING_MMC_HS200)
 196                 ctrl_2 |= XENON_CTRL_HS200;
 197         else if (timing == MMC_TIMING_UHS_SDR104)
 198                 ctrl_2 |= SDHCI_CTRL_UHS_SDR104;
 199         else if (timing == MMC_TIMING_UHS_SDR12)
 200                 ctrl_2 |= SDHCI_CTRL_UHS_SDR12;
 201         else if (timing == MMC_TIMING_UHS_SDR25)
 202                 ctrl_2 |= SDHCI_CTRL_UHS_SDR25;
 203         else if (timing == MMC_TIMING_UHS_SDR50)
 204                 ctrl_2 |= SDHCI_CTRL_UHS_SDR50;
 205         else if ((timing == MMC_TIMING_UHS_DDR50) ||
 206                  (timing == MMC_TIMING_MMC_DDR52))
 207                 ctrl_2 |= SDHCI_CTRL_UHS_DDR50;
 208         else if (timing == MMC_TIMING_MMC_HS400)
 209                 ctrl_2 |= XENON_CTRL_HS400;
 210         sdhci_writew(host, ctrl_2, SDHCI_HOST_CONTROL2);
 211 }
 212
 213 static const struct sdhci_ops sdhci_xenon_ops = {
 214         .set_clock              = sdhci_set_clock,
 215         .set_bus_width          = sdhci_set_bus_width,
 216         .reset                  = xenon_reset,
 217         .set_uhs_signaling      = xenon_set_uhs_signaling,
 218         .get_max_clock          = sdhci_pltfm_clk_get_max_clock,
 219 };
 220
 221 static const struct sdhci_pltfm_data sdhci_xenon_pdata = {
 222         .ops = &sdhci_xenon_ops,
 223         .quirks = SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC |
 224                   SDHCI_QUIRK_NO_SIMULT_VDD_AND_POWER |
 225                   SDHCI_QUIRK_CAP_CLOCK_BASE_BROKEN,
 226 };
 227
 228 /*
 229  * Xenon Specific Operations in mmc_host_ops
 230  */
 231 static void xenon_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 232 {
 233         struct sdhci_host *host = mmc_priv(mmc);
 234         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
 235         struct xenon_priv *priv = sdhci_pltfm_priv(pltfm_host);
 236         u32 reg;
 237
 238         /*
 239          * HS400/HS200/eMMC HS doesn't have Preset Value register.
 240          * However, sdhci_set_ios will read HS400/HS200 Preset register.
 241          * Disable Preset Value register for HS400/HS200.
 242          * eMMC HS with preset_enabled set will trigger a bug in
 243          * get_preset_value().
 244          */
 245         if ((ios->timing == MMC_TIMING_MMC_HS400) ||
 246             (ios->timing == MMC_TIMING_MMC_HS200) ||
 247             (ios->timing == MMC_TIMING_MMC_HS)) {
 248                 host->preset_enabled = false;
 249                 host->quirks2 |= SDHCI_QUIRK2_PRESET_VALUE_BROKEN;
 250                 host->flags &= ~SDHCI_PV_ENABLED;
 251
 252                 reg = sdhci_readw(host, SDHCI_HOST_CONTROL2);
 253                 reg &= ~SDHCI_CTRL_PRESET_VAL_ENABLE;
 254                 sdhci_writew(host, reg, SDHCI_HOST_CONTROL2);
 255         } else {
 256                 host->quirks2 &= ~SDHCI_QUIRK2_PRESET_VALUE_BROKEN;
 257         }
 258
 259         sdhci_set_ios(mmc, ios);
 260         xenon_phy_adj(host, ios);
 261
 262         if (host->clock > XENON_DEFAULT_SDCLK_FREQ)
 263                 xenon_set_sdclk_off_idle(host, priv->sdhc_id, true);
 264 }
 265
 266 static int xenon_start_signal_voltage_switch(struct mmc_host *mmc,
 267                                              struct mmc_ios *ios)
 268 {
 269         struct sdhci_host *host = mmc_priv(mmc);
 270
 271         /*
 272          * Before SD/SDIO set signal voltage, SD bus clock should be
 273          * disabled. However, sdhci_set_clock will also disable the Internal
 274          * clock in mmc_set_signal_voltage().
 275          * If Internal clock is disabled, the 3.3V/1.8V bit can not be updated.
 276          * Thus here manually enable internal clock.
 277          *
 278          * After switch completes, it is unnecessary to disable internal clock,
 279          * since keeping internal clock active obeys SD spec.
 280          */
 281         xenon_enable_internal_clk(host);
 282
 283         xenon_soc_pad_ctrl(host, ios->signal_voltage);
 284
 285         /*
 286          * If Vqmmc is fixed on platform, vqmmc regulator should be unavailable.
 287          * Thus SDHCI_CTRL_VDD_180 bit might not work then.
 288          * Skip the standard voltage switch to avoid any issue.
 289          */
 290         if (PTR_ERR(mmc->supply.vqmmc) == -ENODEV)
 291                 return 0;
 292
 293         return sdhci_start_signal_voltage_switch(mmc, ios);
 294 }
 295
 296 /*
 297  * Update card type.
 298  * priv->init_card_type will be used in PHY timing adjustment.
 299  */
 300 static void xenon_init_card(struct mmc_host *mmc, struct mmc_card *card)
 301 {
 302         struct sdhci_host *host = mmc_priv(mmc);
 303         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
 304         struct xenon_priv *priv = sdhci_pltfm_priv(pltfm_host);
 305
 306         /* Update card type*/
 307         priv->init_card_type = card->type;
 308 }
 309
 310 static int xenon_execute_tuning(struct mmc_host *mmc, u32 opcode)
 311 {
 312         struct sdhci_host *host = mmc_priv(mmc);
 313
 314         if (host->timing == MMC_TIMING_UHS_DDR50 ||
 315                 host->timing == MMC_TIMING_MMC_DDR52)
 316                 return 0;
 317
 318         /*
 319          * Currently force Xenon driver back to support mode 1 only,
 320          * even though Xenon might claim to support mode 2 or mode 3.
 321          * It requires more time to test mode 2/mode 3 on more platforms.
 322          */
 323         if (host->tuning_mode != SDHCI_TUNING_MODE_1)
 324                 xenon_retune_setup(host);
 325
 326         return sdhci_execute_tuning(mmc, opcode);
 327 }
 328
 329 static void xenon_enable_sdio_irq(struct mmc_host *mmc, int enable)
 330 {
 331         struct sdhci_host *host = mmc_priv(mmc);
 332         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
 333         struct xenon_priv *priv = sdhci_pltfm_priv(pltfm_host);
 334         u32 reg;
 335         u8 sdhc_id = priv->sdhc_id;
 336
 337         sdhci_enable_sdio_irq(mmc, enable);
 338
 339         if (enable) {
 340                 /*
 341                  * Set SDIO Card Inserted indication
 342                  * to enable detecting SDIO async irq.
 343                  */
 344                 reg = sdhci_readl(host, XENON_SYS_CFG_INFO);
 345                 reg |= (1 << (sdhc_id + XENON_SLOT_TYPE_SDIO_SHIFT));
 346                 sdhci_writel(host, reg, XENON_SYS_CFG_INFO);
 347         } else {
 348                 /* Clear SDIO Card Inserted indication */
 349                 reg = sdhci_readl(host, XENON_SYS_CFG_INFO);
 350                 reg &= ~(1 << (sdhc_id + XENON_SLOT_TYPE_SDIO_SHIFT));
 351                 sdhci_writel(host, reg, XENON_SYS_CFG_INFO);
 352         }
 353 }
 354
 355 static void xenon_replace_mmc_host_ops(struct sdhci_host *host)
 356 {
 357         host->mmc_host_ops.set_ios = xenon_set_ios;
 358         host->mmc_host_ops.start_signal_voltage_switch =
 359                         xenon_start_signal_voltage_switch;
 360         host->mmc_host_ops.init_card = xenon_init_card;
 361         host->mmc_host_ops.execute_tuning = xenon_execute_tuning;
 362         host->mmc_host_ops.enable_sdio_irq = xenon_enable_sdio_irq;
 363 }
 364
 365 /*
 366  * Parse Xenon specific DT properties:
 367  * sdhc-id: the index of current SDHC.
 368  *          Refer to XENON_SYS_CFG_INFO register
 369  * tun-count: the interval between re-tuning
 370  */
 371 static int xenon_probe_dt(struct platform_device *pdev)
 372 {
 373         struct device_node *np = pdev->dev.of_node;
 374         struct sdhci_host *host = platform_get_drvdata(pdev);
 375         struct mmc_host *mmc = host->mmc;
 376         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
 377         struct xenon_priv *priv = sdhci_pltfm_priv(pltfm_host);
 378         u32 sdhc_id, nr_sdhc;
 379         u32 tuning_count;
 380
 381         /* Disable HS200 on Armada AP806 */
 382         if (of_device_is_compatible(np, "marvell,armada-ap806-sdhci"))
 383                 host->quirks2 |= SDHCI_QUIRK2_BROKEN_HS200;
 384
 385         sdhc_id = 0x0;
 386         if (!of_property_read_u32(np, "marvell,xenon-sdhc-id", &sdhc_id)) {
 387                 nr_sdhc = sdhci_readl(host, XENON_SYS_CFG_INFO);
 388                 nr_sdhc &= XENON_NR_SUPPORTED_SLOT_MASK;
 389                 if (unlikely(sdhc_id > nr_sdhc)) {
 390                         dev_err(mmc_dev(mmc), "SDHC Index %d exceeds Number of SDHCs %d\n",
 391                                 sdhc_id, nr_sdhc);
 392                         return -EINVAL;
 393                 }
 394         }
 395         priv->sdhc_id = sdhc_id;
 396
 397         tuning_count = XENON_DEF_TUNING_COUNT;
 398         if (!of_property_read_u32(np, "marvell,xenon-tun-count",
 399                                   &tuning_count)) {
 400                 if (unlikely(tuning_count >= XENON_TMR_RETUN_NO_PRESENT)) {
 401                         dev_err(mmc_dev(mmc), "Wrong Re-tuning Count. Set default value %d\n",
 402                                 XENON_DEF_TUNING_COUNT);
 403                         tuning_count = XENON_DEF_TUNING_COUNT;
 404                 }
 405         }
 406         priv->tuning_count = tuning_count;
 407
 408         return xenon_phy_parse_dt(np, host);
 409 }
 410
 411 static int xenon_sdhc_prepare(struct sdhci_host *host)
 412 {
 413         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
 414         struct xenon_priv *priv = sdhci_pltfm_priv(pltfm_host);
 415         u8 sdhc_id = priv->sdhc_id;
 416
 417         /* Enable SDHC */
 418         xenon_enable_sdhc(host, sdhc_id);
 419
 420         /* Enable ACG */
 421         xenon_set_acg(host, true);
 422
 423         /* Enable Parallel Transfer Mode */
 424         xenon_enable_sdhc_parallel_tran(host, sdhc_id);
 425
 426         /* Disable SDCLK-Off-While-Idle before card init */
 427         xenon_set_sdclk_off_idle(host, sdhc_id, false);
 428
 429         xenon_mask_cmd_conflict_err(host);
 430
 431         return 0;
 432 }
 433
 434 static void xenon_sdhc_unprepare(struct sdhci_host *host)
 435 {
 436         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
 437         struct xenon_priv *priv = sdhci_pltfm_priv(pltfm_host);
 438         u8 sdhc_id = priv->sdhc_id;
 439
 440         /* disable SDHC */
 441         xenon_disable_sdhc(host, sdhc_id);
 442 }
 443
 444 static int xenon_probe(struct platform_device *pdev)
 445 {
 446         struct sdhci_pltfm_host *pltfm_host;
 447         struct sdhci_host *host;
 448         int err;
 449
 450         host = sdhci_pltfm_init(pdev, &sdhci_xenon_pdata,
 451                                 sizeof(struct xenon_priv));
 452         if (IS_ERR(host))
 453                 return PTR_ERR(host);
 454
 455         pltfm_host = sdhci_priv(host);
 456
 457         /*
 458          * Link Xenon specific mmc_host_ops function,
 459          * to replace standard ones in sdhci_ops.
 460          */
 461         xenon_replace_mmc_host_ops(host);
 462
 463         pltfm_host->clk = devm_clk_get(&pdev->dev, "core");
 464         if (IS_ERR(pltfm_host->clk)) {
 465                 err = PTR_ERR(pltfm_host->clk);
 466                 dev_err(&pdev->dev, "Failed to setup input clk: %d\n", err);
 467                 goto free_pltfm;
 468         }
 469         err = clk_prepare_enable(pltfm_host->clk);
 470         if (err)
 471                 goto free_pltfm;
 472
 473         err = mmc_of_parse(host->mmc);
 474         if (err)
 475                 goto err_clk;
 476
 477         sdhci_get_of_property(pdev);
 478
 479         xenon_set_acg(host, false);
 480
 481         /* Xenon specific dt parse */
 482         err = xenon_probe_dt(pdev);
 483         if (err)
 484                 goto err_clk;
 485
 486         err = xenon_sdhc_prepare(host);
 487         if (err)
 488                 goto err_clk;
 489
 490         err = sdhci_add_host(host);
 491         if (err)
 492                 goto remove_sdhc;
 493
 494         return 0;
 495
 496 remove_sdhc:
 497         xenon_sdhc_unprepare(host);
 498 err_clk:
 499         clk_disable_unprepare(pltfm_host->clk);
 500 free_pltfm:
 501         sdhci_pltfm_free(pdev);
 502         return err;
 503 }
 504
 505 static int xenon_remove(struct platform_device *pdev)
 506 {
 507         struct sdhci_host *host = platform_get_drvdata(pdev);
 508         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
 509
 510         sdhci_remove_host(host, 0);
 511
 512         xenon_sdhc_unprepare(host);
 513
 514         clk_disable_unprepare(pltfm_host->clk);
 515
 516         sdhci_pltfm_free(pdev);
 517
 518         return 0;
 519 }
 520
 521 static const struct of_device_id sdhci_xenon_dt_ids[] = {
 522         { .compatible = "marvell,armada-ap806-sdhci",},
 523         { .compatible = "marvell,armada-cp110-sdhci",},
 524         { .compatible = "marvell,armada-3700-sdhci",},
 525         {}
 526 };
 527 MODULE_DEVICE_TABLE(of, sdhci_xenon_dt_ids);
 528
 529 static struct platform_driver sdhci_xenon_driver = {
 530         .driver = {
 531                 .name   = "xenon-sdhci",
 532                 .of_match_table = sdhci_xenon_dt_ids,
 533                 .pm = &sdhci_pltfm_pmops,
 534         },
 535         .probe  = xenon_probe,
 536         .remove = xenon_remove,
 537 };
 538
 539 module_platform_driver(sdhci_xenon_driver);
 540
 541 MODULE_DESCRIPTION("SDHCI platform driver for Marvell Xenon SDHC");
 542 MODULE_AUTHOR("Hu Ziji <huziji@marvell.com>");
 543 MODULE_LICENSE("GPL v2");