drivers/mmc/am654_sdhci.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2018 Texas Instruments Incorporated - http://www.ti.com/
   4  *
   5  * Texas Instruments' K3 SD Host Controller Interface
   6  */
   7
   8 #include <clk.h>
   9 #include <common.h>
  10 #include <dm.h>
  11 #include <malloc.h>
  12 #include <power-domain.h>
  13 #include <regmap.h>
  14 #include <sdhci.h>
  15 #include <dm/device_compat.h>
  16 #include <linux/err.h>
  17
  18 /* CTL_CFG Registers */
  19 #define CTL_CFG_2               0x14
  20
  21 #define SLOTTYPE_MASK           GENMASK(31, 30)
  22 #define SLOTTYPE_EMBEDDED       BIT(30)
  23
  24 /* PHY Registers */
  25 #define PHY_CTRL1       0x100
  26 #define PHY_CTRL2       0x104
  27 #define PHY_CTRL3       0x108
  28 #define PHY_CTRL4       0x10C
  29 #define PHY_CTRL5       0x110
  30 #define PHY_CTRL6       0x114
  31 #define PHY_STAT1       0x130
  32 #define PHY_STAT2       0x134
  33
  34 #define IOMUX_ENABLE_SHIFT      31
  35 #define IOMUX_ENABLE_MASK       BIT(IOMUX_ENABLE_SHIFT)
  36 #define OTAPDLYENA_SHIFT        20
  37 #define OTAPDLYENA_MASK         BIT(OTAPDLYENA_SHIFT)
  38 #define OTAPDLYSEL_SHIFT        12
  39 #define OTAPDLYSEL_MASK         GENMASK(15, 12)
  40 #define STRBSEL_SHIFT           24
  41 #define STRBSEL_4BIT_MASK       GENMASK(27, 24)
  42 #define STRBSEL_8BIT_MASK       GENMASK(31, 24)
  43 #define SEL50_SHIFT             8
  44 #define SEL50_MASK              BIT(SEL50_SHIFT)
  45 #define SEL100_SHIFT            9
  46 #define SEL100_MASK             BIT(SEL100_SHIFT)
  47 #define FREQSEL_SHIFT           8
  48 #define FREQSEL_MASK            GENMASK(10, 8)
  49 #define DLL_TRIM_ICP_SHIFT      4
  50 #define DLL_TRIM_ICP_MASK       GENMASK(7, 4)
  51 #define DR_TY_SHIFT             20
  52 #define DR_TY_MASK              GENMASK(22, 20)
  53 #define ENDLL_SHIFT             1
  54 #define ENDLL_MASK              BIT(ENDLL_SHIFT)
  55 #define DLLRDY_SHIFT            0
  56 #define DLLRDY_MASK             BIT(DLLRDY_SHIFT)
  57 #define PDB_SHIFT               0
  58 #define PDB_MASK                BIT(PDB_SHIFT)
  59 #define CALDONE_SHIFT           1
  60 #define CALDONE_MASK            BIT(CALDONE_SHIFT)
  61 #define RETRIM_SHIFT            17
  62 #define RETRIM_MASK             BIT(RETRIM_SHIFT)
  63
  64 #define DRIVER_STRENGTH_50_OHM  0x0
  65 #define DRIVER_STRENGTH_33_OHM  0x1
  66 #define DRIVER_STRENGTH_66_OHM  0x2
  67 #define DRIVER_STRENGTH_100_OHM 0x3
  68 #define DRIVER_STRENGTH_40_OHM  0x4
  69
  70 #define AM654_SDHCI_MIN_FREQ    400000
  71
  72 struct am654_sdhci_plat {
  73         struct mmc_config cfg;
  74         struct mmc mmc;
  75         struct regmap *base;
  76         bool non_removable;
  77         u32 otap_del_sel[11];
  78         u32 trm_icp;
  79         u32 drv_strength;
  80         u32 strb_sel;
  81         u32 flags;
  82 #define DLL_PRESENT     (1 << 0)
  83 #define IOMUX_PRESENT   (1 << 1)
  84 #define FREQSEL_2_BIT   (1 << 2)
  85 #define STRBSEL_4_BIT   (1 << 3)
  86         bool dll_on;
  87 };
  88
  89 struct timing_data {
  90         const char *binding;
  91         u32 capability;
  92 };
  93
  94 static const struct timing_data td[] = {
  95         [MMC_LEGACY] = {"ti,otap-del-sel-legacy", 0},
  96         [MMC_HS] = {"ti,otap-del-sel-mmc-hs", MMC_CAP(MMC_HS)},
  97         [SD_HS]  = {"ti,otap-del-sel-sd-hs", MMC_CAP(SD_HS)},
  98         [UHS_SDR12] = {"ti,otap-del-sel-sdr12", MMC_CAP(UHS_SDR12)},
  99         [UHS_SDR25] = {"ti,otap-del-sel-sdr25", MMC_CAP(UHS_SDR25)},
 100         [UHS_SDR50] = {"ti,otap-del-sel-sdr50", MMC_CAP(UHS_SDR50)},
 101         [UHS_SDR104] = {"ti,otap-del-sel-sdr104", MMC_CAP(UHS_SDR104)},
 102         [UHS_DDR50] = {"ti,otap-del-sel-ddr50", MMC_CAP(UHS_DDR50)},
 103         [MMC_DDR_52] = {"ti,otap-del-sel-ddr52", MMC_CAP(MMC_DDR_52)},
 104         [MMC_HS_200] = {"ti,otap-del-sel-hs200", MMC_CAP(MMC_HS_200)},
 105         [MMC_HS_400] = {"ti,otap-del-sel-hs400", MMC_CAP(MMC_HS_400)},
 106 };
 107
 108 struct am654_driver_data {
 109         const struct sdhci_ops *ops;
 110         u32 flags;
 111 };
 112
 113 static void am654_sdhci_set_control_reg(struct sdhci_host *host)
 114 {
 115         struct mmc *mmc = (struct mmc *)host->mmc;
 116         u32 reg;
 117
 118         if (IS_SD(host->mmc) &&
 119             mmc->signal_voltage == MMC_SIGNAL_VOLTAGE_180) {
 120                 reg = sdhci_readw(host, SDHCI_HOST_CONTROL2);
 121                 reg |= SDHCI_CTRL_VDD_180;
 122                 sdhci_writew(host, reg, SDHCI_HOST_CONTROL2);
 123         }
 124
 125         sdhci_set_uhs_timing(host);
 126 }
 127
 128 static int am654_sdhci_set_ios_post(struct sdhci_host *host)
 129 {
 130         struct udevice *dev = host->mmc->dev;
 131         struct am654_sdhci_plat *plat = dev_get_platdata(dev);
 132         unsigned int speed = host->mmc->clock;
 133         int sel50, sel100, freqsel;
 134         u32 otap_del_sel;
 135         u32 mask, val;
 136         int ret;
 137
 138         /* Reset SD Clock Enable */
 139         val = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
 140         val &= ~SDHCI_CLOCK_CARD_EN;
 141         sdhci_writew(host, val, SDHCI_CLOCK_CONTROL);
 142
 143         /* power off phy */
 144         if (plat->dll_on) {
 145                 regmap_update_bits(plat->base, PHY_CTRL1, ENDLL_MASK, 0);
 146
 147                 plat->dll_on = false;
 148         }
 149
 150         /* restart clock */
 151         sdhci_set_clock(host->mmc, speed);
 152
 153         /* switch phy back on */
 154         if (speed > AM654_SDHCI_MIN_FREQ) {
 155                 otap_del_sel = plat->otap_del_sel[host->mmc->selected_mode];
 156                 mask = OTAPDLYENA_MASK | OTAPDLYSEL_MASK;
 157                 val = (1 << OTAPDLYENA_SHIFT) |
 158                       (otap_del_sel << OTAPDLYSEL_SHIFT);
 159
 160                 /* Write to STRBSEL for HS400 speed mode */
 161                 if (host->mmc->selected_mode == MMC_HS_400) {
 162                         if (plat->flags & STRBSEL_4_BIT)
 163                                 mask |= STRBSEL_4BIT_MASK;
 164                         else
 165                                 mask |= STRBSEL_8BIT_MASK;
 166
 167                         val |= plat->strb_sel << STRBSEL_SHIFT;
 168                 }
 169
 170                 regmap_update_bits(plat->base, PHY_CTRL4, mask, val);
 171
 172                 if (plat->flags & FREQSEL_2_BIT) {
 173                         switch (speed) {
 174                         case 200000000:
 175                                 sel50 = 0;
 176                                 sel100 = 0;
 177                                 break;
 178                         case 100000000:
 179                                 sel50 = 0;
 180                                 sel100 = 1;
 181                                 break;
 182                         default:
 183                                 sel50 = 1;
 184                                 sel100 = 0;
 185                         }
 186
 187                         /* Configure PHY DLL frequency */
 188                         mask = SEL50_MASK | SEL100_MASK;
 189                         val = (sel50 << SEL50_SHIFT) | (sel100 << SEL100_SHIFT);
 190                         regmap_update_bits(plat->base, PHY_CTRL5, mask, val);
 191                 } else {
 192                         switch (speed) {
 193                         case 200000000:
 194                                 freqsel = 0x0;
 195                                 break;
 196                         default:
 197                                 freqsel = 0x4;
 198                         }
 199                         regmap_update_bits(plat->base, PHY_CTRL5, FREQSEL_MASK,
 200                                            freqsel << FREQSEL_SHIFT);
 201                 }
 202
 203                 /* Enable DLL */
 204                 regmap_update_bits(plat->base, PHY_CTRL1, ENDLL_MASK,
 205                                    0x1 << ENDLL_SHIFT);
 206                 /*
 207                  * Poll for DLL ready. Use a one second timeout.
 208                  * Works in all experiments done so far
 209                  */
 210                 ret = regmap_read_poll_timeout(plat->base, PHY_STAT1, val,
 211                                          val & DLLRDY_MASK, 1000, 1000000);
 212                 if (ret)
 213                         return ret;
 214
 215                 plat->dll_on = true;
 216         }
 217
 218         return 0;
 219 }
 220
 221 const struct sdhci_ops am654_sdhci_ops = {
 222         .set_ios_post           = &am654_sdhci_set_ios_post,
 223         .set_control_reg        = &am654_sdhci_set_control_reg,
 224 };
 225
 226 const struct am654_driver_data am654_drv_data = {
 227         .ops = &am654_sdhci_ops,
 228         .flags = IOMUX_PRESENT | FREQSEL_2_BIT | DLL_PRESENT | STRBSEL_4_BIT,
 229 };
 230
 231 const struct am654_driver_data j721e_8bit_drv_data = {
 232         .ops = &am654_sdhci_ops,
 233         .flags = DLL_PRESENT,
 234 };
 235
 236 static int j721e_4bit_sdhci_set_ios_post(struct sdhci_host *host)
 237 {
 238         struct udevice *dev = host->mmc->dev;
 239         struct am654_sdhci_plat *plat = dev_get_platdata(dev);
 240         u32 otap_del_sel, mask, val;
 241
 242         otap_del_sel = plat->otap_del_sel[host->mmc->selected_mode];
 243         mask = OTAPDLYENA_MASK | OTAPDLYSEL_MASK;
 244         val = (1 << OTAPDLYENA_SHIFT) | (otap_del_sel << OTAPDLYSEL_SHIFT);
 245         regmap_update_bits(plat->base, PHY_CTRL4, mask, val);
 246
 247         return 0;
 248 }
 249
 250 const struct sdhci_ops j721e_4bit_sdhci_ops = {
 251         .set_ios_post           = &j721e_4bit_sdhci_set_ios_post,
 252 };
 253
 254 const struct am654_driver_data j721e_4bit_drv_data = {
 255         .ops = &j721e_4bit_sdhci_ops,
 256         .flags = IOMUX_PRESENT,
 257 };
 258
 259 int am654_sdhci_init(struct am654_sdhci_plat *plat)
 260 {
 261         u32 ctl_cfg_2 = 0;
 262         u32 mask, val;
 263         int ret;
 264
 265         /* Reset OTAP to default value */
 266         mask = OTAPDLYENA_MASK | OTAPDLYSEL_MASK;
 267         regmap_update_bits(plat->base, PHY_CTRL4, mask, 0x0);
 268
 269         if (plat->flags & DLL_PRESENT) {
 270                 regmap_read(plat->base, PHY_STAT1, &val);
 271                 if (~val & CALDONE_MASK) {
 272                         /* Calibrate IO lines */
 273                         regmap_update_bits(plat->base, PHY_CTRL1, PDB_MASK,
 274                                            PDB_MASK);
 275                         ret = regmap_read_poll_timeout(plat->base, PHY_STAT1,
 276                                                        val, val & CALDONE_MASK,
 277                                                        1, 20);
 278                         if (ret)
 279                                 return ret;
 280                 }
 281
 282                 /* Configure DLL TRIM */
 283                 mask = DLL_TRIM_ICP_MASK;
 284                 val = plat->trm_icp << DLL_TRIM_ICP_SHIFT;
 285
 286                 /* Configure DLL driver strength */
 287                 mask |= DR_TY_MASK;
 288                 val |= plat->drv_strength << DR_TY_SHIFT;
 289                 regmap_update_bits(plat->base, PHY_CTRL1, mask, val);
 290         }
 291
 292         /* Enable pins by setting IO mux to 0 */
 293         if (plat->flags & IOMUX_PRESENT)
 294                 regmap_update_bits(plat->base, PHY_CTRL1, IOMUX_ENABLE_MASK, 0);
 295
 296         /* Set slot type based on SD or eMMC */
 297         if (plat->non_removable)
 298                 ctl_cfg_2 = SLOTTYPE_EMBEDDED;
 299
 300         regmap_update_bits(plat->base, CTL_CFG_2, SLOTTYPE_MASK, ctl_cfg_2);
 301
 302         return 0;
 303 }
 304
 305 static int sdhci_am654_get_otap_delay(struct udevice *dev,
 306                                       struct mmc_config *cfg)
 307 {
 308         struct am654_sdhci_plat *plat = dev_get_platdata(dev);
 309         int ret;
 310         int i;
 311
 312         /* ti,otap-del-sel-legacy is mandatory */
 313         ret = dev_read_u32(dev, "ti,otap-del-sel-legacy",
 314                            &plat->otap_del_sel[0]);
 315         if (ret)
 316                 return ret;
 317         /*
 318          * Remove the corresponding capability if an otap-del-sel
 319          * value is not found
 320          */
 321         for (i = MMC_HS; i <= MMC_HS_400; i++) {
 322                 ret = dev_read_u32(dev, td[i].binding, &plat->otap_del_sel[i]);
 323                 if (ret) {
 324                         dev_dbg(dev, "Couldn't find %s\n", td[i].binding);
 325                         /*
 326                          * Remove the corresponding capability
 327                          * if an otap-del-sel value is not found
 328                          */
 329                         cfg->host_caps &= ~td[i].capability;
 330                 }
 331         }
 332
 333         return 0;
 334 }
 335
 336 static int am654_sdhci_probe(struct udevice *dev)
 337 {
 338         struct am654_driver_data *drv_data =
 339                         (struct am654_driver_data *)dev_get_driver_data(dev);
 340         struct am654_sdhci_plat *plat = dev_get_platdata(dev);
 341         struct mmc_uclass_priv *upriv = dev_get_uclass_priv(dev);
 342         struct sdhci_host *host = dev_get_priv(dev);
 343         struct mmc_config *cfg = &plat->cfg;
 344         struct clk clk;
 345         unsigned long clock;
 346         int ret;
 347
 348         ret = clk_get_by_name(dev, "clk_xin", &clk);
 349         if (ret) {
 350                 dev_err(dev, "failed to get clock\n");
 351                 return ret;
 352         }
 353
 354         clock = clk_get_rate(&clk);
 355         if (IS_ERR_VALUE(clock)) {
 356                 dev_err(dev, "failed to get rate\n");
 357                 return clock;
 358         }
 359
 360         host->max_clk = clock;
 361         host->mmc = &plat->mmc;
 362         host->mmc->dev = dev;
 363         ret = sdhci_setup_cfg(cfg, host, cfg->f_max,
 364                               AM654_SDHCI_MIN_FREQ);
 365         if (ret)
 366                 return ret;
 367
 368         ret = sdhci_am654_get_otap_delay(dev, cfg);
 369         if (ret)
 370                 return ret;
 371
 372         host->ops = drv_data->ops;
 373         host->mmc->priv = host;
 374         upriv->mmc = host->mmc;
 375
 376         regmap_init_mem_index(dev_ofnode(dev), &plat->base, 1);
 377
 378         am654_sdhci_init(plat);
 379
 380         return sdhci_probe(dev);
 381 }
 382
 383 static int am654_sdhci_ofdata_to_platdata(struct udevice *dev)
 384 {
 385         struct am654_sdhci_plat *plat = dev_get_platdata(dev);
 386         struct sdhci_host *host = dev_get_priv(dev);
 387         struct mmc_config *cfg = &plat->cfg;
 388         u32 drv_strength;
 389         int ret;
 390
 391         host->name = dev->name;
 392         host->ioaddr = (void *)dev_read_addr(dev);
 393         plat->non_removable = dev_read_bool(dev, "non-removable");
 394
 395         if (plat->flags & DLL_PRESENT) {
 396                 ret = dev_read_u32(dev, "ti,trm-icp", &plat->trm_icp);
 397                 if (ret)
 398                         return ret;
 399
 400                 ret = dev_read_u32(dev, "ti,driver-strength-ohm",
 401                                    &drv_strength);
 402                 if (ret)
 403                         return ret;
 404
 405                 switch (drv_strength) {
 406                 case 50:
 407                         plat->drv_strength = DRIVER_STRENGTH_50_OHM;
 408                         break;
 409                 case 33:
 410                         plat->drv_strength = DRIVER_STRENGTH_33_OHM;
 411                         break;
 412                 case 66:
 413                         plat->drv_strength = DRIVER_STRENGTH_66_OHM;
 414                         break;
 415                 case 100:
 416                         plat->drv_strength = DRIVER_STRENGTH_100_OHM;
 417                         break;
 418                 case 40:
 419                         plat->drv_strength = DRIVER_STRENGTH_40_OHM;
 420                         break;
 421                 default:
 422                         dev_err(dev, "Invalid driver strength\n");
 423                         return -EINVAL;
 424                 }
 425         }
 426
 427         ret = mmc_of_parse(dev, cfg);
 428         if (ret)
 429                 return ret;
 430
 431         return 0;
 432 }
 433
 434 static int am654_sdhci_bind(struct udevice *dev)
 435 {
 436         struct am654_driver_data *drv_data =
 437                         (struct am654_driver_data *)dev_get_driver_data(dev);
 438         struct am654_sdhci_plat *plat = dev_get_platdata(dev);
 439
 440         plat->flags = drv_data->flags;
 441
 442         return sdhci_bind(dev, &plat->mmc, &plat->cfg);
 443 }
 444
 445 static const struct udevice_id am654_sdhci_ids[] = {
 446         {
 447                 .compatible = "ti,am654-sdhci-5.1",
 448                 .data = (ulong)&am654_drv_data,
 449         },
 450         {
 451                 .compatible = "ti,j721e-sdhci-8bit",
 452                 .data = (ulong)&j721e_8bit_drv_data,
 453         },
 454         {
 455                 .compatible = "ti,j721e-sdhci-4bit",
 456                 .data = (ulong)&j721e_4bit_drv_data,
 457         },
 458         { }
 459 };
 460
 461 U_BOOT_DRIVER(am654_sdhci_drv) = {
 462         .name           = "am654_sdhci",
 463         .id             = UCLASS_MMC,
 464         .of_match       = am654_sdhci_ids,
 465         .ofdata_to_platdata = am654_sdhci_ofdata_to_platdata,
 466         .ops            = &sdhci_ops,
 467         .bind           = am654_sdhci_bind,
 468         .probe          = am654_sdhci_probe,
 469         .priv_auto_alloc_size = sizeof(struct sdhci_host),
 470         .platdata_auto_alloc_size = sizeof(struct am654_sdhci_plat),
 471 };