1 /* 2 * Freescale eSDHC controller driver. 3 * 4 * Copyright (c) 2007, 2010, 2012 Freescale Semiconductor, Inc. 5 * Copyright (c) 2009 MontaVista Software, Inc. 6 * 7 * Authors: Xiaobo Xie <X.Xie@freescale.com> 8 * Anton Vorontsov <avorontsov@ru.mvista.com> 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License as published by 12 * the Free Software Foundation; either version 2 of the License, or (at 13 * your option) any later version. 14 */ 15 16 #include <linux/err.h> 17 #include <linux/io.h> 18 #include <linux/of.h> 19 #include <linux/of_address.h> 20 #include <linux/delay.h> 21 #include <linux/module.h> 22 #include <linux/sys_soc.h> 23 #include <linux/clk.h> 24 #include <linux/ktime.h> 25 #include <linux/mmc/host.h> 26 #include "sdhci-pltfm.h" 27 #include "sdhci-esdhc.h" 28 29 #define VENDOR_V_22 0x12 30 #define VENDOR_V_23 0x13 31 32 struct sdhci_esdhc { 33 u8 vendor_ver; 34 u8 spec_ver; 35 bool quirk_incorrect_hostver; 36 unsigned int peripheral_clock; 37 }; 38 39 /** 40 * esdhc_read*_fixup - Fixup the value read from incompatible eSDHC register 41 * to make it compatible with SD spec. 42 * 43 * @host: pointer to sdhci_host 44 * @spec_reg: SD spec register address 45 * @value: 32bit eSDHC register value on spec_reg address 46 * 47 * In SD spec, there are 8/16/32/64 bits registers, while all of eSDHC 48 * registers are 32 bits. There are differences in register size, register 49 * address, register function, bit position and function between eSDHC spec 50 * and SD spec. 51 * 52 * Return a fixed up register value 53 */ 54 static u32 esdhc_readl_fixup(struct sdhci_host *host, 55 int spec_reg, u32 value) 56 { 57 struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); 58 struct sdhci_esdhc *esdhc = sdhci_pltfm_priv(pltfm_host); 59 u32 ret; 60 61 /* 62 * The bit of ADMA flag in eSDHC is not compatible with standard 63 * SDHC register, so set fake flag SDHCI_CAN_DO_ADMA2 when ADMA is 64 * supported by eSDHC. 65 * And for many FSL eSDHC controller, the reset value of field 66 * SDHCI_CAN_DO_ADMA1 is 1, but some of them can't support ADMA, 67 * only these vendor version is greater than 2.2/0x12 support ADMA. 68 */ 69 if ((spec_reg == SDHCI_CAPABILITIES) && (value & SDHCI_CAN_DO_ADMA1)) { 70 if (esdhc->vendor_ver > VENDOR_V_22) { 71 ret = value | SDHCI_CAN_DO_ADMA2; 72 return ret; 73 } 74 } 75 /* 76 * The DAT[3:0] line signal levels and the CMD line signal level are 77 * not compatible with standard SDHC register. The line signal levels 78 * DAT[7:0] are at bits 31:24 and the command line signal level is at 79 * bit 23. All other bits are the same as in the standard SDHC 80 * register. 81 */ 82 if (spec_reg == SDHCI_PRESENT_STATE) { 83 ret = value & 0x000fffff; 84 ret |= (value >> 4) & SDHCI_DATA_LVL_MASK; 85 ret |= (value << 1) & SDHCI_CMD_LVL; 86 return ret; 87 } 88 89 /* 90 * DTS properties of mmc host are used to enable each speed mode 91 * according to soc and board capability. So clean up 92 * SDR50/SDR104/DDR50 support bits here. 93 */ 94 if (spec_reg == SDHCI_CAPABILITIES_1) { 95 ret = value & ~(SDHCI_SUPPORT_SDR50 | SDHCI_SUPPORT_SDR104 | 96 SDHCI_SUPPORT_DDR50); 97 return ret; 98 } 99 100 ret = value; 101 return ret; 102 } 103 104 static u16 esdhc_readw_fixup(struct sdhci_host *host, 105 int spec_reg, u32 value) 106 { 107 struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); 108 struct sdhci_esdhc *esdhc = sdhci_pltfm_priv(pltfm_host); 109 u16 ret; 110 int shift = (spec_reg & 0x2) * 8; 111 112 if (spec_reg == SDHCI_HOST_VERSION) 113 ret = value & 0xffff; 114 else 115 ret = (value >> shift) & 0xffff; 116 /* Workaround for T4240-R1.0-R2.0 eSDHC which has incorrect 117 * vendor version and spec version information. 118 */ 119 if ((spec_reg == SDHCI_HOST_VERSION) && 120 (esdhc->quirk_incorrect_hostver)) 121 ret = (VENDOR_V_23 << SDHCI_VENDOR_VER_SHIFT) | SDHCI_SPEC_200; 122 return ret; 123 } 124 125 static u8 esdhc_readb_fixup(struct sdhci_host *host, 126 int spec_reg, u32 value) 127 { 128 u8 ret; 129 u8 dma_bits; 130 int shift = (spec_reg & 0x3) * 8; 131 132 ret = (value >> shift) & 0xff; 133 134 /* 135 * "DMA select" locates at offset 0x28 in SD specification, but on 136 * P5020 or P3041, it locates at 0x29. 137 */ 138 if (spec_reg == SDHCI_HOST_CONTROL) { 139 /* DMA select is 22,23 bits in Protocol Control Register */ 140 dma_bits = (value >> 5) & SDHCI_CTRL_DMA_MASK; 141 /* fixup the result */ 142 ret &= ~SDHCI_CTRL_DMA_MASK; 143 ret |= dma_bits; 144 } 145 return ret; 146 } 147 148 /** 149 * esdhc_write*_fixup - Fixup the SD spec register value so that it could be 150 * written into eSDHC register. 151 * 152 * @host: pointer to sdhci_host 153 * @spec_reg: SD spec register address 154 * @value: 8/16/32bit SD spec register value that would be written 155 * @old_value: 32bit eSDHC register value on spec_reg address 156 * 157 * In SD spec, there are 8/16/32/64 bits registers, while all of eSDHC 158 * registers are 32 bits. There are differences in register size, register 159 * address, register function, bit position and function between eSDHC spec 160 * and SD spec. 161 * 162 * Return a fixed up register value 163 */ 164 static u32 esdhc_writel_fixup(struct sdhci_host *host, 165 int spec_reg, u32 value, u32 old_value) 166 { 167 u32 ret; 168 169 /* 170 * Enabling IRQSTATEN[BGESEN] is just to set IRQSTAT[BGE] 171 * when SYSCTL[RSTD] is set for some special operations. 172 * No any impact on other operation. 173 */ 174 if (spec_reg == SDHCI_INT_ENABLE) 175 ret = value | SDHCI_INT_BLK_GAP; 176 else 177 ret = value; 178 179 return ret; 180 } 181 182 static u32 esdhc_writew_fixup(struct sdhci_host *host, 183 int spec_reg, u16 value, u32 old_value) 184 { 185 struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); 186 int shift = (spec_reg & 0x2) * 8; 187 u32 ret; 188 189 switch (spec_reg) { 190 case SDHCI_TRANSFER_MODE: 191 /* 192 * Postpone this write, we must do it together with a 193 * command write that is down below. Return old value. 194 */ 195 pltfm_host->xfer_mode_shadow = value; 196 return old_value; 197 case SDHCI_COMMAND: 198 ret = (value << 16) | pltfm_host->xfer_mode_shadow; 199 return ret; 200 } 201 202 ret = old_value & (~(0xffff << shift)); 203 ret |= (value << shift); 204 205 if (spec_reg == SDHCI_BLOCK_SIZE) { 206 /* 207 * Two last DMA bits are reserved, and first one is used for 208 * non-standard blksz of 4096 bytes that we don't support 209 * yet. So clear the DMA boundary bits. 210 */ 211 ret &= (~SDHCI_MAKE_BLKSZ(0x7, 0)); 212 } 213 return ret; 214 } 215 216 static u32 esdhc_writeb_fixup(struct sdhci_host *host, 217 int spec_reg, u8 value, u32 old_value) 218 { 219 u32 ret; 220 u32 dma_bits; 221 u8 tmp; 222 int shift = (spec_reg & 0x3) * 8; 223 224 /* 225 * eSDHC doesn't have a standard power control register, so we do 226 * nothing here to avoid incorrect operation. 227 */ 228 if (spec_reg == SDHCI_POWER_CONTROL) 229 return old_value; 230 /* 231 * "DMA select" location is offset 0x28 in SD specification, but on 232 * P5020 or P3041, it's located at 0x29. 233 */ 234 if (spec_reg == SDHCI_HOST_CONTROL) { 235 /* 236 * If host control register is not standard, exit 237 * this function 238 */ 239 if (host->quirks2 & SDHCI_QUIRK2_BROKEN_HOST_CONTROL) 240 return old_value; 241 242 /* DMA select is 22,23 bits in Protocol Control Register */ 243 dma_bits = (value & SDHCI_CTRL_DMA_MASK) << 5; 244 ret = (old_value & (~(SDHCI_CTRL_DMA_MASK << 5))) | dma_bits; 245 tmp = (value & (~SDHCI_CTRL_DMA_MASK)) | 246 (old_value & SDHCI_CTRL_DMA_MASK); 247 ret = (ret & (~0xff)) | tmp; 248 249 /* Prevent SDHCI core from writing reserved bits (e.g. HISPD) */ 250 ret &= ~ESDHC_HOST_CONTROL_RES; 251 return ret; 252 } 253 254 ret = (old_value & (~(0xff << shift))) | (value << shift); 255 return ret; 256 } 257 258 static u32 esdhc_be_readl(struct sdhci_host *host, int reg) 259 { 260 u32 ret; 261 u32 value; 262 263 if (reg == SDHCI_CAPABILITIES_1) 264 value = ioread32be(host->ioaddr + ESDHC_CAPABILITIES_1); 265 else 266 value = ioread32be(host->ioaddr + reg); 267 268 ret = esdhc_readl_fixup(host, reg, value); 269 270 return ret; 271 } 272 273 static u32 esdhc_le_readl(struct sdhci_host *host, int reg) 274 { 275 u32 ret; 276 u32 value; 277 278 if (reg == SDHCI_CAPABILITIES_1) 279 value = ioread32(host->ioaddr + ESDHC_CAPABILITIES_1); 280 else 281 value = ioread32(host->ioaddr + reg); 282 283 ret = esdhc_readl_fixup(host, reg, value); 284 285 return ret; 286 } 287 288 static u16 esdhc_be_readw(struct sdhci_host *host, int reg) 289 { 290 u16 ret; 291 u32 value; 292 int base = reg & ~0x3; 293 294 value = ioread32be(host->ioaddr + base); 295 ret = esdhc_readw_fixup(host, reg, value); 296 return ret; 297 } 298 299 static u16 esdhc_le_readw(struct sdhci_host *host, int reg) 300 { 301 u16 ret; 302 u32 value; 303 int base = reg & ~0x3; 304 305 value = ioread32(host->ioaddr + base); 306 ret = esdhc_readw_fixup(host, reg, value); 307 return ret; 308 } 309 310 static u8 esdhc_be_readb(struct sdhci_host *host, int reg) 311 { 312 u8 ret; 313 u32 value; 314 int base = reg & ~0x3; 315 316 value = ioread32be(host->ioaddr + base); 317 ret = esdhc_readb_fixup(host, reg, value); 318 return ret; 319 } 320 321 static u8 esdhc_le_readb(struct sdhci_host *host, int reg) 322 { 323 u8 ret; 324 u32 value; 325 int base = reg & ~0x3; 326 327 value = ioread32(host->ioaddr + base); 328 ret = esdhc_readb_fixup(host, reg, value); 329 return ret; 330 } 331 332 static void esdhc_be_writel(struct sdhci_host *host, u32 val, int reg) 333 { 334 u32 value; 335 336 value = esdhc_writel_fixup(host, reg, val, 0); 337 iowrite32be(value, host->ioaddr + reg); 338 } 339 340 static void esdhc_le_writel(struct sdhci_host *host, u32 val, int reg) 341 { 342 u32 value; 343 344 value = esdhc_writel_fixup(host, reg, val, 0); 345 iowrite32(value, host->ioaddr + reg); 346 } 347 348 static void esdhc_be_writew(struct sdhci_host *host, u16 val, int reg) 349 { 350 int base = reg & ~0x3; 351 u32 value; 352 u32 ret; 353 354 value = ioread32be(host->ioaddr + base); 355 ret = esdhc_writew_fixup(host, reg, val, value); 356 if (reg != SDHCI_TRANSFER_MODE) 357 iowrite32be(ret, host->ioaddr + base); 358 } 359 360 static void esdhc_le_writew(struct sdhci_host *host, u16 val, int reg) 361 { 362 int base = reg & ~0x3; 363 u32 value; 364 u32 ret; 365 366 value = ioread32(host->ioaddr + base); 367 ret = esdhc_writew_fixup(host, reg, val, value); 368 if (reg != SDHCI_TRANSFER_MODE) 369 iowrite32(ret, host->ioaddr + base); 370 } 371 372 static void esdhc_be_writeb(struct sdhci_host *host, u8 val, int reg) 373 { 374 int base = reg & ~0x3; 375 u32 value; 376 u32 ret; 377 378 value = ioread32be(host->ioaddr + base); 379 ret = esdhc_writeb_fixup(host, reg, val, value); 380 iowrite32be(ret, host->ioaddr + base); 381 } 382 383 static void esdhc_le_writeb(struct sdhci_host *host, u8 val, int reg) 384 { 385 int base = reg & ~0x3; 386 u32 value; 387 u32 ret; 388 389 value = ioread32(host->ioaddr + base); 390 ret = esdhc_writeb_fixup(host, reg, val, value); 391 iowrite32(ret, host->ioaddr + base); 392 } 393 394 /* 395 * For Abort or Suspend after Stop at Block Gap, ignore the ADMA 396 * error(IRQSTAT[ADMAE]) if both Transfer Complete(IRQSTAT[TC]) 397 * and Block Gap Event(IRQSTAT[BGE]) are also set. 398 * For Continue, apply soft reset for data(SYSCTL[RSTD]); 399 * and re-issue the entire read transaction from beginning. 400 */ 401 static void esdhc_of_adma_workaround(struct sdhci_host *host, u32 intmask) 402 { 403 struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); 404 struct sdhci_esdhc *esdhc = sdhci_pltfm_priv(pltfm_host); 405 bool applicable; 406 dma_addr_t dmastart; 407 dma_addr_t dmanow; 408 409 applicable = (intmask & SDHCI_INT_DATA_END) && 410 (intmask & SDHCI_INT_BLK_GAP) && 411 (esdhc->vendor_ver == VENDOR_V_23); 412 if (!applicable) 413 return; 414 415 host->data->error = 0; 416 dmastart = sg_dma_address(host->data->sg); 417 dmanow = dmastart + host->data->bytes_xfered; 418 /* 419 * Force update to the next DMA block boundary. 420 */ 421 dmanow = (dmanow & ~(SDHCI_DEFAULT_BOUNDARY_SIZE - 1)) + 422 SDHCI_DEFAULT_BOUNDARY_SIZE; 423 host->data->bytes_xfered = dmanow - dmastart; 424 sdhci_writel(host, dmanow, SDHCI_DMA_ADDRESS); 425 } 426 427 static int esdhc_of_enable_dma(struct sdhci_host *host) 428 { 429 u32 value; 430 431 value = sdhci_readl(host, ESDHC_DMA_SYSCTL); 432 value |= ESDHC_DMA_SNOOP; 433 sdhci_writel(host, value, ESDHC_DMA_SYSCTL); 434 return 0; 435 } 436 437 static unsigned int esdhc_of_get_max_clock(struct sdhci_host *host) 438 { 439 struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); 440 struct sdhci_esdhc *esdhc = sdhci_pltfm_priv(pltfm_host); 441 442 if (esdhc->peripheral_clock) 443 return esdhc->peripheral_clock; 444 else 445 return pltfm_host->clock; 446 } 447 448 static unsigned int esdhc_of_get_min_clock(struct sdhci_host *host) 449 { 450 struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); 451 struct sdhci_esdhc *esdhc = sdhci_pltfm_priv(pltfm_host); 452 unsigned int clock; 453 454 if (esdhc->peripheral_clock) 455 clock = esdhc->peripheral_clock; 456 else 457 clock = pltfm_host->clock; 458 return clock / 256 / 16; 459 } 460 461 static void esdhc_of_set_clock(struct sdhci_host *host, unsigned int clock) 462 { 463 struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); 464 struct sdhci_esdhc *esdhc = sdhci_pltfm_priv(pltfm_host); 465 int pre_div = 1; 466 int div = 1; 467 ktime_t timeout; 468 u32 temp; 469 470 host->mmc->actual_clock = 0; 471 472 if (clock == 0) 473 return; 474 475 /* Workaround to start pre_div at 2 for VNN < VENDOR_V_23 */ 476 if (esdhc->vendor_ver < VENDOR_V_23) 477 pre_div = 2; 478 479 /* 480 * Limit SD clock to 167MHz for ls1046a according to its datasheet 481 */ 482 if (clock > 167000000 && 483 of_find_compatible_node(NULL, NULL, "fsl,ls1046a-esdhc")) 484 clock = 167000000; 485 486 /* 487 * Limit SD clock to 125MHz for ls1012a according to its datasheet 488 */ 489 if (clock > 125000000 && 490 of_find_compatible_node(NULL, NULL, "fsl,ls1012a-esdhc")) 491 clock = 125000000; 492 493 /* Workaround to reduce the clock frequency for p1010 esdhc */ 494 if (of_find_compatible_node(NULL, NULL, "fsl,p1010-esdhc")) { 495 if (clock > 20000000) 496 clock -= 5000000; 497 if (clock > 40000000) 498 clock -= 5000000; 499 } 500 501 temp = sdhci_readl(host, ESDHC_SYSTEM_CONTROL); 502 temp &= ~(ESDHC_CLOCK_SDCLKEN | ESDHC_CLOCK_IPGEN | ESDHC_CLOCK_HCKEN | 503 ESDHC_CLOCK_PEREN | ESDHC_CLOCK_MASK); 504 sdhci_writel(host, temp, ESDHC_SYSTEM_CONTROL); 505 506 while (host->max_clk / pre_div / 16 > clock && pre_div < 256) 507 pre_div *= 2; 508 509 while (host->max_clk / pre_div / div > clock && div < 16) 510 div++; 511 512 dev_dbg(mmc_dev(host->mmc), "desired SD clock: %d, actual: %d\n", 513 clock, host->max_clk / pre_div / div); 514 host->mmc->actual_clock = host->max_clk / pre_div / div; 515 pre_div >>= 1; 516 div--; 517 518 temp = sdhci_readl(host, ESDHC_SYSTEM_CONTROL); 519 temp |= (ESDHC_CLOCK_IPGEN | ESDHC_CLOCK_HCKEN | ESDHC_CLOCK_PEREN 520 | (div << ESDHC_DIVIDER_SHIFT) 521 | (pre_div << ESDHC_PREDIV_SHIFT)); 522 sdhci_writel(host, temp, ESDHC_SYSTEM_CONTROL); 523 524 /* Wait max 20 ms */ 525 timeout = ktime_add_ms(ktime_get(), 20); 526 while (!(sdhci_readl(host, ESDHC_PRSSTAT) & ESDHC_CLOCK_STABLE)) { 527 if (ktime_after(ktime_get(), timeout)) { 528 pr_err("%s: Internal clock never stabilised.\n", 529 mmc_hostname(host->mmc)); 530 return; 531 } 532 udelay(10); 533 } 534 535 temp |= ESDHC_CLOCK_SDCLKEN; 536 sdhci_writel(host, temp, ESDHC_SYSTEM_CONTROL); 537 } 538 539 static void esdhc_pltfm_set_bus_width(struct sdhci_host *host, int width) 540 { 541 u32 ctrl; 542 543 ctrl = sdhci_readl(host, ESDHC_PROCTL); 544 ctrl &= (~ESDHC_CTRL_BUSWIDTH_MASK); 545 switch (width) { 546 case MMC_BUS_WIDTH_8: 547 ctrl |= ESDHC_CTRL_8BITBUS; 548 break; 549 550 case MMC_BUS_WIDTH_4: 551 ctrl |= ESDHC_CTRL_4BITBUS; 552 break; 553 554 default: 555 break; 556 } 557 558 sdhci_writel(host, ctrl, ESDHC_PROCTL); 559 } 560 561 static void esdhc_clock_enable(struct sdhci_host *host, bool enable) 562 { 563 u32 val; 564 ktime_t timeout; 565 566 val = sdhci_readl(host, ESDHC_SYSTEM_CONTROL); 567 568 if (enable) 569 val |= ESDHC_CLOCK_SDCLKEN; 570 else 571 val &= ~ESDHC_CLOCK_SDCLKEN; 572 573 sdhci_writel(host, val, ESDHC_SYSTEM_CONTROL); 574 575 /* Wait max 20 ms */ 576 timeout = ktime_add_ms(ktime_get(), 20); 577 val = ESDHC_CLOCK_STABLE; 578 while (!(sdhci_readl(host, ESDHC_PRSSTAT) & val)) { 579 if (ktime_after(ktime_get(), timeout)) { 580 pr_err("%s: Internal clock never stabilised.\n", 581 mmc_hostname(host->mmc)); 582 break; 583 } 584 udelay(10); 585 } 586 } 587 588 static void esdhc_reset(struct sdhci_host *host, u8 mask) 589 { 590 sdhci_reset(host, mask); 591 592 sdhci_writel(host, host->ier, SDHCI_INT_ENABLE); 593 sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE); 594 } 595 596 /* The SCFG, Supplemental Configuration Unit, provides SoC specific 597 * configuration and status registers for the device. There is a 598 * SDHC IO VSEL control register on SCFG for some platforms. It's 599 * used to support SDHC IO voltage switching. 600 */ 601 static const struct of_device_id scfg_device_ids[] = { 602 { .compatible = "fsl,t1040-scfg", }, 603 { .compatible = "fsl,ls1012a-scfg", }, 604 { .compatible = "fsl,ls1046a-scfg", }, 605 {} 606 }; 607 608 /* SDHC IO VSEL control register definition */ 609 #define SCFG_SDHCIOVSELCR 0x408 610 #define SDHCIOVSELCR_TGLEN 0x80000000 611 #define SDHCIOVSELCR_VSELVAL 0x60000000 612 #define SDHCIOVSELCR_SDHC_VS 0x00000001 613 614 static int esdhc_signal_voltage_switch(struct mmc_host *mmc, 615 struct mmc_ios *ios) 616 { 617 struct sdhci_host *host = mmc_priv(mmc); 618 struct device_node *scfg_node; 619 void __iomem *scfg_base = NULL; 620 u32 sdhciovselcr; 621 u32 val; 622 623 /* 624 * Signal Voltage Switching is only applicable for Host Controllers 625 * v3.00 and above. 626 */ 627 if (host->version < SDHCI_SPEC_300) 628 return 0; 629 630 val = sdhci_readl(host, ESDHC_PROCTL); 631 632 switch (ios->signal_voltage) { 633 case MMC_SIGNAL_VOLTAGE_330: 634 val &= ~ESDHC_VOLT_SEL; 635 sdhci_writel(host, val, ESDHC_PROCTL); 636 return 0; 637 case MMC_SIGNAL_VOLTAGE_180: 638 scfg_node = of_find_matching_node(NULL, scfg_device_ids); 639 if (scfg_node) 640 scfg_base = of_iomap(scfg_node, 0); 641 if (scfg_base) { 642 sdhciovselcr = SDHCIOVSELCR_TGLEN | 643 SDHCIOVSELCR_VSELVAL; 644 iowrite32be(sdhciovselcr, 645 scfg_base + SCFG_SDHCIOVSELCR); 646 647 val |= ESDHC_VOLT_SEL; 648 sdhci_writel(host, val, ESDHC_PROCTL); 649 mdelay(5); 650 651 sdhciovselcr = SDHCIOVSELCR_TGLEN | 652 SDHCIOVSELCR_SDHC_VS; 653 iowrite32be(sdhciovselcr, 654 scfg_base + SCFG_SDHCIOVSELCR); 655 iounmap(scfg_base); 656 } else { 657 val |= ESDHC_VOLT_SEL; 658 sdhci_writel(host, val, ESDHC_PROCTL); 659 } 660 return 0; 661 default: 662 return 0; 663 } 664 } 665 666 static int esdhc_execute_tuning(struct mmc_host *mmc, u32 opcode) 667 { 668 struct sdhci_host *host = mmc_priv(mmc); 669 u32 val; 670 671 /* Use tuning block for tuning procedure */ 672 esdhc_clock_enable(host, false); 673 val = sdhci_readl(host, ESDHC_DMA_SYSCTL); 674 val |= ESDHC_FLUSH_ASYNC_FIFO; 675 sdhci_writel(host, val, ESDHC_DMA_SYSCTL); 676 677 val = sdhci_readl(host, ESDHC_TBCTL); 678 val |= ESDHC_TB_EN; 679 sdhci_writel(host, val, ESDHC_TBCTL); 680 esdhc_clock_enable(host, true); 681 682 return sdhci_execute_tuning(mmc, opcode); 683 } 684 685 #ifdef CONFIG_PM_SLEEP 686 static u32 esdhc_proctl; 687 static int esdhc_of_suspend(struct device *dev) 688 { 689 struct sdhci_host *host = dev_get_drvdata(dev); 690 691 esdhc_proctl = sdhci_readl(host, SDHCI_HOST_CONTROL); 692 693 if (host->tuning_mode != SDHCI_TUNING_MODE_3) 694 mmc_retune_needed(host->mmc); 695 696 return sdhci_suspend_host(host); 697 } 698 699 static int esdhc_of_resume(struct device *dev) 700 { 701 struct sdhci_host *host = dev_get_drvdata(dev); 702 int ret = sdhci_resume_host(host); 703 704 if (ret == 0) { 705 /* Isn't this already done by sdhci_resume_host() ? --rmk */ 706 esdhc_of_enable_dma(host); 707 sdhci_writel(host, esdhc_proctl, SDHCI_HOST_CONTROL); 708 } 709 return ret; 710 } 711 #endif 712 713 static SIMPLE_DEV_PM_OPS(esdhc_of_dev_pm_ops, 714 esdhc_of_suspend, 715 esdhc_of_resume); 716 717 static const struct sdhci_ops sdhci_esdhc_be_ops = { 718 .read_l = esdhc_be_readl, 719 .read_w = esdhc_be_readw, 720 .read_b = esdhc_be_readb, 721 .write_l = esdhc_be_writel, 722 .write_w = esdhc_be_writew, 723 .write_b = esdhc_be_writeb, 724 .set_clock = esdhc_of_set_clock, 725 .enable_dma = esdhc_of_enable_dma, 726 .get_max_clock = esdhc_of_get_max_clock, 727 .get_min_clock = esdhc_of_get_min_clock, 728 .adma_workaround = esdhc_of_adma_workaround, 729 .set_bus_width = esdhc_pltfm_set_bus_width, 730 .reset = esdhc_reset, 731 .set_uhs_signaling = sdhci_set_uhs_signaling, 732 }; 733 734 static const struct sdhci_ops sdhci_esdhc_le_ops = { 735 .read_l = esdhc_le_readl, 736 .read_w = esdhc_le_readw, 737 .read_b = esdhc_le_readb, 738 .write_l = esdhc_le_writel, 739 .write_w = esdhc_le_writew, 740 .write_b = esdhc_le_writeb, 741 .set_clock = esdhc_of_set_clock, 742 .enable_dma = esdhc_of_enable_dma, 743 .get_max_clock = esdhc_of_get_max_clock, 744 .get_min_clock = esdhc_of_get_min_clock, 745 .adma_workaround = esdhc_of_adma_workaround, 746 .set_bus_width = esdhc_pltfm_set_bus_width, 747 .reset = esdhc_reset, 748 .set_uhs_signaling = sdhci_set_uhs_signaling, 749 }; 750 751 static const struct sdhci_pltfm_data sdhci_esdhc_be_pdata = { 752 .quirks = ESDHC_DEFAULT_QUIRKS | 753 #ifdef CONFIG_PPC 754 SDHCI_QUIRK_BROKEN_CARD_DETECTION | 755 #endif 756 SDHCI_QUIRK_NO_CARD_NO_RESET | 757 SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC, 758 .ops = &sdhci_esdhc_be_ops, 759 }; 760 761 static const struct sdhci_pltfm_data sdhci_esdhc_le_pdata = { 762 .quirks = ESDHC_DEFAULT_QUIRKS | 763 SDHCI_QUIRK_NO_CARD_NO_RESET | 764 SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC, 765 .ops = &sdhci_esdhc_le_ops, 766 }; 767 768 static struct soc_device_attribute soc_incorrect_hostver[] = { 769 { .family = "QorIQ T4240", .revision = "1.0", }, 770 { .family = "QorIQ T4240", .revision = "2.0", }, 771 { }, 772 }; 773 774 static void esdhc_init(struct platform_device *pdev, struct sdhci_host *host) 775 { 776 struct sdhci_pltfm_host *pltfm_host; 777 struct sdhci_esdhc *esdhc; 778 struct device_node *np; 779 struct clk *clk; 780 u32 val; 781 u16 host_ver; 782 783 pltfm_host = sdhci_priv(host); 784 esdhc = sdhci_pltfm_priv(pltfm_host); 785 786 host_ver = sdhci_readw(host, SDHCI_HOST_VERSION); 787 esdhc->vendor_ver = (host_ver & SDHCI_VENDOR_VER_MASK) >> 788 SDHCI_VENDOR_VER_SHIFT; 789 esdhc->spec_ver = host_ver & SDHCI_SPEC_VER_MASK; 790 if (soc_device_match(soc_incorrect_hostver)) 791 esdhc->quirk_incorrect_hostver = true; 792 else 793 esdhc->quirk_incorrect_hostver = false; 794 795 np = pdev->dev.of_node; 796 clk = of_clk_get(np, 0); 797 if (!IS_ERR(clk)) { 798 /* 799 * esdhc->peripheral_clock would be assigned with a value 800 * which is eSDHC base clock when use periperal clock. 801 * For ls1046a, the clock value got by common clk API is 802 * peripheral clock while the eSDHC base clock is 1/2 803 * peripheral clock. 804 */ 805 if (of_device_is_compatible(np, "fsl,ls1046a-esdhc")) 806 esdhc->peripheral_clock = clk_get_rate(clk) / 2; 807 else 808 esdhc->peripheral_clock = clk_get_rate(clk); 809 810 clk_put(clk); 811 } 812 813 if (esdhc->peripheral_clock) { 814 esdhc_clock_enable(host, false); 815 val = sdhci_readl(host, ESDHC_DMA_SYSCTL); 816 val |= ESDHC_PERIPHERAL_CLK_SEL; 817 sdhci_writel(host, val, ESDHC_DMA_SYSCTL); 818 esdhc_clock_enable(host, true); 819 } 820 } 821 822 static int sdhci_esdhc_probe(struct platform_device *pdev) 823 { 824 struct sdhci_host *host; 825 struct device_node *np; 826 struct sdhci_pltfm_host *pltfm_host; 827 struct sdhci_esdhc *esdhc; 828 int ret; 829 830 np = pdev->dev.of_node; 831 832 if (of_property_read_bool(np, "little-endian")) 833 host = sdhci_pltfm_init(pdev, &sdhci_esdhc_le_pdata, 834 sizeof(struct sdhci_esdhc)); 835 else 836 host = sdhci_pltfm_init(pdev, &sdhci_esdhc_be_pdata, 837 sizeof(struct sdhci_esdhc)); 838 839 if (IS_ERR(host)) 840 return PTR_ERR(host); 841 842 host->mmc_host_ops.start_signal_voltage_switch = 843 esdhc_signal_voltage_switch; 844 host->mmc_host_ops.execute_tuning = esdhc_execute_tuning; 845 host->tuning_delay = 1; 846 847 esdhc_init(pdev, host); 848 849 sdhci_get_of_property(pdev); 850 851 pltfm_host = sdhci_priv(host); 852 esdhc = sdhci_pltfm_priv(pltfm_host); 853 if (esdhc->vendor_ver == VENDOR_V_22) 854 host->quirks2 |= SDHCI_QUIRK2_HOST_NO_CMD23; 855 856 if (esdhc->vendor_ver > VENDOR_V_22) 857 host->quirks &= ~SDHCI_QUIRK_NO_BUSY_IRQ; 858 859 if (of_device_is_compatible(np, "fsl,p5040-esdhc") || 860 of_device_is_compatible(np, "fsl,p5020-esdhc") || 861 of_device_is_compatible(np, "fsl,p4080-esdhc") || 862 of_device_is_compatible(np, "fsl,p1020-esdhc") || 863 of_device_is_compatible(np, "fsl,t1040-esdhc")) 864 host->quirks &= ~SDHCI_QUIRK_BROKEN_CARD_DETECTION; 865 866 if (of_device_is_compatible(np, "fsl,ls1021a-esdhc")) 867 host->quirks |= SDHCI_QUIRK_BROKEN_TIMEOUT_VAL; 868 869 if (of_device_is_compatible(np, "fsl,p2020-esdhc")) { 870 /* 871 * Freescale messed up with P2020 as it has a non-standard 872 * host control register 873 */ 874 host->quirks2 |= SDHCI_QUIRK2_BROKEN_HOST_CONTROL; 875 } 876 877 /* call to generic mmc_of_parse to support additional capabilities */ 878 ret = mmc_of_parse(host->mmc); 879 if (ret) 880 goto err; 881 882 mmc_of_parse_voltage(np, &host->ocr_mask); 883 884 ret = sdhci_add_host(host); 885 if (ret) 886 goto err; 887 888 return 0; 889 err: 890 sdhci_pltfm_free(pdev); 891 return ret; 892 } 893 894 static const struct of_device_id sdhci_esdhc_of_match[] = { 895 { .compatible = "fsl,mpc8379-esdhc" }, 896 { .compatible = "fsl,mpc8536-esdhc" }, 897 { .compatible = "fsl,esdhc" }, 898 { } 899 }; 900 MODULE_DEVICE_TABLE(of, sdhci_esdhc_of_match); 901 902 static struct platform_driver sdhci_esdhc_driver = { 903 .driver = { 904 .name = "sdhci-esdhc", 905 .of_match_table = sdhci_esdhc_of_match, 906 .pm = &esdhc_of_dev_pm_ops, 907 }, 908 .probe = sdhci_esdhc_probe, 909 .remove = sdhci_pltfm_unregister, 910 }; 911 912 module_platform_driver(sdhci_esdhc_driver); 913 914 MODULE_DESCRIPTION("SDHCI OF driver for Freescale MPC eSDHC"); 915 MODULE_AUTHOR("Xiaobo Xie <X.Xie@freescale.com>, " 916 "Anton Vorontsov <avorontsov@ru.mvista.com>"); 917 MODULE_LICENSE("GPL v2"); 918