1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * MediaTek SD/MMC Card Interface driver 4 * 5 * Copyright (C) 2018 MediaTek Inc. 6 * Author: Weijie Gao <weijie.gao@mediatek.com> 7 */ 8 9 #include <clk.h> 10 #include <common.h> 11 #include <dm.h> 12 #include <mmc.h> 13 #include <errno.h> 14 #include <malloc.h> 15 #include <stdbool.h> 16 #include <asm/gpio.h> 17 #include <dm/pinctrl.h> 18 #include <linux/bitops.h> 19 #include <linux/io.h> 20 #include <linux/iopoll.h> 21 22 /* MSDC_CFG */ 23 #define MSDC_CFG_HS400_CK_MODE_EXT BIT(22) 24 #define MSDC_CFG_CKMOD_EXT_M 0x300000 25 #define MSDC_CFG_CKMOD_EXT_S 20 26 #define MSDC_CFG_CKDIV_EXT_M 0xfff00 27 #define MSDC_CFG_CKDIV_EXT_S 8 28 #define MSDC_CFG_HS400_CK_MODE BIT(18) 29 #define MSDC_CFG_CKMOD_M 0x30000 30 #define MSDC_CFG_CKMOD_S 16 31 #define MSDC_CFG_CKDIV_M 0xff00 32 #define MSDC_CFG_CKDIV_S 8 33 #define MSDC_CFG_CKSTB BIT(7) 34 #define MSDC_CFG_PIO BIT(3) 35 #define MSDC_CFG_RST BIT(2) 36 #define MSDC_CFG_CKPDN BIT(1) 37 #define MSDC_CFG_MODE BIT(0) 38 39 /* MSDC_IOCON */ 40 #define MSDC_IOCON_W_DSPL BIT(8) 41 #define MSDC_IOCON_DSPL BIT(2) 42 #define MSDC_IOCON_RSPL BIT(1) 43 44 /* MSDC_PS */ 45 #define MSDC_PS_DAT0 BIT(16) 46 #define MSDC_PS_CDDBCE_M 0xf000 47 #define MSDC_PS_CDDBCE_S 12 48 #define MSDC_PS_CDSTS BIT(1) 49 #define MSDC_PS_CDEN BIT(0) 50 51 /* #define MSDC_INT(EN) */ 52 #define MSDC_INT_ACMDRDY BIT(3) 53 #define MSDC_INT_ACMDTMO BIT(4) 54 #define MSDC_INT_ACMDCRCERR BIT(5) 55 #define MSDC_INT_CMDRDY BIT(8) 56 #define MSDC_INT_CMDTMO BIT(9) 57 #define MSDC_INT_RSPCRCERR BIT(10) 58 #define MSDC_INT_XFER_COMPL BIT(12) 59 #define MSDC_INT_DATTMO BIT(14) 60 #define MSDC_INT_DATCRCERR BIT(15) 61 62 /* MSDC_FIFOCS */ 63 #define MSDC_FIFOCS_CLR BIT(31) 64 #define MSDC_FIFOCS_TXCNT_M 0xff0000 65 #define MSDC_FIFOCS_TXCNT_S 16 66 #define MSDC_FIFOCS_RXCNT_M 0xff 67 #define MSDC_FIFOCS_RXCNT_S 0 68 69 /* #define SDC_CFG */ 70 #define SDC_CFG_DTOC_M 0xff000000 71 #define SDC_CFG_DTOC_S 24 72 #define SDC_CFG_SDIOIDE BIT(20) 73 #define SDC_CFG_SDIO BIT(19) 74 #define SDC_CFG_BUSWIDTH_M 0x30000 75 #define SDC_CFG_BUSWIDTH_S 16 76 77 /* SDC_CMD */ 78 #define SDC_CMD_BLK_LEN_M 0xfff0000 79 #define SDC_CMD_BLK_LEN_S 16 80 #define SDC_CMD_STOP BIT(14) 81 #define SDC_CMD_WR BIT(13) 82 #define SDC_CMD_DTYPE_M 0x1800 83 #define SDC_CMD_DTYPE_S 11 84 #define SDC_CMD_RSPTYP_M 0x380 85 #define SDC_CMD_RSPTYP_S 7 86 #define SDC_CMD_CMD_M 0x3f 87 #define SDC_CMD_CMD_S 0 88 89 /* SDC_STS */ 90 #define SDC_STS_CMDBUSY BIT(1) 91 #define SDC_STS_SDCBUSY BIT(0) 92 93 /* SDC_ADV_CFG0 */ 94 #define SDC_RX_ENHANCE_EN BIT(20) 95 96 /* PATCH_BIT0 */ 97 #define MSDC_INT_DAT_LATCH_CK_SEL_M 0x380 98 #define MSDC_INT_DAT_LATCH_CK_SEL_S 7 99 100 /* PATCH_BIT1 */ 101 #define MSDC_PB1_STOP_DLY_M 0xf00 102 #define MSDC_PB1_STOP_DLY_S 8 103 104 /* PATCH_BIT2 */ 105 #define MSDC_PB2_CRCSTSENSEL_M 0xe0000000 106 #define MSDC_PB2_CRCSTSENSEL_S 29 107 #define MSDC_PB2_CFGCRCSTS BIT(28) 108 #define MSDC_PB2_RESPSTSENSEL_M 0x70000 109 #define MSDC_PB2_RESPSTSENSEL_S 16 110 #define MSDC_PB2_CFGRESP BIT(15) 111 #define MSDC_PB2_RESPWAIT_M 0x0c 112 #define MSDC_PB2_RESPWAIT_S 2 113 114 /* PAD_TUNE */ 115 #define MSDC_PAD_TUNE_CMDRRDLY_M 0x7c00000 116 #define MSDC_PAD_TUNE_CMDRRDLY_S 22 117 #define MSDC_PAD_TUNE_CMD_SEL BIT(21) 118 #define MSDC_PAD_TUNE_CMDRDLY_M 0x1f0000 119 #define MSDC_PAD_TUNE_CMDRDLY_S 16 120 #define MSDC_PAD_TUNE_RXDLYSEL BIT(15) 121 #define MSDC_PAD_TUNE_RD_SEL BIT(13) 122 #define MSDC_PAD_TUNE_DATRRDLY_M 0x1f00 123 #define MSDC_PAD_TUNE_DATRRDLY_S 8 124 #define MSDC_PAD_TUNE_DATWRDLY_M 0x1f 125 #define MSDC_PAD_TUNE_DATWRDLY_S 0 126 127 /* EMMC50_CFG0 */ 128 #define EMMC50_CFG_CFCSTS_SEL BIT(4) 129 130 /* SDC_FIFO_CFG */ 131 #define SDC_FIFO_CFG_WRVALIDSEL BIT(24) 132 #define SDC_FIFO_CFG_RDVALIDSEL BIT(25) 133 134 /* SDC_CFG_BUSWIDTH */ 135 #define MSDC_BUS_1BITS 0x0 136 #define MSDC_BUS_4BITS 0x1 137 #define MSDC_BUS_8BITS 0x2 138 139 #define MSDC_FIFO_SIZE 128 140 141 #define PAD_DELAY_MAX 32 142 143 #define DEFAULT_CD_DEBOUNCE 8 144 145 #define CMD_INTS_MASK \ 146 (MSDC_INT_CMDRDY | MSDC_INT_RSPCRCERR | MSDC_INT_CMDTMO) 147 148 #define DATA_INTS_MASK \ 149 (MSDC_INT_XFER_COMPL | MSDC_INT_DATTMO | MSDC_INT_DATCRCERR) 150 151 /* Register offset */ 152 struct mtk_sd_regs { 153 u32 msdc_cfg; 154 u32 msdc_iocon; 155 u32 msdc_ps; 156 u32 msdc_int; 157 u32 msdc_inten; 158 u32 msdc_fifocs; 159 u32 msdc_txdata; 160 u32 msdc_rxdata; 161 u32 reserved0[4]; 162 u32 sdc_cfg; 163 u32 sdc_cmd; 164 u32 sdc_arg; 165 u32 sdc_sts; 166 u32 sdc_resp[4]; 167 u32 sdc_blk_num; 168 u32 sdc_vol_chg; 169 u32 sdc_csts; 170 u32 sdc_csts_en; 171 u32 sdc_datcrc_sts; 172 u32 sdc_adv_cfg0; 173 u32 reserved1[2]; 174 u32 emmc_cfg0; 175 u32 emmc_cfg1; 176 u32 emmc_sts; 177 u32 emmc_iocon; 178 u32 sd_acmd_resp; 179 u32 sd_acmd19_trg; 180 u32 sd_acmd19_sts; 181 u32 dma_sa_high4bit; 182 u32 dma_sa; 183 u32 dma_ca; 184 u32 dma_ctrl; 185 u32 dma_cfg; 186 u32 sw_dbg_sel; 187 u32 sw_dbg_out; 188 u32 dma_length; 189 u32 reserved2; 190 u32 patch_bit0; 191 u32 patch_bit1; 192 u32 patch_bit2; 193 u32 reserved3; 194 u32 dat0_tune_crc; 195 u32 dat1_tune_crc; 196 u32 dat2_tune_crc; 197 u32 dat3_tune_crc; 198 u32 cmd_tune_crc; 199 u32 sdio_tune_wind; 200 u32 reserved4[5]; 201 u32 pad_tune; 202 u32 pad_tune0; 203 u32 pad_tune1; 204 u32 dat_rd_dly[4]; 205 u32 reserved5[2]; 206 u32 hw_dbg_sel; 207 u32 main_ver; 208 u32 eco_ver; 209 u32 reserved6[27]; 210 u32 pad_ds_tune; 211 u32 reserved7[31]; 212 u32 emmc50_cfg0; 213 u32 reserved8[7]; 214 u32 sdc_fifo_cfg; 215 }; 216 217 struct msdc_compatible { 218 u8 clk_div_bits; 219 bool pad_tune0; 220 bool async_fifo; 221 bool data_tune; 222 bool busy_check; 223 bool stop_clk_fix; 224 bool enhance_rx; 225 }; 226 227 struct msdc_delay_phase { 228 u8 maxlen; 229 u8 start; 230 u8 final_phase; 231 }; 232 233 struct msdc_plat { 234 struct mmc_config cfg; 235 struct mmc mmc; 236 }; 237 238 struct msdc_tune_para { 239 u32 iocon; 240 u32 pad_tune; 241 }; 242 243 struct msdc_host { 244 struct mtk_sd_regs *base; 245 struct mmc *mmc; 246 247 struct msdc_compatible *dev_comp; 248 249 struct clk src_clk; /* for SD/MMC bus clock */ 250 struct clk h_clk; /* MSDC core clock */ 251 252 u32 src_clk_freq; /* source clock */ 253 u32 mclk; /* mmc framework required bus clock */ 254 u32 sclk; /* actual calculated bus clock */ 255 256 /* operation timeout clocks */ 257 u32 timeout_ns; 258 u32 timeout_clks; 259 260 /* tuning options */ 261 u32 hs400_ds_delay; 262 u32 hs200_cmd_int_delay; 263 u32 hs200_write_int_delay; 264 u32 latch_ck; 265 u32 r_smpl; /* sample edge */ 266 bool hs400_mode; 267 268 /* whether to use gpio detection or built-in hw detection */ 269 bool builtin_cd; 270 271 /* card detection / write protection GPIOs */ 272 #if IS_ENABLED(DM_GPIO) 273 struct gpio_desc gpio_wp; 274 struct gpio_desc gpio_cd; 275 #endif 276 277 uint last_resp_type; 278 uint last_data_write; 279 280 enum bus_mode timing; 281 282 struct msdc_tune_para def_tune_para; 283 struct msdc_tune_para saved_tune_para; 284 }; 285 286 static void msdc_reset_hw(struct msdc_host *host) 287 { 288 u32 reg; 289 290 setbits_le32(&host->base->msdc_cfg, MSDC_CFG_RST); 291 292 readl_poll_timeout(&host->base->msdc_cfg, reg, 293 !(reg & MSDC_CFG_RST), 1000000); 294 } 295 296 static void msdc_fifo_clr(struct msdc_host *host) 297 { 298 u32 reg; 299 300 setbits_le32(&host->base->msdc_fifocs, MSDC_FIFOCS_CLR); 301 302 readl_poll_timeout(&host->base->msdc_fifocs, reg, 303 !(reg & MSDC_FIFOCS_CLR), 1000000); 304 } 305 306 static u32 msdc_fifo_rx_bytes(struct msdc_host *host) 307 { 308 return (readl(&host->base->msdc_fifocs) & 309 MSDC_FIFOCS_RXCNT_M) >> MSDC_FIFOCS_RXCNT_S; 310 } 311 312 static u32 msdc_fifo_tx_bytes(struct msdc_host *host) 313 { 314 return (readl(&host->base->msdc_fifocs) & 315 MSDC_FIFOCS_TXCNT_M) >> MSDC_FIFOCS_TXCNT_S; 316 } 317 318 static u32 msdc_cmd_find_resp(struct msdc_host *host, struct mmc_cmd *cmd) 319 { 320 u32 resp; 321 322 switch (cmd->resp_type) { 323 /* Actually, R1, R5, R6, R7 are the same */ 324 case MMC_RSP_R1: 325 resp = 0x1; 326 break; 327 case MMC_RSP_R1b: 328 resp = 0x7; 329 break; 330 case MMC_RSP_R2: 331 resp = 0x2; 332 break; 333 case MMC_RSP_R3: 334 resp = 0x3; 335 break; 336 case MMC_RSP_NONE: 337 default: 338 resp = 0x0; 339 break; 340 } 341 342 return resp; 343 } 344 345 static u32 msdc_cmd_prepare_raw_cmd(struct msdc_host *host, 346 struct mmc_cmd *cmd, 347 struct mmc_data *data) 348 { 349 u32 opcode = cmd->cmdidx; 350 u32 resp_type = msdc_cmd_find_resp(host, cmd); 351 uint blocksize = 0; 352 u32 dtype = 0; 353 u32 rawcmd = 0; 354 355 switch (opcode) { 356 case MMC_CMD_WRITE_MULTIPLE_BLOCK: 357 case MMC_CMD_READ_MULTIPLE_BLOCK: 358 dtype = 2; 359 break; 360 case MMC_CMD_WRITE_SINGLE_BLOCK: 361 case MMC_CMD_READ_SINGLE_BLOCK: 362 case SD_CMD_APP_SEND_SCR: 363 dtype = 1; 364 break; 365 case SD_CMD_SWITCH_FUNC: /* same as MMC_CMD_SWITCH */ 366 case SD_CMD_SEND_IF_COND: /* same as MMC_CMD_SEND_EXT_CSD */ 367 case SD_CMD_APP_SD_STATUS: /* same as MMC_CMD_SEND_STATUS */ 368 if (data) 369 dtype = 1; 370 } 371 372 if (data) { 373 if (data->flags == MMC_DATA_WRITE) 374 rawcmd |= SDC_CMD_WR; 375 376 if (data->blocks > 1) 377 dtype = 2; 378 379 blocksize = data->blocksize; 380 } 381 382 rawcmd |= ((opcode << SDC_CMD_CMD_S) & SDC_CMD_CMD_M) | 383 ((resp_type << SDC_CMD_RSPTYP_S) & SDC_CMD_RSPTYP_M) | 384 ((blocksize << SDC_CMD_BLK_LEN_S) & SDC_CMD_BLK_LEN_M) | 385 ((dtype << SDC_CMD_DTYPE_S) & SDC_CMD_DTYPE_M); 386 387 if (opcode == MMC_CMD_STOP_TRANSMISSION) 388 rawcmd |= SDC_CMD_STOP; 389 390 return rawcmd; 391 } 392 393 static int msdc_cmd_done(struct msdc_host *host, int events, 394 struct mmc_cmd *cmd) 395 { 396 u32 *rsp = cmd->response; 397 int ret = 0; 398 399 if (cmd->resp_type & MMC_RSP_PRESENT) { 400 if (cmd->resp_type & MMC_RSP_136) { 401 rsp[0] = readl(&host->base->sdc_resp[3]); 402 rsp[1] = readl(&host->base->sdc_resp[2]); 403 rsp[2] = readl(&host->base->sdc_resp[1]); 404 rsp[3] = readl(&host->base->sdc_resp[0]); 405 } else { 406 rsp[0] = readl(&host->base->sdc_resp[0]); 407 } 408 } 409 410 if (!(events & MSDC_INT_CMDRDY)) { 411 if (cmd->cmdidx != MMC_CMD_SEND_TUNING_BLOCK && 412 cmd->cmdidx != MMC_CMD_SEND_TUNING_BLOCK_HS200) 413 /* 414 * should not clear fifo/interrupt as the tune data 415 * may have alreay come. 416 */ 417 msdc_reset_hw(host); 418 419 if (events & MSDC_INT_CMDTMO) 420 ret = -ETIMEDOUT; 421 else 422 ret = -EIO; 423 } 424 425 return ret; 426 } 427 428 static bool msdc_cmd_is_ready(struct msdc_host *host) 429 { 430 int ret; 431 u32 reg; 432 433 /* The max busy time we can endure is 20ms */ 434 ret = readl_poll_timeout(&host->base->sdc_sts, reg, 435 !(reg & SDC_STS_CMDBUSY), 20000); 436 437 if (ret) { 438 pr_err("CMD bus busy detected\n"); 439 msdc_reset_hw(host); 440 return false; 441 } 442 443 if (host->last_resp_type == MMC_RSP_R1b && host->last_data_write) { 444 ret = readl_poll_timeout(&host->base->msdc_ps, reg, 445 reg & MSDC_PS_DAT0, 1000000); 446 447 if (ret) { 448 pr_err("Card stuck in programming state!\n"); 449 msdc_reset_hw(host); 450 return false; 451 } 452 } 453 454 return true; 455 } 456 457 static int msdc_start_command(struct msdc_host *host, struct mmc_cmd *cmd, 458 struct mmc_data *data) 459 { 460 u32 rawcmd; 461 u32 status; 462 u32 blocks = 0; 463 int ret; 464 465 if (!msdc_cmd_is_ready(host)) 466 return -EIO; 467 468 msdc_fifo_clr(host); 469 470 host->last_resp_type = cmd->resp_type; 471 host->last_data_write = 0; 472 473 rawcmd = msdc_cmd_prepare_raw_cmd(host, cmd, data); 474 475 if (data) 476 blocks = data->blocks; 477 478 writel(CMD_INTS_MASK, &host->base->msdc_int); 479 writel(blocks, &host->base->sdc_blk_num); 480 writel(cmd->cmdarg, &host->base->sdc_arg); 481 writel(rawcmd, &host->base->sdc_cmd); 482 483 ret = readl_poll_timeout(&host->base->msdc_int, status, 484 status & CMD_INTS_MASK, 1000000); 485 486 if (ret) 487 status = MSDC_INT_CMDTMO; 488 489 return msdc_cmd_done(host, status, cmd); 490 } 491 492 static void msdc_fifo_read(struct msdc_host *host, u8 *buf, u32 size) 493 { 494 u32 *wbuf; 495 496 while ((size_t)buf % 4) { 497 *buf++ = readb(&host->base->msdc_rxdata); 498 size--; 499 } 500 501 wbuf = (u32 *)buf; 502 while (size >= 4) { 503 *wbuf++ = readl(&host->base->msdc_rxdata); 504 size -= 4; 505 } 506 507 buf = (u8 *)wbuf; 508 while (size) { 509 *buf++ = readb(&host->base->msdc_rxdata); 510 size--; 511 } 512 } 513 514 static void msdc_fifo_write(struct msdc_host *host, const u8 *buf, u32 size) 515 { 516 const u32 *wbuf; 517 518 while ((size_t)buf % 4) { 519 writeb(*buf++, &host->base->msdc_txdata); 520 size--; 521 } 522 523 wbuf = (const u32 *)buf; 524 while (size >= 4) { 525 writel(*wbuf++, &host->base->msdc_txdata); 526 size -= 4; 527 } 528 529 buf = (const u8 *)wbuf; 530 while (size) { 531 writeb(*buf++, &host->base->msdc_txdata); 532 size--; 533 } 534 } 535 536 static int msdc_pio_read(struct msdc_host *host, u8 *ptr, u32 size) 537 { 538 u32 status; 539 u32 chksz; 540 int ret = 0; 541 542 while (1) { 543 status = readl(&host->base->msdc_int); 544 writel(status, &host->base->msdc_int); 545 status &= DATA_INTS_MASK; 546 547 if (status & MSDC_INT_DATCRCERR) { 548 ret = -EIO; 549 break; 550 } 551 552 if (status & MSDC_INT_DATTMO) { 553 ret = -ETIMEDOUT; 554 break; 555 } 556 557 chksz = min(size, (u32)MSDC_FIFO_SIZE); 558 559 if (msdc_fifo_rx_bytes(host) >= chksz) { 560 msdc_fifo_read(host, ptr, chksz); 561 ptr += chksz; 562 size -= chksz; 563 } 564 565 if (status & MSDC_INT_XFER_COMPL) { 566 if (size) { 567 pr_err("data not fully read\n"); 568 ret = -EIO; 569 } 570 571 break; 572 } 573 } 574 575 return ret; 576 } 577 578 static int msdc_pio_write(struct msdc_host *host, const u8 *ptr, u32 size) 579 { 580 u32 status; 581 u32 chksz; 582 int ret = 0; 583 584 while (1) { 585 status = readl(&host->base->msdc_int); 586 writel(status, &host->base->msdc_int); 587 status &= DATA_INTS_MASK; 588 589 if (status & MSDC_INT_DATCRCERR) { 590 ret = -EIO; 591 break; 592 } 593 594 if (status & MSDC_INT_DATTMO) { 595 ret = -ETIMEDOUT; 596 break; 597 } 598 599 if (status & MSDC_INT_XFER_COMPL) { 600 if (size) { 601 pr_err("data not fully written\n"); 602 ret = -EIO; 603 } 604 605 break; 606 } 607 608 chksz = min(size, (u32)MSDC_FIFO_SIZE); 609 610 if (MSDC_FIFO_SIZE - msdc_fifo_tx_bytes(host) >= chksz) { 611 msdc_fifo_write(host, ptr, chksz); 612 ptr += chksz; 613 size -= chksz; 614 } 615 } 616 617 return ret; 618 } 619 620 static int msdc_start_data(struct msdc_host *host, struct mmc_data *data) 621 { 622 u32 size; 623 int ret; 624 625 if (data->flags == MMC_DATA_WRITE) 626 host->last_data_write = 1; 627 628 writel(DATA_INTS_MASK, &host->base->msdc_int); 629 630 size = data->blocks * data->blocksize; 631 632 if (data->flags == MMC_DATA_WRITE) 633 ret = msdc_pio_write(host, (const u8 *)data->src, size); 634 else 635 ret = msdc_pio_read(host, (u8 *)data->dest, size); 636 637 if (ret) { 638 msdc_reset_hw(host); 639 msdc_fifo_clr(host); 640 } 641 642 return ret; 643 } 644 645 static int msdc_ops_send_cmd(struct udevice *dev, struct mmc_cmd *cmd, 646 struct mmc_data *data) 647 { 648 struct msdc_host *host = dev_get_priv(dev); 649 int ret; 650 651 ret = msdc_start_command(host, cmd, data); 652 if (ret) 653 return ret; 654 655 if (data) 656 return msdc_start_data(host, data); 657 658 return 0; 659 } 660 661 static void msdc_set_timeout(struct msdc_host *host, u32 ns, u32 clks) 662 { 663 u32 timeout, clk_ns; 664 u32 mode = 0; 665 666 host->timeout_ns = ns; 667 host->timeout_clks = clks; 668 669 if (host->sclk == 0) { 670 timeout = 0; 671 } else { 672 clk_ns = 1000000000UL / host->sclk; 673 timeout = (ns + clk_ns - 1) / clk_ns + clks; 674 /* unit is 1048576 sclk cycles */ 675 timeout = (timeout + (0x1 << 20) - 1) >> 20; 676 if (host->dev_comp->clk_div_bits == 8) 677 mode = (readl(&host->base->msdc_cfg) & 678 MSDC_CFG_CKMOD_M) >> MSDC_CFG_CKMOD_S; 679 else 680 mode = (readl(&host->base->msdc_cfg) & 681 MSDC_CFG_CKMOD_EXT_M) >> MSDC_CFG_CKMOD_EXT_S; 682 /* DDR mode will double the clk cycles for data timeout */ 683 timeout = mode >= 2 ? timeout * 2 : timeout; 684 timeout = timeout > 1 ? timeout - 1 : 0; 685 timeout = timeout > 255 ? 255 : timeout; 686 } 687 688 clrsetbits_le32(&host->base->sdc_cfg, SDC_CFG_DTOC_M, 689 timeout << SDC_CFG_DTOC_S); 690 } 691 692 static void msdc_set_buswidth(struct msdc_host *host, u32 width) 693 { 694 u32 val = readl(&host->base->sdc_cfg); 695 696 val &= ~SDC_CFG_BUSWIDTH_M; 697 698 switch (width) { 699 default: 700 case 1: 701 val |= (MSDC_BUS_1BITS << SDC_CFG_BUSWIDTH_S); 702 break; 703 case 4: 704 val |= (MSDC_BUS_4BITS << SDC_CFG_BUSWIDTH_S); 705 break; 706 case 8: 707 val |= (MSDC_BUS_8BITS << SDC_CFG_BUSWIDTH_S); 708 break; 709 } 710 711 writel(val, &host->base->sdc_cfg); 712 } 713 714 static void msdc_set_mclk(struct msdc_host *host, enum bus_mode timing, u32 hz) 715 { 716 u32 mode; 717 u32 div; 718 u32 sclk; 719 u32 reg; 720 721 if (!hz) { 722 host->mclk = 0; 723 clrbits_le32(&host->base->msdc_cfg, MSDC_CFG_CKPDN); 724 return; 725 } 726 727 if (host->dev_comp->clk_div_bits == 8) 728 clrbits_le32(&host->base->msdc_cfg, MSDC_CFG_HS400_CK_MODE); 729 else 730 clrbits_le32(&host->base->msdc_cfg, 731 MSDC_CFG_HS400_CK_MODE_EXT); 732 733 if (timing == UHS_DDR50 || timing == MMC_DDR_52 || 734 timing == MMC_HS_400) { 735 if (timing == MMC_HS_400) 736 mode = 0x3; 737 else 738 mode = 0x2; /* ddr mode and use divisor */ 739 740 if (hz >= (host->src_clk_freq >> 2)) { 741 div = 0; /* mean div = 1/4 */ 742 sclk = host->src_clk_freq >> 2; /* sclk = clk / 4 */ 743 } else { 744 div = (host->src_clk_freq + ((hz << 2) - 1)) / 745 (hz << 2); 746 sclk = (host->src_clk_freq >> 2) / div; 747 div = (div >> 1); 748 } 749 750 if (timing == MMC_HS_400 && hz >= (host->src_clk_freq >> 1)) { 751 if (host->dev_comp->clk_div_bits == 8) 752 setbits_le32(&host->base->msdc_cfg, 753 MSDC_CFG_HS400_CK_MODE); 754 else 755 setbits_le32(&host->base->msdc_cfg, 756 MSDC_CFG_HS400_CK_MODE_EXT); 757 758 sclk = host->src_clk_freq >> 1; 759 div = 0; /* div is ignore when bit18 is set */ 760 } 761 } else if (hz >= host->src_clk_freq) { 762 mode = 0x1; /* no divisor */ 763 div = 0; 764 sclk = host->src_clk_freq; 765 } else { 766 mode = 0x0; /* use divisor */ 767 if (hz >= (host->src_clk_freq >> 1)) { 768 div = 0; /* mean div = 1/2 */ 769 sclk = host->src_clk_freq >> 1; /* sclk = clk / 2 */ 770 } else { 771 div = (host->src_clk_freq + ((hz << 2) - 1)) / 772 (hz << 2); 773 sclk = (host->src_clk_freq >> 2) / div; 774 } 775 } 776 777 clrbits_le32(&host->base->msdc_cfg, MSDC_CFG_CKPDN); 778 779 if (host->dev_comp->clk_div_bits == 8) { 780 div = min(div, (u32)(MSDC_CFG_CKDIV_M >> MSDC_CFG_CKDIV_S)); 781 clrsetbits_le32(&host->base->msdc_cfg, 782 MSDC_CFG_CKMOD_M | MSDC_CFG_CKDIV_M, 783 (mode << MSDC_CFG_CKMOD_S) | 784 (div << MSDC_CFG_CKDIV_S)); 785 } else { 786 div = min(div, (u32)(MSDC_CFG_CKDIV_EXT_M >> 787 MSDC_CFG_CKDIV_EXT_S)); 788 clrsetbits_le32(&host->base->msdc_cfg, 789 MSDC_CFG_CKMOD_EXT_M | MSDC_CFG_CKDIV_EXT_M, 790 (mode << MSDC_CFG_CKMOD_EXT_S) | 791 (div << MSDC_CFG_CKDIV_EXT_S)); 792 } 793 794 readl_poll_timeout(&host->base->msdc_cfg, reg, 795 reg & MSDC_CFG_CKSTB, 1000000); 796 797 setbits_le32(&host->base->msdc_cfg, MSDC_CFG_CKPDN); 798 host->sclk = sclk; 799 host->mclk = hz; 800 host->timing = timing; 801 802 /* needed because clk changed. */ 803 msdc_set_timeout(host, host->timeout_ns, host->timeout_clks); 804 805 /* 806 * mmc_select_hs400() will drop to 50Mhz and High speed mode, 807 * tune result of hs200/200Mhz is not suitable for 50Mhz 808 */ 809 if (host->sclk <= 52000000) { 810 writel(host->def_tune_para.iocon, &host->base->msdc_iocon); 811 writel(host->def_tune_para.pad_tune, 812 &host->base->pad_tune); 813 } else { 814 writel(host->saved_tune_para.iocon, &host->base->msdc_iocon); 815 writel(host->saved_tune_para.pad_tune, 816 &host->base->pad_tune); 817 } 818 819 dev_dbg(dev, "sclk: %d, timing: %d\n", host->sclk, timing); 820 } 821 822 static int msdc_ops_set_ios(struct udevice *dev) 823 { 824 struct msdc_plat *plat = dev_get_platdata(dev); 825 struct msdc_host *host = dev_get_priv(dev); 826 struct mmc *mmc = &plat->mmc; 827 uint clock = mmc->clock; 828 829 msdc_set_buswidth(host, mmc->bus_width); 830 831 if (mmc->clk_disable) 832 clock = 0; 833 else if (clock < mmc->cfg->f_min) 834 clock = mmc->cfg->f_min; 835 836 if (host->mclk != clock || host->timing != mmc->selected_mode) 837 msdc_set_mclk(host, mmc->selected_mode, clock); 838 839 return 0; 840 } 841 842 static int msdc_ops_get_cd(struct udevice *dev) 843 { 844 struct msdc_host *host = dev_get_priv(dev); 845 u32 val; 846 847 if (host->builtin_cd) { 848 val = readl(&host->base->msdc_ps); 849 return !(val & MSDC_PS_CDSTS); 850 } 851 852 #if IS_ENABLED(DM_GPIO) 853 if (!host->gpio_cd.dev) 854 return 1; 855 856 return dm_gpio_get_value(&host->gpio_cd); 857 #else 858 return 1; 859 #endif 860 } 861 862 static int msdc_ops_get_wp(struct udevice *dev) 863 { 864 #if IS_ENABLED(DM_GPIO) 865 struct msdc_host *host = dev_get_priv(dev); 866 867 if (!host->gpio_wp.dev) 868 return 0; 869 870 return !dm_gpio_get_value(&host->gpio_wp); 871 #else 872 return 0; 873 #endif 874 } 875 876 #ifdef MMC_SUPPORTS_TUNING 877 static u32 test_delay_bit(u32 delay, u32 bit) 878 { 879 bit %= PAD_DELAY_MAX; 880 return delay & (1 << bit); 881 } 882 883 static int get_delay_len(u32 delay, u32 start_bit) 884 { 885 int i; 886 887 for (i = 0; i < (PAD_DELAY_MAX - start_bit); i++) { 888 if (test_delay_bit(delay, start_bit + i) == 0) 889 return i; 890 } 891 892 return PAD_DELAY_MAX - start_bit; 893 } 894 895 static struct msdc_delay_phase get_best_delay(struct msdc_host *host, u32 delay) 896 { 897 int start = 0, len = 0; 898 int start_final = 0, len_final = 0; 899 u8 final_phase = 0xff; 900 struct msdc_delay_phase delay_phase = { 0, }; 901 902 if (delay == 0) { 903 dev_err(dev, "phase error: [map:%x]\n", delay); 904 delay_phase.final_phase = final_phase; 905 return delay_phase; 906 } 907 908 while (start < PAD_DELAY_MAX) { 909 len = get_delay_len(delay, start); 910 if (len_final < len) { 911 start_final = start; 912 len_final = len; 913 } 914 915 start += len ? len : 1; 916 if (len >= 12 && start_final < 4) 917 break; 918 } 919 920 /* The rule is to find the smallest delay cell */ 921 if (start_final == 0) 922 final_phase = (start_final + len_final / 3) % PAD_DELAY_MAX; 923 else 924 final_phase = (start_final + len_final / 2) % PAD_DELAY_MAX; 925 926 dev_info(dev, "phase: [map:%x] [maxlen:%d] [final:%d]\n", 927 delay, len_final, final_phase); 928 929 delay_phase.maxlen = len_final; 930 delay_phase.start = start_final; 931 delay_phase.final_phase = final_phase; 932 return delay_phase; 933 } 934 935 static int msdc_tune_response(struct udevice *dev, u32 opcode) 936 { 937 struct msdc_plat *plat = dev_get_platdata(dev); 938 struct msdc_host *host = dev_get_priv(dev); 939 struct mmc *mmc = &plat->mmc; 940 u32 rise_delay = 0, fall_delay = 0; 941 struct msdc_delay_phase final_rise_delay, final_fall_delay = { 0, }; 942 struct msdc_delay_phase internal_delay_phase; 943 u8 final_delay, final_maxlen; 944 u32 internal_delay = 0; 945 void __iomem *tune_reg = &host->base->pad_tune; 946 int cmd_err; 947 int i, j; 948 949 if (host->dev_comp->pad_tune0) 950 tune_reg = &host->base->pad_tune0; 951 952 if (mmc->selected_mode == MMC_HS_200 || 953 mmc->selected_mode == UHS_SDR104) 954 clrsetbits_le32(tune_reg, MSDC_PAD_TUNE_CMDRRDLY_M, 955 host->hs200_cmd_int_delay << 956 MSDC_PAD_TUNE_CMDRRDLY_S); 957 958 clrbits_le32(&host->base->msdc_iocon, MSDC_IOCON_RSPL); 959 960 for (i = 0; i < PAD_DELAY_MAX; i++) { 961 clrsetbits_le32(tune_reg, MSDC_PAD_TUNE_CMDRDLY_M, 962 i << MSDC_PAD_TUNE_CMDRDLY_S); 963 964 for (j = 0; j < 3; j++) { 965 mmc_send_tuning(mmc, opcode, &cmd_err); 966 if (!cmd_err) { 967 rise_delay |= (1 << i); 968 } else { 969 rise_delay &= ~(1 << i); 970 break; 971 } 972 } 973 } 974 975 final_rise_delay = get_best_delay(host, rise_delay); 976 /* if rising edge has enough margin, do not scan falling edge */ 977 if (final_rise_delay.maxlen >= 12 || 978 (final_rise_delay.start == 0 && final_rise_delay.maxlen >= 4)) 979 goto skip_fall; 980 981 setbits_le32(&host->base->msdc_iocon, MSDC_IOCON_RSPL); 982 for (i = 0; i < PAD_DELAY_MAX; i++) { 983 clrsetbits_le32(tune_reg, MSDC_PAD_TUNE_CMDRDLY_M, 984 i << MSDC_PAD_TUNE_CMDRDLY_S); 985 986 for (j = 0; j < 3; j++) { 987 mmc_send_tuning(mmc, opcode, &cmd_err); 988 if (!cmd_err) { 989 fall_delay |= (1 << i); 990 } else { 991 fall_delay &= ~(1 << i); 992 break; 993 } 994 } 995 } 996 997 final_fall_delay = get_best_delay(host, fall_delay); 998 999 skip_fall: 1000 final_maxlen = max(final_rise_delay.maxlen, final_fall_delay.maxlen); 1001 if (final_maxlen == final_rise_delay.maxlen) { 1002 clrbits_le32(&host->base->msdc_iocon, MSDC_IOCON_RSPL); 1003 clrsetbits_le32(tune_reg, MSDC_PAD_TUNE_CMDRDLY_M, 1004 final_rise_delay.final_phase << 1005 MSDC_PAD_TUNE_CMDRDLY_S); 1006 final_delay = final_rise_delay.final_phase; 1007 } else { 1008 setbits_le32(&host->base->msdc_iocon, MSDC_IOCON_RSPL); 1009 clrsetbits_le32(tune_reg, MSDC_PAD_TUNE_CMDRDLY_M, 1010 final_fall_delay.final_phase << 1011 MSDC_PAD_TUNE_CMDRDLY_S); 1012 final_delay = final_fall_delay.final_phase; 1013 } 1014 1015 if (host->dev_comp->async_fifo || host->hs200_cmd_int_delay) 1016 goto skip_internal; 1017 1018 for (i = 0; i < PAD_DELAY_MAX; i++) { 1019 clrsetbits_le32(tune_reg, MSDC_PAD_TUNE_CMDRRDLY_M, 1020 i << MSDC_PAD_TUNE_CMDRRDLY_S); 1021 1022 mmc_send_tuning(mmc, opcode, &cmd_err); 1023 if (!cmd_err) 1024 internal_delay |= (1 << i); 1025 } 1026 1027 dev_err(dev, "Final internal delay: 0x%x\n", internal_delay); 1028 1029 internal_delay_phase = get_best_delay(host, internal_delay); 1030 clrsetbits_le32(tune_reg, MSDC_PAD_TUNE_CMDRRDLY_M, 1031 internal_delay_phase.final_phase << 1032 MSDC_PAD_TUNE_CMDRRDLY_S); 1033 1034 skip_internal: 1035 dev_err(dev, "Final cmd pad delay: %x\n", final_delay); 1036 return final_delay == 0xff ? -EIO : 0; 1037 } 1038 1039 static int msdc_tune_data(struct udevice *dev, u32 opcode) 1040 { 1041 struct msdc_plat *plat = dev_get_platdata(dev); 1042 struct msdc_host *host = dev_get_priv(dev); 1043 struct mmc *mmc = &plat->mmc; 1044 u32 rise_delay = 0, fall_delay = 0; 1045 struct msdc_delay_phase final_rise_delay, final_fall_delay = { 0, }; 1046 u8 final_delay, final_maxlen; 1047 void __iomem *tune_reg = &host->base->pad_tune; 1048 int cmd_err; 1049 int i, ret; 1050 1051 if (host->dev_comp->pad_tune0) 1052 tune_reg = &host->base->pad_tune0; 1053 1054 clrbits_le32(&host->base->msdc_iocon, MSDC_IOCON_DSPL); 1055 clrbits_le32(&host->base->msdc_iocon, MSDC_IOCON_W_DSPL); 1056 1057 for (i = 0; i < PAD_DELAY_MAX; i++) { 1058 clrsetbits_le32(tune_reg, MSDC_PAD_TUNE_DATRRDLY_M, 1059 i << MSDC_PAD_TUNE_DATRRDLY_S); 1060 1061 ret = mmc_send_tuning(mmc, opcode, &cmd_err); 1062 if (!ret) { 1063 rise_delay |= (1 << i); 1064 } else if (cmd_err) { 1065 /* in this case, retune response is needed */ 1066 ret = msdc_tune_response(dev, opcode); 1067 if (ret) 1068 break; 1069 } 1070 } 1071 1072 final_rise_delay = get_best_delay(host, rise_delay); 1073 if (final_rise_delay.maxlen >= 12 || 1074 (final_rise_delay.start == 0 && final_rise_delay.maxlen >= 4)) 1075 goto skip_fall; 1076 1077 setbits_le32(&host->base->msdc_iocon, MSDC_IOCON_DSPL); 1078 setbits_le32(&host->base->msdc_iocon, MSDC_IOCON_W_DSPL); 1079 1080 for (i = 0; i < PAD_DELAY_MAX; i++) { 1081 clrsetbits_le32(tune_reg, MSDC_PAD_TUNE_DATRRDLY_M, 1082 i << MSDC_PAD_TUNE_DATRRDLY_S); 1083 1084 ret = mmc_send_tuning(mmc, opcode, &cmd_err); 1085 if (!ret) { 1086 fall_delay |= (1 << i); 1087 } else if (cmd_err) { 1088 /* in this case, retune response is needed */ 1089 ret = msdc_tune_response(dev, opcode); 1090 if (ret) 1091 break; 1092 } 1093 } 1094 1095 final_fall_delay = get_best_delay(host, fall_delay); 1096 1097 skip_fall: 1098 final_maxlen = max(final_rise_delay.maxlen, final_fall_delay.maxlen); 1099 if (final_maxlen == final_rise_delay.maxlen) { 1100 clrbits_le32(&host->base->msdc_iocon, MSDC_IOCON_DSPL); 1101 clrbits_le32(&host->base->msdc_iocon, MSDC_IOCON_W_DSPL); 1102 clrsetbits_le32(tune_reg, MSDC_PAD_TUNE_DATRRDLY_M, 1103 final_rise_delay.final_phase << 1104 MSDC_PAD_TUNE_DATRRDLY_S); 1105 final_delay = final_rise_delay.final_phase; 1106 } else { 1107 setbits_le32(&host->base->msdc_iocon, MSDC_IOCON_DSPL); 1108 setbits_le32(&host->base->msdc_iocon, MSDC_IOCON_W_DSPL); 1109 clrsetbits_le32(tune_reg, MSDC_PAD_TUNE_DATRRDLY_M, 1110 final_fall_delay.final_phase << 1111 MSDC_PAD_TUNE_DATRRDLY_S); 1112 final_delay = final_fall_delay.final_phase; 1113 } 1114 1115 if (mmc->selected_mode == MMC_HS_200 || 1116 mmc->selected_mode == UHS_SDR104) 1117 clrsetbits_le32(tune_reg, MSDC_PAD_TUNE_DATWRDLY_M, 1118 host->hs200_write_int_delay << 1119 MSDC_PAD_TUNE_DATWRDLY_S); 1120 1121 dev_err(dev, "Final data pad delay: %x\n", final_delay); 1122 1123 return final_delay == 0xff ? -EIO : 0; 1124 } 1125 1126 static int msdc_execute_tuning(struct udevice *dev, uint opcode) 1127 { 1128 struct msdc_plat *plat = dev_get_platdata(dev); 1129 struct msdc_host *host = dev_get_priv(dev); 1130 struct mmc *mmc = &plat->mmc; 1131 int ret; 1132 1133 if (mmc->selected_mode == MMC_HS_400) { 1134 writel(host->hs400_ds_delay, &host->base->pad_ds_tune); 1135 /* for hs400 mode it must be set to 0 */ 1136 clrbits_le32(&host->base->patch_bit2, MSDC_PB2_CFGCRCSTS); 1137 host->hs400_mode = true; 1138 } 1139 1140 ret = msdc_tune_response(dev, opcode); 1141 if (ret == -EIO) { 1142 dev_err(dev, "Tune response fail!\n"); 1143 return ret; 1144 } 1145 1146 if (!host->hs400_mode) { 1147 ret = msdc_tune_data(dev, opcode); 1148 if (ret == -EIO) 1149 dev_err(dev, "Tune data fail!\n"); 1150 } 1151 1152 host->saved_tune_para.iocon = readl(&host->base->msdc_iocon); 1153 host->saved_tune_para.pad_tune = readl(&host->base->pad_tune); 1154 1155 return ret; 1156 } 1157 #endif 1158 1159 static void msdc_init_hw(struct msdc_host *host) 1160 { 1161 u32 val; 1162 void __iomem *tune_reg = &host->base->pad_tune; 1163 1164 if (host->dev_comp->pad_tune0) 1165 tune_reg = &host->base->pad_tune0; 1166 1167 /* Configure to MMC/SD mode, clock free running */ 1168 setbits_le32(&host->base->msdc_cfg, MSDC_CFG_MODE); 1169 1170 /* Use PIO mode */ 1171 setbits_le32(&host->base->msdc_cfg, MSDC_CFG_PIO); 1172 1173 /* Reset */ 1174 msdc_reset_hw(host); 1175 1176 /* Enable/disable hw card detection according to fdt option */ 1177 if (host->builtin_cd) 1178 clrsetbits_le32(&host->base->msdc_ps, 1179 MSDC_PS_CDDBCE_M, 1180 (DEFAULT_CD_DEBOUNCE << MSDC_PS_CDDBCE_S) | 1181 MSDC_PS_CDEN); 1182 else 1183 clrbits_le32(&host->base->msdc_ps, MSDC_PS_CDEN); 1184 1185 /* Clear all interrupts */ 1186 val = readl(&host->base->msdc_int); 1187 writel(val, &host->base->msdc_int); 1188 1189 /* Enable data & cmd interrupts */ 1190 writel(DATA_INTS_MASK | CMD_INTS_MASK, &host->base->msdc_inten); 1191 1192 writel(0, tune_reg); 1193 writel(0, &host->base->msdc_iocon); 1194 1195 if (host->r_smpl) 1196 setbits_le32(&host->base->msdc_iocon, MSDC_IOCON_RSPL); 1197 else 1198 clrbits_le32(&host->base->msdc_iocon, MSDC_IOCON_RSPL); 1199 1200 writel(0x403c0046, &host->base->patch_bit0); 1201 writel(0xffff4089, &host->base->patch_bit1); 1202 1203 if (host->dev_comp->stop_clk_fix) 1204 clrsetbits_le32(&host->base->patch_bit1, MSDC_PB1_STOP_DLY_M, 1205 3 << MSDC_PB1_STOP_DLY_S); 1206 1207 if (host->dev_comp->busy_check) 1208 clrbits_le32(&host->base->patch_bit1, (1 << 7)); 1209 1210 setbits_le32(&host->base->emmc50_cfg0, EMMC50_CFG_CFCSTS_SEL); 1211 1212 if (host->dev_comp->async_fifo) { 1213 clrsetbits_le32(&host->base->patch_bit2, MSDC_PB2_RESPWAIT_M, 1214 3 << MSDC_PB2_RESPWAIT_S); 1215 1216 if (host->dev_comp->enhance_rx) { 1217 setbits_le32(&host->base->sdc_adv_cfg0, 1218 SDC_RX_ENHANCE_EN); 1219 } else { 1220 clrsetbits_le32(&host->base->patch_bit2, 1221 MSDC_PB2_RESPSTSENSEL_M, 1222 2 << MSDC_PB2_RESPSTSENSEL_S); 1223 clrsetbits_le32(&host->base->patch_bit2, 1224 MSDC_PB2_CRCSTSENSEL_M, 1225 2 << MSDC_PB2_CRCSTSENSEL_S); 1226 } 1227 1228 /* use async fifo to avoid tune internal delay */ 1229 clrbits_le32(&host->base->patch_bit2, 1230 MSDC_PB2_CFGRESP); 1231 clrbits_le32(&host->base->patch_bit2, 1232 MSDC_PB2_CFGCRCSTS); 1233 } 1234 1235 if (host->dev_comp->data_tune) { 1236 setbits_le32(tune_reg, 1237 MSDC_PAD_TUNE_RD_SEL | MSDC_PAD_TUNE_CMD_SEL); 1238 clrsetbits_le32(&host->base->patch_bit0, 1239 MSDC_INT_DAT_LATCH_CK_SEL_M, 1240 host->latch_ck << 1241 MSDC_INT_DAT_LATCH_CK_SEL_S); 1242 } else { 1243 /* choose clock tune */ 1244 setbits_le32(tune_reg, MSDC_PAD_TUNE_RXDLYSEL); 1245 } 1246 1247 /* Configure to enable SDIO mode otherwise sdio cmd5 won't work */ 1248 setbits_le32(&host->base->sdc_cfg, SDC_CFG_SDIO); 1249 1250 /* disable detecting SDIO device interrupt function */ 1251 clrbits_le32(&host->base->sdc_cfg, SDC_CFG_SDIOIDE); 1252 1253 /* Configure to default data timeout */ 1254 clrsetbits_le32(&host->base->sdc_cfg, SDC_CFG_DTOC_M, 1255 3 << SDC_CFG_DTOC_S); 1256 1257 if (host->dev_comp->stop_clk_fix) { 1258 clrbits_le32(&host->base->sdc_fifo_cfg, 1259 SDC_FIFO_CFG_WRVALIDSEL); 1260 clrbits_le32(&host->base->sdc_fifo_cfg, 1261 SDC_FIFO_CFG_RDVALIDSEL); 1262 } 1263 1264 host->def_tune_para.iocon = readl(&host->base->msdc_iocon); 1265 host->def_tune_para.pad_tune = readl(&host->base->pad_tune); 1266 } 1267 1268 static void msdc_ungate_clock(struct msdc_host *host) 1269 { 1270 clk_enable(&host->src_clk); 1271 clk_enable(&host->h_clk); 1272 } 1273 1274 static int msdc_drv_probe(struct udevice *dev) 1275 { 1276 struct mmc_uclass_priv *upriv = dev_get_uclass_priv(dev); 1277 struct msdc_plat *plat = dev_get_platdata(dev); 1278 struct msdc_host *host = dev_get_priv(dev); 1279 struct mmc_config *cfg = &plat->cfg; 1280 1281 cfg->name = dev->name; 1282 1283 host->dev_comp = (struct msdc_compatible *)dev_get_driver_data(dev); 1284 1285 host->src_clk_freq = clk_get_rate(&host->src_clk); 1286 1287 if (host->dev_comp->clk_div_bits == 8) 1288 cfg->f_min = host->src_clk_freq / (4 * 255); 1289 else 1290 cfg->f_min = host->src_clk_freq / (4 * 4095); 1291 cfg->f_max = host->src_clk_freq / 2; 1292 1293 cfg->b_max = 1024; 1294 cfg->voltages = MMC_VDD_32_33 | MMC_VDD_33_34; 1295 1296 host->mmc = &plat->mmc; 1297 host->timeout_ns = 100000000; 1298 host->timeout_clks = 3 * 1048576; 1299 1300 #ifdef CONFIG_PINCTRL 1301 pinctrl_select_state(dev, "default"); 1302 #endif 1303 1304 msdc_ungate_clock(host); 1305 msdc_init_hw(host); 1306 1307 upriv->mmc = &plat->mmc; 1308 1309 return 0; 1310 } 1311 1312 static int msdc_ofdata_to_platdata(struct udevice *dev) 1313 { 1314 struct msdc_plat *plat = dev_get_platdata(dev); 1315 struct msdc_host *host = dev_get_priv(dev); 1316 struct mmc_config *cfg = &plat->cfg; 1317 int ret; 1318 1319 host->base = (void *)dev_read_addr(dev); 1320 if (!host->base) 1321 return -EINVAL; 1322 1323 ret = mmc_of_parse(dev, cfg); 1324 if (ret) 1325 return ret; 1326 1327 ret = clk_get_by_name(dev, "source", &host->src_clk); 1328 if (ret < 0) 1329 return ret; 1330 1331 ret = clk_get_by_name(dev, "hclk", &host->h_clk); 1332 if (ret < 0) 1333 return ret; 1334 1335 #if IS_ENABLED(DM_GPIO) 1336 gpio_request_by_name(dev, "wp-gpios", 0, &host->gpio_wp, GPIOD_IS_IN); 1337 gpio_request_by_name(dev, "cd-gpios", 0, &host->gpio_cd, GPIOD_IS_IN); 1338 #endif 1339 1340 host->hs400_ds_delay = dev_read_u32_default(dev, "hs400-ds-delay", 0); 1341 host->hs200_cmd_int_delay = 1342 dev_read_u32_default(dev, "cmd_int_delay", 0); 1343 host->hs200_write_int_delay = 1344 dev_read_u32_default(dev, "write_int_delay", 0); 1345 host->latch_ck = dev_read_u32_default(dev, "latch-ck", 0); 1346 host->r_smpl = dev_read_u32_default(dev, "r_smpl", 0); 1347 host->builtin_cd = dev_read_u32_default(dev, "builtin-cd", 0); 1348 1349 return 0; 1350 } 1351 1352 static int msdc_drv_bind(struct udevice *dev) 1353 { 1354 struct msdc_plat *plat = dev_get_platdata(dev); 1355 1356 return mmc_bind(dev, &plat->mmc, &plat->cfg); 1357 } 1358 1359 static const struct dm_mmc_ops msdc_ops = { 1360 .send_cmd = msdc_ops_send_cmd, 1361 .set_ios = msdc_ops_set_ios, 1362 .get_cd = msdc_ops_get_cd, 1363 .get_wp = msdc_ops_get_wp, 1364 #ifdef MMC_SUPPORTS_TUNING 1365 .execute_tuning = msdc_execute_tuning, 1366 #endif 1367 }; 1368 1369 static const struct msdc_compatible mt7623_compat = { 1370 .clk_div_bits = 12, 1371 .pad_tune0 = true, 1372 .async_fifo = true, 1373 .data_tune = true, 1374 .busy_check = false, 1375 .stop_clk_fix = false, 1376 .enhance_rx = false 1377 }; 1378 1379 static const struct udevice_id msdc_ids[] = { 1380 { .compatible = "mediatek,mt7623-mmc", .data = (ulong)&mt7623_compat }, 1381 {} 1382 }; 1383 1384 U_BOOT_DRIVER(mtk_sd_drv) = { 1385 .name = "mtk_sd", 1386 .id = UCLASS_MMC, 1387 .of_match = msdc_ids, 1388 .ofdata_to_platdata = msdc_ofdata_to_platdata, 1389 .bind = msdc_drv_bind, 1390 .probe = msdc_drv_probe, 1391 .ops = &msdc_ops, 1392 .platdata_auto_alloc_size = sizeof(struct msdc_plat), 1393 .priv_auto_alloc_size = sizeof(struct msdc_host), 1394 }; 1395