1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Copyright 2008, Freescale Semiconductor, Inc 4 * Andy Fleming 5 * 6 * Based vaguely on the Linux code 7 */ 8 9 #include <config.h> 10 #include <common.h> 11 #include <command.h> 12 #include <dm.h> 13 #include <dm/device-internal.h> 14 #include <errno.h> 15 #include <mmc.h> 16 #include <part.h> 17 #include <power/regulator.h> 18 #include <malloc.h> 19 #include <memalign.h> 20 #include <linux/list.h> 21 #include <div64.h> 22 #include "mmc_private.h" 23 24 static int mmc_set_signal_voltage(struct mmc *mmc, uint signal_voltage); 25 static int mmc_power_cycle(struct mmc *mmc); 26 #if !CONFIG_IS_ENABLED(MMC_TINY) 27 static int mmc_select_mode_and_width(struct mmc *mmc, uint card_caps); 28 #endif 29 30 #if !CONFIG_IS_ENABLED(DM_MMC) 31 32 #if CONFIG_IS_ENABLED(MMC_UHS_SUPPORT) 33 static int mmc_wait_dat0(struct mmc *mmc, int state, int timeout) 34 { 35 return -ENOSYS; 36 } 37 #endif 38 39 __weak int board_mmc_getwp(struct mmc *mmc) 40 { 41 return -1; 42 } 43 44 int mmc_getwp(struct mmc *mmc) 45 { 46 int wp; 47 48 wp = board_mmc_getwp(mmc); 49 50 if (wp < 0) { 51 if (mmc->cfg->ops->getwp) 52 wp = mmc->cfg->ops->getwp(mmc); 53 else 54 wp = 0; 55 } 56 57 return wp; 58 } 59 60 __weak int board_mmc_getcd(struct mmc *mmc) 61 { 62 return -1; 63 } 64 #endif 65 66 #ifdef CONFIG_MMC_TRACE 67 void mmmc_trace_before_send(struct mmc *mmc, struct mmc_cmd *cmd) 68 { 69 printf("CMD_SEND:%d\n", cmd->cmdidx); 70 printf("\t\tARG\t\t\t 0x%08X\n", cmd->cmdarg); 71 } 72 73 void mmmc_trace_after_send(struct mmc *mmc, struct mmc_cmd *cmd, int ret) 74 { 75 int i; 76 u8 *ptr; 77 78 if (ret) { 79 printf("\t\tRET\t\t\t %d\n", ret); 80 } else { 81 switch (cmd->resp_type) { 82 case MMC_RSP_NONE: 83 printf("\t\tMMC_RSP_NONE\n"); 84 break; 85 case MMC_RSP_R1: 86 printf("\t\tMMC_RSP_R1,5,6,7 \t 0x%08X \n", 87 cmd->response[0]); 88 break; 89 case MMC_RSP_R1b: 90 printf("\t\tMMC_RSP_R1b\t\t 0x%08X \n", 91 cmd->response[0]); 92 break; 93 case MMC_RSP_R2: 94 printf("\t\tMMC_RSP_R2\t\t 0x%08X \n", 95 cmd->response[0]); 96 printf("\t\t \t\t 0x%08X \n", 97 cmd->response[1]); 98 printf("\t\t \t\t 0x%08X \n", 99 cmd->response[2]); 100 printf("\t\t \t\t 0x%08X \n", 101 cmd->response[3]); 102 printf("\n"); 103 printf("\t\t\t\t\tDUMPING DATA\n"); 104 for (i = 0; i < 4; i++) { 105 int j; 106 printf("\t\t\t\t\t%03d - ", i*4); 107 ptr = (u8 *)&cmd->response[i]; 108 ptr += 3; 109 for (j = 0; j < 4; j++) 110 printf("%02X ", *ptr--); 111 printf("\n"); 112 } 113 break; 114 case MMC_RSP_R3: 115 printf("\t\tMMC_RSP_R3,4\t\t 0x%08X \n", 116 cmd->response[0]); 117 break; 118 default: 119 printf("\t\tERROR MMC rsp not supported\n"); 120 break; 121 } 122 } 123 } 124 125 void mmc_trace_state(struct mmc *mmc, struct mmc_cmd *cmd) 126 { 127 int status; 128 129 status = (cmd->response[0] & MMC_STATUS_CURR_STATE) >> 9; 130 printf("CURR STATE:%d\n", status); 131 } 132 #endif 133 134 #if CONFIG_IS_ENABLED(MMC_VERBOSE) || defined(DEBUG) 135 const char *mmc_mode_name(enum bus_mode mode) 136 { 137 static const char *const names[] = { 138 [MMC_LEGACY] = "MMC legacy", 139 [SD_LEGACY] = "SD Legacy", 140 [MMC_HS] = "MMC High Speed (26MHz)", 141 [SD_HS] = "SD High Speed (50MHz)", 142 [UHS_SDR12] = "UHS SDR12 (25MHz)", 143 [UHS_SDR25] = "UHS SDR25 (50MHz)", 144 [UHS_SDR50] = "UHS SDR50 (100MHz)", 145 [UHS_SDR104] = "UHS SDR104 (208MHz)", 146 [UHS_DDR50] = "UHS DDR50 (50MHz)", 147 [MMC_HS_52] = "MMC High Speed (52MHz)", 148 [MMC_DDR_52] = "MMC DDR52 (52MHz)", 149 [MMC_HS_200] = "HS200 (200MHz)", 150 }; 151 152 if (mode >= MMC_MODES_END) 153 return "Unknown mode"; 154 else 155 return names[mode]; 156 } 157 #endif 158 159 static uint mmc_mode2freq(struct mmc *mmc, enum bus_mode mode) 160 { 161 static const int freqs[] = { 162 [MMC_LEGACY] = 25000000, 163 [SD_LEGACY] = 25000000, 164 [MMC_HS] = 26000000, 165 [SD_HS] = 50000000, 166 [MMC_HS_52] = 52000000, 167 [MMC_DDR_52] = 52000000, 168 [UHS_SDR12] = 25000000, 169 [UHS_SDR25] = 50000000, 170 [UHS_SDR50] = 100000000, 171 [UHS_DDR50] = 50000000, 172 [UHS_SDR104] = 208000000, 173 [MMC_HS_200] = 200000000, 174 }; 175 176 if (mode == MMC_LEGACY) 177 return mmc->legacy_speed; 178 else if (mode >= MMC_MODES_END) 179 return 0; 180 else 181 return freqs[mode]; 182 } 183 184 static int mmc_select_mode(struct mmc *mmc, enum bus_mode mode) 185 { 186 mmc->selected_mode = mode; 187 mmc->tran_speed = mmc_mode2freq(mmc, mode); 188 mmc->ddr_mode = mmc_is_mode_ddr(mode); 189 pr_debug("selecting mode %s (freq : %d MHz)\n", mmc_mode_name(mode), 190 mmc->tran_speed / 1000000); 191 return 0; 192 } 193 194 #if !CONFIG_IS_ENABLED(DM_MMC) 195 int mmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data) 196 { 197 int ret; 198 199 mmmc_trace_before_send(mmc, cmd); 200 ret = mmc->cfg->ops->send_cmd(mmc, cmd, data); 201 mmmc_trace_after_send(mmc, cmd, ret); 202 203 return ret; 204 } 205 #endif 206 207 int mmc_send_status(struct mmc *mmc, int timeout) 208 { 209 struct mmc_cmd cmd; 210 int err, retries = 5; 211 212 cmd.cmdidx = MMC_CMD_SEND_STATUS; 213 cmd.resp_type = MMC_RSP_R1; 214 if (!mmc_host_is_spi(mmc)) 215 cmd.cmdarg = mmc->rca << 16; 216 217 while (1) { 218 err = mmc_send_cmd(mmc, &cmd, NULL); 219 if (!err) { 220 if ((cmd.response[0] & MMC_STATUS_RDY_FOR_DATA) && 221 (cmd.response[0] & MMC_STATUS_CURR_STATE) != 222 MMC_STATE_PRG) 223 break; 224 225 if (cmd.response[0] & MMC_STATUS_MASK) { 226 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 227 pr_err("Status Error: 0x%08X\n", 228 cmd.response[0]); 229 #endif 230 return -ECOMM; 231 } 232 } else if (--retries < 0) 233 return err; 234 235 if (timeout-- <= 0) 236 break; 237 238 udelay(1000); 239 } 240 241 mmc_trace_state(mmc, &cmd); 242 if (timeout <= 0) { 243 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 244 pr_err("Timeout waiting card ready\n"); 245 #endif 246 return -ETIMEDOUT; 247 } 248 249 return 0; 250 } 251 252 int mmc_set_blocklen(struct mmc *mmc, int len) 253 { 254 struct mmc_cmd cmd; 255 int err; 256 257 if (mmc->ddr_mode) 258 return 0; 259 260 cmd.cmdidx = MMC_CMD_SET_BLOCKLEN; 261 cmd.resp_type = MMC_RSP_R1; 262 cmd.cmdarg = len; 263 264 err = mmc_send_cmd(mmc, &cmd, NULL); 265 266 #ifdef CONFIG_MMC_QUIRKS 267 if (err && (mmc->quirks & MMC_QUIRK_RETRY_SET_BLOCKLEN)) { 268 int retries = 4; 269 /* 270 * It has been seen that SET_BLOCKLEN may fail on the first 271 * attempt, let's try a few more time 272 */ 273 do { 274 err = mmc_send_cmd(mmc, &cmd, NULL); 275 if (!err) 276 break; 277 } while (retries--); 278 } 279 #endif 280 281 return err; 282 } 283 284 #ifdef MMC_SUPPORTS_TUNING 285 static const u8 tuning_blk_pattern_4bit[] = { 286 0xff, 0x0f, 0xff, 0x00, 0xff, 0xcc, 0xc3, 0xcc, 287 0xc3, 0x3c, 0xcc, 0xff, 0xfe, 0xff, 0xfe, 0xef, 288 0xff, 0xdf, 0xff, 0xdd, 0xff, 0xfb, 0xff, 0xfb, 289 0xbf, 0xff, 0x7f, 0xff, 0x77, 0xf7, 0xbd, 0xef, 290 0xff, 0xf0, 0xff, 0xf0, 0x0f, 0xfc, 0xcc, 0x3c, 291 0xcc, 0x33, 0xcc, 0xcf, 0xff, 0xef, 0xff, 0xee, 292 0xff, 0xfd, 0xff, 0xfd, 0xdf, 0xff, 0xbf, 0xff, 293 0xbb, 0xff, 0xf7, 0xff, 0xf7, 0x7f, 0x7b, 0xde, 294 }; 295 296 static const u8 tuning_blk_pattern_8bit[] = { 297 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 298 0xff, 0xff, 0xcc, 0xcc, 0xcc, 0x33, 0xcc, 0xcc, 299 0xcc, 0x33, 0x33, 0xcc, 0xcc, 0xcc, 0xff, 0xff, 300 0xff, 0xee, 0xff, 0xff, 0xff, 0xee, 0xee, 0xff, 301 0xff, 0xff, 0xdd, 0xff, 0xff, 0xff, 0xdd, 0xdd, 302 0xff, 0xff, 0xff, 0xbb, 0xff, 0xff, 0xff, 0xbb, 303 0xbb, 0xff, 0xff, 0xff, 0x77, 0xff, 0xff, 0xff, 304 0x77, 0x77, 0xff, 0x77, 0xbb, 0xdd, 0xee, 0xff, 305 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 306 0x00, 0xff, 0xff, 0xcc, 0xcc, 0xcc, 0x33, 0xcc, 307 0xcc, 0xcc, 0x33, 0x33, 0xcc, 0xcc, 0xcc, 0xff, 308 0xff, 0xff, 0xee, 0xff, 0xff, 0xff, 0xee, 0xee, 309 0xff, 0xff, 0xff, 0xdd, 0xff, 0xff, 0xff, 0xdd, 310 0xdd, 0xff, 0xff, 0xff, 0xbb, 0xff, 0xff, 0xff, 311 0xbb, 0xbb, 0xff, 0xff, 0xff, 0x77, 0xff, 0xff, 312 0xff, 0x77, 0x77, 0xff, 0x77, 0xbb, 0xdd, 0xee, 313 }; 314 315 int mmc_send_tuning(struct mmc *mmc, u32 opcode, int *cmd_error) 316 { 317 struct mmc_cmd cmd; 318 struct mmc_data data; 319 const u8 *tuning_block_pattern; 320 int size, err; 321 322 if (mmc->bus_width == 8) { 323 tuning_block_pattern = tuning_blk_pattern_8bit; 324 size = sizeof(tuning_blk_pattern_8bit); 325 } else if (mmc->bus_width == 4) { 326 tuning_block_pattern = tuning_blk_pattern_4bit; 327 size = sizeof(tuning_blk_pattern_4bit); 328 } else { 329 return -EINVAL; 330 } 331 332 ALLOC_CACHE_ALIGN_BUFFER(u8, data_buf, size); 333 334 cmd.cmdidx = opcode; 335 cmd.cmdarg = 0; 336 cmd.resp_type = MMC_RSP_R1; 337 338 data.dest = (void *)data_buf; 339 data.blocks = 1; 340 data.blocksize = size; 341 data.flags = MMC_DATA_READ; 342 343 err = mmc_send_cmd(mmc, &cmd, &data); 344 if (err) 345 return err; 346 347 if (memcmp(data_buf, tuning_block_pattern, size)) 348 return -EIO; 349 350 return 0; 351 } 352 #endif 353 354 static int mmc_read_blocks(struct mmc *mmc, void *dst, lbaint_t start, 355 lbaint_t blkcnt) 356 { 357 struct mmc_cmd cmd; 358 struct mmc_data data; 359 360 if (blkcnt > 1) 361 cmd.cmdidx = MMC_CMD_READ_MULTIPLE_BLOCK; 362 else 363 cmd.cmdidx = MMC_CMD_READ_SINGLE_BLOCK; 364 365 if (mmc->high_capacity) 366 cmd.cmdarg = start; 367 else 368 cmd.cmdarg = start * mmc->read_bl_len; 369 370 cmd.resp_type = MMC_RSP_R1; 371 372 data.dest = dst; 373 data.blocks = blkcnt; 374 data.blocksize = mmc->read_bl_len; 375 data.flags = MMC_DATA_READ; 376 377 if (mmc_send_cmd(mmc, &cmd, &data)) 378 return 0; 379 380 if (blkcnt > 1) { 381 cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION; 382 cmd.cmdarg = 0; 383 cmd.resp_type = MMC_RSP_R1b; 384 if (mmc_send_cmd(mmc, &cmd, NULL)) { 385 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 386 pr_err("mmc fail to send stop cmd\n"); 387 #endif 388 return 0; 389 } 390 } 391 392 return blkcnt; 393 } 394 395 #if CONFIG_IS_ENABLED(BLK) 396 ulong mmc_bread(struct udevice *dev, lbaint_t start, lbaint_t blkcnt, void *dst) 397 #else 398 ulong mmc_bread(struct blk_desc *block_dev, lbaint_t start, lbaint_t blkcnt, 399 void *dst) 400 #endif 401 { 402 #if CONFIG_IS_ENABLED(BLK) 403 struct blk_desc *block_dev = dev_get_uclass_platdata(dev); 404 #endif 405 int dev_num = block_dev->devnum; 406 int err; 407 lbaint_t cur, blocks_todo = blkcnt; 408 409 if (blkcnt == 0) 410 return 0; 411 412 struct mmc *mmc = find_mmc_device(dev_num); 413 if (!mmc) 414 return 0; 415 416 if (CONFIG_IS_ENABLED(MMC_TINY)) 417 err = mmc_switch_part(mmc, block_dev->hwpart); 418 else 419 err = blk_dselect_hwpart(block_dev, block_dev->hwpart); 420 421 if (err < 0) 422 return 0; 423 424 if ((start + blkcnt) > block_dev->lba) { 425 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 426 pr_err("MMC: block number 0x" LBAF " exceeds max(0x" LBAF ")\n", 427 start + blkcnt, block_dev->lba); 428 #endif 429 return 0; 430 } 431 432 if (mmc_set_blocklen(mmc, mmc->read_bl_len)) { 433 pr_debug("%s: Failed to set blocklen\n", __func__); 434 return 0; 435 } 436 437 do { 438 cur = (blocks_todo > mmc->cfg->b_max) ? 439 mmc->cfg->b_max : blocks_todo; 440 if (mmc_read_blocks(mmc, dst, start, cur) != cur) { 441 pr_debug("%s: Failed to read blocks\n", __func__); 442 return 0; 443 } 444 blocks_todo -= cur; 445 start += cur; 446 dst += cur * mmc->read_bl_len; 447 } while (blocks_todo > 0); 448 449 return blkcnt; 450 } 451 452 static int mmc_go_idle(struct mmc *mmc) 453 { 454 struct mmc_cmd cmd; 455 int err; 456 457 udelay(1000); 458 459 cmd.cmdidx = MMC_CMD_GO_IDLE_STATE; 460 cmd.cmdarg = 0; 461 cmd.resp_type = MMC_RSP_NONE; 462 463 err = mmc_send_cmd(mmc, &cmd, NULL); 464 465 if (err) 466 return err; 467 468 udelay(2000); 469 470 return 0; 471 } 472 473 #if CONFIG_IS_ENABLED(MMC_UHS_SUPPORT) 474 static int mmc_switch_voltage(struct mmc *mmc, int signal_voltage) 475 { 476 struct mmc_cmd cmd; 477 int err = 0; 478 479 /* 480 * Send CMD11 only if the request is to switch the card to 481 * 1.8V signalling. 482 */ 483 if (signal_voltage == MMC_SIGNAL_VOLTAGE_330) 484 return mmc_set_signal_voltage(mmc, signal_voltage); 485 486 cmd.cmdidx = SD_CMD_SWITCH_UHS18V; 487 cmd.cmdarg = 0; 488 cmd.resp_type = MMC_RSP_R1; 489 490 err = mmc_send_cmd(mmc, &cmd, NULL); 491 if (err) 492 return err; 493 494 if (!mmc_host_is_spi(mmc) && (cmd.response[0] & MMC_STATUS_ERROR)) 495 return -EIO; 496 497 /* 498 * The card should drive cmd and dat[0:3] low immediately 499 * after the response of cmd11, but wait 100 us to be sure 500 */ 501 err = mmc_wait_dat0(mmc, 0, 100); 502 if (err == -ENOSYS) 503 udelay(100); 504 else if (err) 505 return -ETIMEDOUT; 506 507 /* 508 * During a signal voltage level switch, the clock must be gated 509 * for 5 ms according to the SD spec 510 */ 511 mmc_set_clock(mmc, mmc->clock, MMC_CLK_DISABLE); 512 513 err = mmc_set_signal_voltage(mmc, signal_voltage); 514 if (err) 515 return err; 516 517 /* Keep clock gated for at least 10 ms, though spec only says 5 ms */ 518 mdelay(10); 519 mmc_set_clock(mmc, mmc->clock, MMC_CLK_ENABLE); 520 521 /* 522 * Failure to switch is indicated by the card holding 523 * dat[0:3] low. Wait for at least 1 ms according to spec 524 */ 525 err = mmc_wait_dat0(mmc, 1, 1000); 526 if (err == -ENOSYS) 527 udelay(1000); 528 else if (err) 529 return -ETIMEDOUT; 530 531 return 0; 532 } 533 #endif 534 535 static int sd_send_op_cond(struct mmc *mmc, bool uhs_en) 536 { 537 int timeout = 1000; 538 int err; 539 struct mmc_cmd cmd; 540 541 while (1) { 542 cmd.cmdidx = MMC_CMD_APP_CMD; 543 cmd.resp_type = MMC_RSP_R1; 544 cmd.cmdarg = 0; 545 546 err = mmc_send_cmd(mmc, &cmd, NULL); 547 548 if (err) 549 return err; 550 551 cmd.cmdidx = SD_CMD_APP_SEND_OP_COND; 552 cmd.resp_type = MMC_RSP_R3; 553 554 /* 555 * Most cards do not answer if some reserved bits 556 * in the ocr are set. However, Some controller 557 * can set bit 7 (reserved for low voltages), but 558 * how to manage low voltages SD card is not yet 559 * specified. 560 */ 561 cmd.cmdarg = mmc_host_is_spi(mmc) ? 0 : 562 (mmc->cfg->voltages & 0xff8000); 563 564 if (mmc->version == SD_VERSION_2) 565 cmd.cmdarg |= OCR_HCS; 566 567 if (uhs_en) 568 cmd.cmdarg |= OCR_S18R; 569 570 err = mmc_send_cmd(mmc, &cmd, NULL); 571 572 if (err) 573 return err; 574 575 if (cmd.response[0] & OCR_BUSY) 576 break; 577 578 if (timeout-- <= 0) 579 return -EOPNOTSUPP; 580 581 udelay(1000); 582 } 583 584 if (mmc->version != SD_VERSION_2) 585 mmc->version = SD_VERSION_1_0; 586 587 if (mmc_host_is_spi(mmc)) { /* read OCR for spi */ 588 cmd.cmdidx = MMC_CMD_SPI_READ_OCR; 589 cmd.resp_type = MMC_RSP_R3; 590 cmd.cmdarg = 0; 591 592 err = mmc_send_cmd(mmc, &cmd, NULL); 593 594 if (err) 595 return err; 596 } 597 598 mmc->ocr = cmd.response[0]; 599 600 #if CONFIG_IS_ENABLED(MMC_UHS_SUPPORT) 601 if (uhs_en && !(mmc_host_is_spi(mmc)) && (cmd.response[0] & 0x41000000) 602 == 0x41000000) { 603 err = mmc_switch_voltage(mmc, MMC_SIGNAL_VOLTAGE_180); 604 if (err) 605 return err; 606 } 607 #endif 608 609 mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS); 610 mmc->rca = 0; 611 612 return 0; 613 } 614 615 static int mmc_send_op_cond_iter(struct mmc *mmc, int use_arg) 616 { 617 struct mmc_cmd cmd; 618 int err; 619 620 cmd.cmdidx = MMC_CMD_SEND_OP_COND; 621 cmd.resp_type = MMC_RSP_R3; 622 cmd.cmdarg = 0; 623 if (use_arg && !mmc_host_is_spi(mmc)) 624 cmd.cmdarg = OCR_HCS | 625 (mmc->cfg->voltages & 626 (mmc->ocr & OCR_VOLTAGE_MASK)) | 627 (mmc->ocr & OCR_ACCESS_MODE); 628 629 err = mmc_send_cmd(mmc, &cmd, NULL); 630 if (err) 631 return err; 632 mmc->ocr = cmd.response[0]; 633 return 0; 634 } 635 636 static int mmc_send_op_cond(struct mmc *mmc) 637 { 638 int err, i; 639 640 /* Some cards seem to need this */ 641 mmc_go_idle(mmc); 642 643 /* Asking to the card its capabilities */ 644 for (i = 0; i < 2; i++) { 645 err = mmc_send_op_cond_iter(mmc, i != 0); 646 if (err) 647 return err; 648 649 /* exit if not busy (flag seems to be inverted) */ 650 if (mmc->ocr & OCR_BUSY) 651 break; 652 } 653 mmc->op_cond_pending = 1; 654 return 0; 655 } 656 657 static int mmc_complete_op_cond(struct mmc *mmc) 658 { 659 struct mmc_cmd cmd; 660 int timeout = 1000; 661 ulong start; 662 int err; 663 664 mmc->op_cond_pending = 0; 665 if (!(mmc->ocr & OCR_BUSY)) { 666 /* Some cards seem to need this */ 667 mmc_go_idle(mmc); 668 669 start = get_timer(0); 670 while (1) { 671 err = mmc_send_op_cond_iter(mmc, 1); 672 if (err) 673 return err; 674 if (mmc->ocr & OCR_BUSY) 675 break; 676 if (get_timer(start) > timeout) 677 return -EOPNOTSUPP; 678 udelay(100); 679 } 680 } 681 682 if (mmc_host_is_spi(mmc)) { /* read OCR for spi */ 683 cmd.cmdidx = MMC_CMD_SPI_READ_OCR; 684 cmd.resp_type = MMC_RSP_R3; 685 cmd.cmdarg = 0; 686 687 err = mmc_send_cmd(mmc, &cmd, NULL); 688 689 if (err) 690 return err; 691 692 mmc->ocr = cmd.response[0]; 693 } 694 695 mmc->version = MMC_VERSION_UNKNOWN; 696 697 mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS); 698 mmc->rca = 1; 699 700 return 0; 701 } 702 703 704 static int mmc_send_ext_csd(struct mmc *mmc, u8 *ext_csd) 705 { 706 struct mmc_cmd cmd; 707 struct mmc_data data; 708 int err; 709 710 /* Get the Card Status Register */ 711 cmd.cmdidx = MMC_CMD_SEND_EXT_CSD; 712 cmd.resp_type = MMC_RSP_R1; 713 cmd.cmdarg = 0; 714 715 data.dest = (char *)ext_csd; 716 data.blocks = 1; 717 data.blocksize = MMC_MAX_BLOCK_LEN; 718 data.flags = MMC_DATA_READ; 719 720 err = mmc_send_cmd(mmc, &cmd, &data); 721 722 return err; 723 } 724 725 int mmc_switch(struct mmc *mmc, u8 set, u8 index, u8 value) 726 { 727 struct mmc_cmd cmd; 728 int timeout = 1000; 729 int retries = 3; 730 int ret; 731 732 cmd.cmdidx = MMC_CMD_SWITCH; 733 cmd.resp_type = MMC_RSP_R1b; 734 cmd.cmdarg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) | 735 (index << 16) | 736 (value << 8); 737 738 while (retries > 0) { 739 ret = mmc_send_cmd(mmc, &cmd, NULL); 740 741 /* Waiting for the ready status */ 742 if (!ret) { 743 ret = mmc_send_status(mmc, timeout); 744 return ret; 745 } 746 747 retries--; 748 } 749 750 return ret; 751 752 } 753 754 #if !CONFIG_IS_ENABLED(MMC_TINY) 755 static int mmc_set_card_speed(struct mmc *mmc, enum bus_mode mode) 756 { 757 int err; 758 int speed_bits; 759 760 ALLOC_CACHE_ALIGN_BUFFER(u8, test_csd, MMC_MAX_BLOCK_LEN); 761 762 switch (mode) { 763 case MMC_HS: 764 case MMC_HS_52: 765 case MMC_DDR_52: 766 speed_bits = EXT_CSD_TIMING_HS; 767 break; 768 #if CONFIG_IS_ENABLED(MMC_HS200_SUPPORT) 769 case MMC_HS_200: 770 speed_bits = EXT_CSD_TIMING_HS200; 771 break; 772 #endif 773 case MMC_LEGACY: 774 speed_bits = EXT_CSD_TIMING_LEGACY; 775 break; 776 default: 777 return -EINVAL; 778 } 779 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING, 780 speed_bits); 781 if (err) 782 return err; 783 784 if ((mode == MMC_HS) || (mode == MMC_HS_52)) { 785 /* Now check to see that it worked */ 786 err = mmc_send_ext_csd(mmc, test_csd); 787 if (err) 788 return err; 789 790 /* No high-speed support */ 791 if (!test_csd[EXT_CSD_HS_TIMING]) 792 return -ENOTSUPP; 793 } 794 795 return 0; 796 } 797 798 static int mmc_get_capabilities(struct mmc *mmc) 799 { 800 u8 *ext_csd = mmc->ext_csd; 801 char cardtype; 802 803 mmc->card_caps = MMC_MODE_1BIT | MMC_CAP(MMC_LEGACY); 804 805 if (mmc_host_is_spi(mmc)) 806 return 0; 807 808 /* Only version 4 supports high-speed */ 809 if (mmc->version < MMC_VERSION_4) 810 return 0; 811 812 if (!ext_csd) { 813 pr_err("No ext_csd found!\n"); /* this should enver happen */ 814 return -ENOTSUPP; 815 } 816 817 mmc->card_caps |= MMC_MODE_4BIT | MMC_MODE_8BIT; 818 819 cardtype = ext_csd[EXT_CSD_CARD_TYPE] & 0x3f; 820 mmc->cardtype = cardtype; 821 822 #if CONFIG_IS_ENABLED(MMC_HS200_SUPPORT) 823 if (cardtype & (EXT_CSD_CARD_TYPE_HS200_1_2V | 824 EXT_CSD_CARD_TYPE_HS200_1_8V)) { 825 mmc->card_caps |= MMC_MODE_HS200; 826 } 827 #endif 828 if (cardtype & EXT_CSD_CARD_TYPE_52) { 829 if (cardtype & EXT_CSD_CARD_TYPE_DDR_52) 830 mmc->card_caps |= MMC_MODE_DDR_52MHz; 831 mmc->card_caps |= MMC_MODE_HS_52MHz; 832 } 833 if (cardtype & EXT_CSD_CARD_TYPE_26) 834 mmc->card_caps |= MMC_MODE_HS; 835 836 return 0; 837 } 838 #endif 839 840 static int mmc_set_capacity(struct mmc *mmc, int part_num) 841 { 842 switch (part_num) { 843 case 0: 844 mmc->capacity = mmc->capacity_user; 845 break; 846 case 1: 847 case 2: 848 mmc->capacity = mmc->capacity_boot; 849 break; 850 case 3: 851 mmc->capacity = mmc->capacity_rpmb; 852 break; 853 case 4: 854 case 5: 855 case 6: 856 case 7: 857 mmc->capacity = mmc->capacity_gp[part_num - 4]; 858 break; 859 default: 860 return -1; 861 } 862 863 mmc_get_blk_desc(mmc)->lba = lldiv(mmc->capacity, mmc->read_bl_len); 864 865 return 0; 866 } 867 868 #if CONFIG_IS_ENABLED(MMC_HS200_SUPPORT) 869 static int mmc_boot_part_access_chk(struct mmc *mmc, unsigned int part_num) 870 { 871 int forbidden = 0; 872 bool change = false; 873 874 if (part_num & PART_ACCESS_MASK) 875 forbidden = MMC_CAP(MMC_HS_200); 876 877 if (MMC_CAP(mmc->selected_mode) & forbidden) { 878 pr_debug("selected mode (%s) is forbidden for part %d\n", 879 mmc_mode_name(mmc->selected_mode), part_num); 880 change = true; 881 } else if (mmc->selected_mode != mmc->best_mode) { 882 pr_debug("selected mode is not optimal\n"); 883 change = true; 884 } 885 886 if (change) 887 return mmc_select_mode_and_width(mmc, 888 mmc->card_caps & ~forbidden); 889 890 return 0; 891 } 892 #else 893 static inline int mmc_boot_part_access_chk(struct mmc *mmc, 894 unsigned int part_num) 895 { 896 return 0; 897 } 898 #endif 899 900 int mmc_switch_part(struct mmc *mmc, unsigned int part_num) 901 { 902 int ret; 903 904 ret = mmc_boot_part_access_chk(mmc, part_num); 905 if (ret) 906 return ret; 907 908 ret = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONF, 909 (mmc->part_config & ~PART_ACCESS_MASK) 910 | (part_num & PART_ACCESS_MASK)); 911 912 /* 913 * Set the capacity if the switch succeeded or was intended 914 * to return to representing the raw device. 915 */ 916 if ((ret == 0) || ((ret == -ENODEV) && (part_num == 0))) { 917 ret = mmc_set_capacity(mmc, part_num); 918 mmc_get_blk_desc(mmc)->hwpart = part_num; 919 } 920 921 return ret; 922 } 923 924 #if CONFIG_IS_ENABLED(MMC_HW_PARTITIONING) 925 int mmc_hwpart_config(struct mmc *mmc, 926 const struct mmc_hwpart_conf *conf, 927 enum mmc_hwpart_conf_mode mode) 928 { 929 u8 part_attrs = 0; 930 u32 enh_size_mult; 931 u32 enh_start_addr; 932 u32 gp_size_mult[4]; 933 u32 max_enh_size_mult; 934 u32 tot_enh_size_mult = 0; 935 u8 wr_rel_set; 936 int i, pidx, err; 937 ALLOC_CACHE_ALIGN_BUFFER(u8, ext_csd, MMC_MAX_BLOCK_LEN); 938 939 if (mode < MMC_HWPART_CONF_CHECK || mode > MMC_HWPART_CONF_COMPLETE) 940 return -EINVAL; 941 942 if (IS_SD(mmc) || (mmc->version < MMC_VERSION_4_41)) { 943 pr_err("eMMC >= 4.4 required for enhanced user data area\n"); 944 return -EMEDIUMTYPE; 945 } 946 947 if (!(mmc->part_support & PART_SUPPORT)) { 948 pr_err("Card does not support partitioning\n"); 949 return -EMEDIUMTYPE; 950 } 951 952 if (!mmc->hc_wp_grp_size) { 953 pr_err("Card does not define HC WP group size\n"); 954 return -EMEDIUMTYPE; 955 } 956 957 /* check partition alignment and total enhanced size */ 958 if (conf->user.enh_size) { 959 if (conf->user.enh_size % mmc->hc_wp_grp_size || 960 conf->user.enh_start % mmc->hc_wp_grp_size) { 961 pr_err("User data enhanced area not HC WP group " 962 "size aligned\n"); 963 return -EINVAL; 964 } 965 part_attrs |= EXT_CSD_ENH_USR; 966 enh_size_mult = conf->user.enh_size / mmc->hc_wp_grp_size; 967 if (mmc->high_capacity) { 968 enh_start_addr = conf->user.enh_start; 969 } else { 970 enh_start_addr = (conf->user.enh_start << 9); 971 } 972 } else { 973 enh_size_mult = 0; 974 enh_start_addr = 0; 975 } 976 tot_enh_size_mult += enh_size_mult; 977 978 for (pidx = 0; pidx < 4; pidx++) { 979 if (conf->gp_part[pidx].size % mmc->hc_wp_grp_size) { 980 pr_err("GP%i partition not HC WP group size " 981 "aligned\n", pidx+1); 982 return -EINVAL; 983 } 984 gp_size_mult[pidx] = conf->gp_part[pidx].size / mmc->hc_wp_grp_size; 985 if (conf->gp_part[pidx].size && conf->gp_part[pidx].enhanced) { 986 part_attrs |= EXT_CSD_ENH_GP(pidx); 987 tot_enh_size_mult += gp_size_mult[pidx]; 988 } 989 } 990 991 if (part_attrs && ! (mmc->part_support & ENHNCD_SUPPORT)) { 992 pr_err("Card does not support enhanced attribute\n"); 993 return -EMEDIUMTYPE; 994 } 995 996 err = mmc_send_ext_csd(mmc, ext_csd); 997 if (err) 998 return err; 999 1000 max_enh_size_mult = 1001 (ext_csd[EXT_CSD_MAX_ENH_SIZE_MULT+2] << 16) + 1002 (ext_csd[EXT_CSD_MAX_ENH_SIZE_MULT+1] << 8) + 1003 ext_csd[EXT_CSD_MAX_ENH_SIZE_MULT]; 1004 if (tot_enh_size_mult > max_enh_size_mult) { 1005 pr_err("Total enhanced size exceeds maximum (%u > %u)\n", 1006 tot_enh_size_mult, max_enh_size_mult); 1007 return -EMEDIUMTYPE; 1008 } 1009 1010 /* The default value of EXT_CSD_WR_REL_SET is device 1011 * dependent, the values can only be changed if the 1012 * EXT_CSD_HS_CTRL_REL bit is set. The values can be 1013 * changed only once and before partitioning is completed. */ 1014 wr_rel_set = ext_csd[EXT_CSD_WR_REL_SET]; 1015 if (conf->user.wr_rel_change) { 1016 if (conf->user.wr_rel_set) 1017 wr_rel_set |= EXT_CSD_WR_DATA_REL_USR; 1018 else 1019 wr_rel_set &= ~EXT_CSD_WR_DATA_REL_USR; 1020 } 1021 for (pidx = 0; pidx < 4; pidx++) { 1022 if (conf->gp_part[pidx].wr_rel_change) { 1023 if (conf->gp_part[pidx].wr_rel_set) 1024 wr_rel_set |= EXT_CSD_WR_DATA_REL_GP(pidx); 1025 else 1026 wr_rel_set &= ~EXT_CSD_WR_DATA_REL_GP(pidx); 1027 } 1028 } 1029 1030 if (wr_rel_set != ext_csd[EXT_CSD_WR_REL_SET] && 1031 !(ext_csd[EXT_CSD_WR_REL_PARAM] & EXT_CSD_HS_CTRL_REL)) { 1032 puts("Card does not support host controlled partition write " 1033 "reliability settings\n"); 1034 return -EMEDIUMTYPE; 1035 } 1036 1037 if (ext_csd[EXT_CSD_PARTITION_SETTING] & 1038 EXT_CSD_PARTITION_SETTING_COMPLETED) { 1039 pr_err("Card already partitioned\n"); 1040 return -EPERM; 1041 } 1042 1043 if (mode == MMC_HWPART_CONF_CHECK) 1044 return 0; 1045 1046 /* Partitioning requires high-capacity size definitions */ 1047 if (!(ext_csd[EXT_CSD_ERASE_GROUP_DEF] & 0x01)) { 1048 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 1049 EXT_CSD_ERASE_GROUP_DEF, 1); 1050 1051 if (err) 1052 return err; 1053 1054 ext_csd[EXT_CSD_ERASE_GROUP_DEF] = 1; 1055 1056 /* update erase group size to be high-capacity */ 1057 mmc->erase_grp_size = 1058 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] * 1024; 1059 1060 } 1061 1062 /* all OK, write the configuration */ 1063 for (i = 0; i < 4; i++) { 1064 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 1065 EXT_CSD_ENH_START_ADDR+i, 1066 (enh_start_addr >> (i*8)) & 0xFF); 1067 if (err) 1068 return err; 1069 } 1070 for (i = 0; i < 3; i++) { 1071 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 1072 EXT_CSD_ENH_SIZE_MULT+i, 1073 (enh_size_mult >> (i*8)) & 0xFF); 1074 if (err) 1075 return err; 1076 } 1077 for (pidx = 0; pidx < 4; pidx++) { 1078 for (i = 0; i < 3; i++) { 1079 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 1080 EXT_CSD_GP_SIZE_MULT+pidx*3+i, 1081 (gp_size_mult[pidx] >> (i*8)) & 0xFF); 1082 if (err) 1083 return err; 1084 } 1085 } 1086 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 1087 EXT_CSD_PARTITIONS_ATTRIBUTE, part_attrs); 1088 if (err) 1089 return err; 1090 1091 if (mode == MMC_HWPART_CONF_SET) 1092 return 0; 1093 1094 /* The WR_REL_SET is a write-once register but shall be 1095 * written before setting PART_SETTING_COMPLETED. As it is 1096 * write-once we can only write it when completing the 1097 * partitioning. */ 1098 if (wr_rel_set != ext_csd[EXT_CSD_WR_REL_SET]) { 1099 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 1100 EXT_CSD_WR_REL_SET, wr_rel_set); 1101 if (err) 1102 return err; 1103 } 1104 1105 /* Setting PART_SETTING_COMPLETED confirms the partition 1106 * configuration but it only becomes effective after power 1107 * cycle, so we do not adjust the partition related settings 1108 * in the mmc struct. */ 1109 1110 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 1111 EXT_CSD_PARTITION_SETTING, 1112 EXT_CSD_PARTITION_SETTING_COMPLETED); 1113 if (err) 1114 return err; 1115 1116 return 0; 1117 } 1118 #endif 1119 1120 #if !CONFIG_IS_ENABLED(DM_MMC) 1121 int mmc_getcd(struct mmc *mmc) 1122 { 1123 int cd; 1124 1125 cd = board_mmc_getcd(mmc); 1126 1127 if (cd < 0) { 1128 if (mmc->cfg->ops->getcd) 1129 cd = mmc->cfg->ops->getcd(mmc); 1130 else 1131 cd = 1; 1132 } 1133 1134 return cd; 1135 } 1136 #endif 1137 1138 #if !CONFIG_IS_ENABLED(MMC_TINY) 1139 static int sd_switch(struct mmc *mmc, int mode, int group, u8 value, u8 *resp) 1140 { 1141 struct mmc_cmd cmd; 1142 struct mmc_data data; 1143 1144 /* Switch the frequency */ 1145 cmd.cmdidx = SD_CMD_SWITCH_FUNC; 1146 cmd.resp_type = MMC_RSP_R1; 1147 cmd.cmdarg = (mode << 31) | 0xffffff; 1148 cmd.cmdarg &= ~(0xf << (group * 4)); 1149 cmd.cmdarg |= value << (group * 4); 1150 1151 data.dest = (char *)resp; 1152 data.blocksize = 64; 1153 data.blocks = 1; 1154 data.flags = MMC_DATA_READ; 1155 1156 return mmc_send_cmd(mmc, &cmd, &data); 1157 } 1158 1159 static int sd_get_capabilities(struct mmc *mmc) 1160 { 1161 int err; 1162 struct mmc_cmd cmd; 1163 ALLOC_CACHE_ALIGN_BUFFER(__be32, scr, 2); 1164 ALLOC_CACHE_ALIGN_BUFFER(__be32, switch_status, 16); 1165 struct mmc_data data; 1166 int timeout; 1167 #if CONFIG_IS_ENABLED(MMC_UHS_SUPPORT) 1168 u32 sd3_bus_mode; 1169 #endif 1170 1171 mmc->card_caps = MMC_MODE_1BIT | MMC_CAP(SD_LEGACY); 1172 1173 if (mmc_host_is_spi(mmc)) 1174 return 0; 1175 1176 /* Read the SCR to find out if this card supports higher speeds */ 1177 cmd.cmdidx = MMC_CMD_APP_CMD; 1178 cmd.resp_type = MMC_RSP_R1; 1179 cmd.cmdarg = mmc->rca << 16; 1180 1181 err = mmc_send_cmd(mmc, &cmd, NULL); 1182 1183 if (err) 1184 return err; 1185 1186 cmd.cmdidx = SD_CMD_APP_SEND_SCR; 1187 cmd.resp_type = MMC_RSP_R1; 1188 cmd.cmdarg = 0; 1189 1190 timeout = 3; 1191 1192 retry_scr: 1193 data.dest = (char *)scr; 1194 data.blocksize = 8; 1195 data.blocks = 1; 1196 data.flags = MMC_DATA_READ; 1197 1198 err = mmc_send_cmd(mmc, &cmd, &data); 1199 1200 if (err) { 1201 if (timeout--) 1202 goto retry_scr; 1203 1204 return err; 1205 } 1206 1207 mmc->scr[0] = __be32_to_cpu(scr[0]); 1208 mmc->scr[1] = __be32_to_cpu(scr[1]); 1209 1210 switch ((mmc->scr[0] >> 24) & 0xf) { 1211 case 0: 1212 mmc->version = SD_VERSION_1_0; 1213 break; 1214 case 1: 1215 mmc->version = SD_VERSION_1_10; 1216 break; 1217 case 2: 1218 mmc->version = SD_VERSION_2; 1219 if ((mmc->scr[0] >> 15) & 0x1) 1220 mmc->version = SD_VERSION_3; 1221 break; 1222 default: 1223 mmc->version = SD_VERSION_1_0; 1224 break; 1225 } 1226 1227 if (mmc->scr[0] & SD_DATA_4BIT) 1228 mmc->card_caps |= MMC_MODE_4BIT; 1229 1230 /* Version 1.0 doesn't support switching */ 1231 if (mmc->version == SD_VERSION_1_0) 1232 return 0; 1233 1234 timeout = 4; 1235 while (timeout--) { 1236 err = sd_switch(mmc, SD_SWITCH_CHECK, 0, 1, 1237 (u8 *)switch_status); 1238 1239 if (err) 1240 return err; 1241 1242 /* The high-speed function is busy. Try again */ 1243 if (!(__be32_to_cpu(switch_status[7]) & SD_HIGHSPEED_BUSY)) 1244 break; 1245 } 1246 1247 /* If high-speed isn't supported, we return */ 1248 if (__be32_to_cpu(switch_status[3]) & SD_HIGHSPEED_SUPPORTED) 1249 mmc->card_caps |= MMC_CAP(SD_HS); 1250 1251 #if CONFIG_IS_ENABLED(MMC_UHS_SUPPORT) 1252 /* Version before 3.0 don't support UHS modes */ 1253 if (mmc->version < SD_VERSION_3) 1254 return 0; 1255 1256 sd3_bus_mode = __be32_to_cpu(switch_status[3]) >> 16 & 0x1f; 1257 if (sd3_bus_mode & SD_MODE_UHS_SDR104) 1258 mmc->card_caps |= MMC_CAP(UHS_SDR104); 1259 if (sd3_bus_mode & SD_MODE_UHS_SDR50) 1260 mmc->card_caps |= MMC_CAP(UHS_SDR50); 1261 if (sd3_bus_mode & SD_MODE_UHS_SDR25) 1262 mmc->card_caps |= MMC_CAP(UHS_SDR25); 1263 if (sd3_bus_mode & SD_MODE_UHS_SDR12) 1264 mmc->card_caps |= MMC_CAP(UHS_SDR12); 1265 if (sd3_bus_mode & SD_MODE_UHS_DDR50) 1266 mmc->card_caps |= MMC_CAP(UHS_DDR50); 1267 #endif 1268 1269 return 0; 1270 } 1271 1272 static int sd_set_card_speed(struct mmc *mmc, enum bus_mode mode) 1273 { 1274 int err; 1275 1276 ALLOC_CACHE_ALIGN_BUFFER(uint, switch_status, 16); 1277 int speed; 1278 1279 switch (mode) { 1280 case SD_LEGACY: 1281 speed = UHS_SDR12_BUS_SPEED; 1282 break; 1283 case SD_HS: 1284 speed = HIGH_SPEED_BUS_SPEED; 1285 break; 1286 #if CONFIG_IS_ENABLED(MMC_UHS_SUPPORT) 1287 case UHS_SDR12: 1288 speed = UHS_SDR12_BUS_SPEED; 1289 break; 1290 case UHS_SDR25: 1291 speed = UHS_SDR25_BUS_SPEED; 1292 break; 1293 case UHS_SDR50: 1294 speed = UHS_SDR50_BUS_SPEED; 1295 break; 1296 case UHS_DDR50: 1297 speed = UHS_DDR50_BUS_SPEED; 1298 break; 1299 case UHS_SDR104: 1300 speed = UHS_SDR104_BUS_SPEED; 1301 break; 1302 #endif 1303 default: 1304 return -EINVAL; 1305 } 1306 1307 err = sd_switch(mmc, SD_SWITCH_SWITCH, 0, speed, (u8 *)switch_status); 1308 if (err) 1309 return err; 1310 1311 if (((__be32_to_cpu(switch_status[4]) >> 24) & 0xF) != speed) 1312 return -ENOTSUPP; 1313 1314 return 0; 1315 } 1316 1317 static int sd_select_bus_width(struct mmc *mmc, int w) 1318 { 1319 int err; 1320 struct mmc_cmd cmd; 1321 1322 if ((w != 4) && (w != 1)) 1323 return -EINVAL; 1324 1325 cmd.cmdidx = MMC_CMD_APP_CMD; 1326 cmd.resp_type = MMC_RSP_R1; 1327 cmd.cmdarg = mmc->rca << 16; 1328 1329 err = mmc_send_cmd(mmc, &cmd, NULL); 1330 if (err) 1331 return err; 1332 1333 cmd.cmdidx = SD_CMD_APP_SET_BUS_WIDTH; 1334 cmd.resp_type = MMC_RSP_R1; 1335 if (w == 4) 1336 cmd.cmdarg = 2; 1337 else if (w == 1) 1338 cmd.cmdarg = 0; 1339 err = mmc_send_cmd(mmc, &cmd, NULL); 1340 if (err) 1341 return err; 1342 1343 return 0; 1344 } 1345 #endif 1346 1347 #if CONFIG_IS_ENABLED(MMC_WRITE) 1348 static int sd_read_ssr(struct mmc *mmc) 1349 { 1350 static const unsigned int sd_au_size[] = { 1351 0, SZ_16K / 512, SZ_32K / 512, 1352 SZ_64K / 512, SZ_128K / 512, SZ_256K / 512, 1353 SZ_512K / 512, SZ_1M / 512, SZ_2M / 512, 1354 SZ_4M / 512, SZ_8M / 512, (SZ_8M + SZ_4M) / 512, 1355 SZ_16M / 512, (SZ_16M + SZ_8M) / 512, SZ_32M / 512, 1356 SZ_64M / 512, 1357 }; 1358 int err, i; 1359 struct mmc_cmd cmd; 1360 ALLOC_CACHE_ALIGN_BUFFER(uint, ssr, 16); 1361 struct mmc_data data; 1362 int timeout = 3; 1363 unsigned int au, eo, et, es; 1364 1365 cmd.cmdidx = MMC_CMD_APP_CMD; 1366 cmd.resp_type = MMC_RSP_R1; 1367 cmd.cmdarg = mmc->rca << 16; 1368 1369 err = mmc_send_cmd(mmc, &cmd, NULL); 1370 if (err) 1371 return err; 1372 1373 cmd.cmdidx = SD_CMD_APP_SD_STATUS; 1374 cmd.resp_type = MMC_RSP_R1; 1375 cmd.cmdarg = 0; 1376 1377 retry_ssr: 1378 data.dest = (char *)ssr; 1379 data.blocksize = 64; 1380 data.blocks = 1; 1381 data.flags = MMC_DATA_READ; 1382 1383 err = mmc_send_cmd(mmc, &cmd, &data); 1384 if (err) { 1385 if (timeout--) 1386 goto retry_ssr; 1387 1388 return err; 1389 } 1390 1391 for (i = 0; i < 16; i++) 1392 ssr[i] = be32_to_cpu(ssr[i]); 1393 1394 au = (ssr[2] >> 12) & 0xF; 1395 if ((au <= 9) || (mmc->version == SD_VERSION_3)) { 1396 mmc->ssr.au = sd_au_size[au]; 1397 es = (ssr[3] >> 24) & 0xFF; 1398 es |= (ssr[2] & 0xFF) << 8; 1399 et = (ssr[3] >> 18) & 0x3F; 1400 if (es && et) { 1401 eo = (ssr[3] >> 16) & 0x3; 1402 mmc->ssr.erase_timeout = (et * 1000) / es; 1403 mmc->ssr.erase_offset = eo * 1000; 1404 } 1405 } else { 1406 pr_debug("Invalid Allocation Unit Size.\n"); 1407 } 1408 1409 return 0; 1410 } 1411 #endif 1412 /* frequency bases */ 1413 /* divided by 10 to be nice to platforms without floating point */ 1414 static const int fbase[] = { 1415 10000, 1416 100000, 1417 1000000, 1418 10000000, 1419 }; 1420 1421 /* Multiplier values for TRAN_SPEED. Multiplied by 10 to be nice 1422 * to platforms without floating point. 1423 */ 1424 static const u8 multipliers[] = { 1425 0, /* reserved */ 1426 10, 1427 12, 1428 13, 1429 15, 1430 20, 1431 25, 1432 30, 1433 35, 1434 40, 1435 45, 1436 50, 1437 55, 1438 60, 1439 70, 1440 80, 1441 }; 1442 1443 static inline int bus_width(uint cap) 1444 { 1445 if (cap == MMC_MODE_8BIT) 1446 return 8; 1447 if (cap == MMC_MODE_4BIT) 1448 return 4; 1449 if (cap == MMC_MODE_1BIT) 1450 return 1; 1451 pr_warn("invalid bus witdh capability 0x%x\n", cap); 1452 return 0; 1453 } 1454 1455 #if !CONFIG_IS_ENABLED(DM_MMC) 1456 #ifdef MMC_SUPPORTS_TUNING 1457 static int mmc_execute_tuning(struct mmc *mmc, uint opcode) 1458 { 1459 return -ENOTSUPP; 1460 } 1461 #endif 1462 1463 static void mmc_send_init_stream(struct mmc *mmc) 1464 { 1465 } 1466 1467 static int mmc_set_ios(struct mmc *mmc) 1468 { 1469 int ret = 0; 1470 1471 if (mmc->cfg->ops->set_ios) 1472 ret = mmc->cfg->ops->set_ios(mmc); 1473 1474 return ret; 1475 } 1476 #endif 1477 1478 int mmc_set_clock(struct mmc *mmc, uint clock, bool disable) 1479 { 1480 if (!disable) { 1481 if (clock > mmc->cfg->f_max) 1482 clock = mmc->cfg->f_max; 1483 1484 if (clock < mmc->cfg->f_min) 1485 clock = mmc->cfg->f_min; 1486 } 1487 1488 mmc->clock = clock; 1489 mmc->clk_disable = disable; 1490 1491 debug("clock is %s (%dHz)\n", disable ? "disabled" : "enabled", clock); 1492 1493 return mmc_set_ios(mmc); 1494 } 1495 1496 static int mmc_set_bus_width(struct mmc *mmc, uint width) 1497 { 1498 mmc->bus_width = width; 1499 1500 return mmc_set_ios(mmc); 1501 } 1502 1503 #if CONFIG_IS_ENABLED(MMC_VERBOSE) || defined(DEBUG) 1504 /* 1505 * helper function to display the capabilities in a human 1506 * friendly manner. The capabilities include bus width and 1507 * supported modes. 1508 */ 1509 void mmc_dump_capabilities(const char *text, uint caps) 1510 { 1511 enum bus_mode mode; 1512 1513 pr_debug("%s: widths [", text); 1514 if (caps & MMC_MODE_8BIT) 1515 pr_debug("8, "); 1516 if (caps & MMC_MODE_4BIT) 1517 pr_debug("4, "); 1518 if (caps & MMC_MODE_1BIT) 1519 pr_debug("1, "); 1520 pr_debug("\b\b] modes ["); 1521 for (mode = MMC_LEGACY; mode < MMC_MODES_END; mode++) 1522 if (MMC_CAP(mode) & caps) 1523 pr_debug("%s, ", mmc_mode_name(mode)); 1524 pr_debug("\b\b]\n"); 1525 } 1526 #endif 1527 1528 struct mode_width_tuning { 1529 enum bus_mode mode; 1530 uint widths; 1531 #ifdef MMC_SUPPORTS_TUNING 1532 uint tuning; 1533 #endif 1534 }; 1535 1536 #if CONFIG_IS_ENABLED(MMC_IO_VOLTAGE) 1537 int mmc_voltage_to_mv(enum mmc_voltage voltage) 1538 { 1539 switch (voltage) { 1540 case MMC_SIGNAL_VOLTAGE_000: return 0; 1541 case MMC_SIGNAL_VOLTAGE_330: return 3300; 1542 case MMC_SIGNAL_VOLTAGE_180: return 1800; 1543 case MMC_SIGNAL_VOLTAGE_120: return 1200; 1544 } 1545 return -EINVAL; 1546 } 1547 1548 static int mmc_set_signal_voltage(struct mmc *mmc, uint signal_voltage) 1549 { 1550 int err; 1551 1552 if (mmc->signal_voltage == signal_voltage) 1553 return 0; 1554 1555 mmc->signal_voltage = signal_voltage; 1556 err = mmc_set_ios(mmc); 1557 if (err) 1558 pr_debug("unable to set voltage (err %d)\n", err); 1559 1560 return err; 1561 } 1562 #else 1563 static inline int mmc_set_signal_voltage(struct mmc *mmc, uint signal_voltage) 1564 { 1565 return 0; 1566 } 1567 #endif 1568 1569 #if !CONFIG_IS_ENABLED(MMC_TINY) 1570 static const struct mode_width_tuning sd_modes_by_pref[] = { 1571 #if CONFIG_IS_ENABLED(MMC_UHS_SUPPORT) 1572 #ifdef MMC_SUPPORTS_TUNING 1573 { 1574 .mode = UHS_SDR104, 1575 .widths = MMC_MODE_4BIT | MMC_MODE_1BIT, 1576 .tuning = MMC_CMD_SEND_TUNING_BLOCK 1577 }, 1578 #endif 1579 { 1580 .mode = UHS_SDR50, 1581 .widths = MMC_MODE_4BIT | MMC_MODE_1BIT, 1582 }, 1583 { 1584 .mode = UHS_DDR50, 1585 .widths = MMC_MODE_4BIT | MMC_MODE_1BIT, 1586 }, 1587 { 1588 .mode = UHS_SDR25, 1589 .widths = MMC_MODE_4BIT | MMC_MODE_1BIT, 1590 }, 1591 #endif 1592 { 1593 .mode = SD_HS, 1594 .widths = MMC_MODE_4BIT | MMC_MODE_1BIT, 1595 }, 1596 #if CONFIG_IS_ENABLED(MMC_UHS_SUPPORT) 1597 { 1598 .mode = UHS_SDR12, 1599 .widths = MMC_MODE_4BIT | MMC_MODE_1BIT, 1600 }, 1601 #endif 1602 { 1603 .mode = SD_LEGACY, 1604 .widths = MMC_MODE_4BIT | MMC_MODE_1BIT, 1605 } 1606 }; 1607 1608 #define for_each_sd_mode_by_pref(caps, mwt) \ 1609 for (mwt = sd_modes_by_pref;\ 1610 mwt < sd_modes_by_pref + ARRAY_SIZE(sd_modes_by_pref);\ 1611 mwt++) \ 1612 if (caps & MMC_CAP(mwt->mode)) 1613 1614 static int sd_select_mode_and_width(struct mmc *mmc, uint card_caps) 1615 { 1616 int err; 1617 uint widths[] = {MMC_MODE_4BIT, MMC_MODE_1BIT}; 1618 const struct mode_width_tuning *mwt; 1619 #if CONFIG_IS_ENABLED(MMC_UHS_SUPPORT) 1620 bool uhs_en = (mmc->ocr & OCR_S18R) ? true : false; 1621 #else 1622 bool uhs_en = false; 1623 #endif 1624 uint caps; 1625 1626 #ifdef DEBUG 1627 mmc_dump_capabilities("sd card", card_caps); 1628 mmc_dump_capabilities("host", mmc->host_caps); 1629 #endif 1630 1631 /* Restrict card's capabilities by what the host can do */ 1632 caps = card_caps & mmc->host_caps; 1633 1634 if (!uhs_en) 1635 caps &= ~UHS_CAPS; 1636 1637 for_each_sd_mode_by_pref(caps, mwt) { 1638 uint *w; 1639 1640 for (w = widths; w < widths + ARRAY_SIZE(widths); w++) { 1641 if (*w & caps & mwt->widths) { 1642 pr_debug("trying mode %s width %d (at %d MHz)\n", 1643 mmc_mode_name(mwt->mode), 1644 bus_width(*w), 1645 mmc_mode2freq(mmc, mwt->mode) / 1000000); 1646 1647 /* configure the bus width (card + host) */ 1648 err = sd_select_bus_width(mmc, bus_width(*w)); 1649 if (err) 1650 goto error; 1651 mmc_set_bus_width(mmc, bus_width(*w)); 1652 1653 /* configure the bus mode (card) */ 1654 err = sd_set_card_speed(mmc, mwt->mode); 1655 if (err) 1656 goto error; 1657 1658 /* configure the bus mode (host) */ 1659 mmc_select_mode(mmc, mwt->mode); 1660 mmc_set_clock(mmc, mmc->tran_speed, 1661 MMC_CLK_ENABLE); 1662 1663 #ifdef MMC_SUPPORTS_TUNING 1664 /* execute tuning if needed */ 1665 if (mwt->tuning && !mmc_host_is_spi(mmc)) { 1666 err = mmc_execute_tuning(mmc, 1667 mwt->tuning); 1668 if (err) { 1669 pr_debug("tuning failed\n"); 1670 goto error; 1671 } 1672 } 1673 #endif 1674 1675 #if CONFIG_IS_ENABLED(MMC_WRITE) 1676 err = sd_read_ssr(mmc); 1677 if (err) 1678 pr_warn("unable to read ssr\n"); 1679 #endif 1680 if (!err) 1681 return 0; 1682 1683 error: 1684 /* revert to a safer bus speed */ 1685 mmc_select_mode(mmc, SD_LEGACY); 1686 mmc_set_clock(mmc, mmc->tran_speed, 1687 MMC_CLK_ENABLE); 1688 } 1689 } 1690 } 1691 1692 pr_err("unable to select a mode\n"); 1693 return -ENOTSUPP; 1694 } 1695 1696 /* 1697 * read the compare the part of ext csd that is constant. 1698 * This can be used to check that the transfer is working 1699 * as expected. 1700 */ 1701 static int mmc_read_and_compare_ext_csd(struct mmc *mmc) 1702 { 1703 int err; 1704 const u8 *ext_csd = mmc->ext_csd; 1705 ALLOC_CACHE_ALIGN_BUFFER(u8, test_csd, MMC_MAX_BLOCK_LEN); 1706 1707 if (mmc->version < MMC_VERSION_4) 1708 return 0; 1709 1710 err = mmc_send_ext_csd(mmc, test_csd); 1711 if (err) 1712 return err; 1713 1714 /* Only compare read only fields */ 1715 if (ext_csd[EXT_CSD_PARTITIONING_SUPPORT] 1716 == test_csd[EXT_CSD_PARTITIONING_SUPPORT] && 1717 ext_csd[EXT_CSD_HC_WP_GRP_SIZE] 1718 == test_csd[EXT_CSD_HC_WP_GRP_SIZE] && 1719 ext_csd[EXT_CSD_REV] 1720 == test_csd[EXT_CSD_REV] && 1721 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] 1722 == test_csd[EXT_CSD_HC_ERASE_GRP_SIZE] && 1723 memcmp(&ext_csd[EXT_CSD_SEC_CNT], 1724 &test_csd[EXT_CSD_SEC_CNT], 4) == 0) 1725 return 0; 1726 1727 return -EBADMSG; 1728 } 1729 1730 #if CONFIG_IS_ENABLED(MMC_IO_VOLTAGE) 1731 static int mmc_set_lowest_voltage(struct mmc *mmc, enum bus_mode mode, 1732 uint32_t allowed_mask) 1733 { 1734 u32 card_mask = 0; 1735 1736 switch (mode) { 1737 case MMC_HS_200: 1738 if (mmc->cardtype & EXT_CSD_CARD_TYPE_HS200_1_8V) 1739 card_mask |= MMC_SIGNAL_VOLTAGE_180; 1740 if (mmc->cardtype & EXT_CSD_CARD_TYPE_HS200_1_2V) 1741 card_mask |= MMC_SIGNAL_VOLTAGE_120; 1742 break; 1743 case MMC_DDR_52: 1744 if (mmc->cardtype & EXT_CSD_CARD_TYPE_DDR_1_8V) 1745 card_mask |= MMC_SIGNAL_VOLTAGE_330 | 1746 MMC_SIGNAL_VOLTAGE_180; 1747 if (mmc->cardtype & EXT_CSD_CARD_TYPE_DDR_1_2V) 1748 card_mask |= MMC_SIGNAL_VOLTAGE_120; 1749 break; 1750 default: 1751 card_mask |= MMC_SIGNAL_VOLTAGE_330; 1752 break; 1753 } 1754 1755 while (card_mask & allowed_mask) { 1756 enum mmc_voltage best_match; 1757 1758 best_match = 1 << (ffs(card_mask & allowed_mask) - 1); 1759 if (!mmc_set_signal_voltage(mmc, best_match)) 1760 return 0; 1761 1762 allowed_mask &= ~best_match; 1763 } 1764 1765 return -ENOTSUPP; 1766 } 1767 #else 1768 static inline int mmc_set_lowest_voltage(struct mmc *mmc, enum bus_mode mode, 1769 uint32_t allowed_mask) 1770 { 1771 return 0; 1772 } 1773 #endif 1774 1775 static const struct mode_width_tuning mmc_modes_by_pref[] = { 1776 #if CONFIG_IS_ENABLED(MMC_HS200_SUPPORT) 1777 { 1778 .mode = MMC_HS_200, 1779 .widths = MMC_MODE_8BIT | MMC_MODE_4BIT, 1780 .tuning = MMC_CMD_SEND_TUNING_BLOCK_HS200 1781 }, 1782 #endif 1783 { 1784 .mode = MMC_DDR_52, 1785 .widths = MMC_MODE_8BIT | MMC_MODE_4BIT, 1786 }, 1787 { 1788 .mode = MMC_HS_52, 1789 .widths = MMC_MODE_8BIT | MMC_MODE_4BIT | MMC_MODE_1BIT, 1790 }, 1791 { 1792 .mode = MMC_HS, 1793 .widths = MMC_MODE_8BIT | MMC_MODE_4BIT | MMC_MODE_1BIT, 1794 }, 1795 { 1796 .mode = MMC_LEGACY, 1797 .widths = MMC_MODE_8BIT | MMC_MODE_4BIT | MMC_MODE_1BIT, 1798 } 1799 }; 1800 1801 #define for_each_mmc_mode_by_pref(caps, mwt) \ 1802 for (mwt = mmc_modes_by_pref;\ 1803 mwt < mmc_modes_by_pref + ARRAY_SIZE(mmc_modes_by_pref);\ 1804 mwt++) \ 1805 if (caps & MMC_CAP(mwt->mode)) 1806 1807 static const struct ext_csd_bus_width { 1808 uint cap; 1809 bool is_ddr; 1810 uint ext_csd_bits; 1811 } ext_csd_bus_width[] = { 1812 {MMC_MODE_8BIT, true, EXT_CSD_DDR_BUS_WIDTH_8}, 1813 {MMC_MODE_4BIT, true, EXT_CSD_DDR_BUS_WIDTH_4}, 1814 {MMC_MODE_8BIT, false, EXT_CSD_BUS_WIDTH_8}, 1815 {MMC_MODE_4BIT, false, EXT_CSD_BUS_WIDTH_4}, 1816 {MMC_MODE_1BIT, false, EXT_CSD_BUS_WIDTH_1}, 1817 }; 1818 1819 #define for_each_supported_width(caps, ddr, ecbv) \ 1820 for (ecbv = ext_csd_bus_width;\ 1821 ecbv < ext_csd_bus_width + ARRAY_SIZE(ext_csd_bus_width);\ 1822 ecbv++) \ 1823 if ((ddr == ecbv->is_ddr) && (caps & ecbv->cap)) 1824 1825 static int mmc_select_mode_and_width(struct mmc *mmc, uint card_caps) 1826 { 1827 int err; 1828 const struct mode_width_tuning *mwt; 1829 const struct ext_csd_bus_width *ecbw; 1830 1831 #ifdef DEBUG 1832 mmc_dump_capabilities("mmc", card_caps); 1833 mmc_dump_capabilities("host", mmc->host_caps); 1834 #endif 1835 1836 /* Restrict card's capabilities by what the host can do */ 1837 card_caps &= mmc->host_caps; 1838 1839 /* Only version 4 of MMC supports wider bus widths */ 1840 if (mmc->version < MMC_VERSION_4) 1841 return 0; 1842 1843 if (!mmc->ext_csd) { 1844 pr_debug("No ext_csd found!\n"); /* this should enver happen */ 1845 return -ENOTSUPP; 1846 } 1847 1848 mmc_set_clock(mmc, mmc->legacy_speed, MMC_CLK_ENABLE); 1849 1850 for_each_mmc_mode_by_pref(card_caps, mwt) { 1851 for_each_supported_width(card_caps & mwt->widths, 1852 mmc_is_mode_ddr(mwt->mode), ecbw) { 1853 enum mmc_voltage old_voltage; 1854 pr_debug("trying mode %s width %d (at %d MHz)\n", 1855 mmc_mode_name(mwt->mode), 1856 bus_width(ecbw->cap), 1857 mmc_mode2freq(mmc, mwt->mode) / 1000000); 1858 old_voltage = mmc->signal_voltage; 1859 err = mmc_set_lowest_voltage(mmc, mwt->mode, 1860 MMC_ALL_SIGNAL_VOLTAGE); 1861 if (err) 1862 continue; 1863 1864 /* configure the bus width (card + host) */ 1865 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 1866 EXT_CSD_BUS_WIDTH, 1867 ecbw->ext_csd_bits & ~EXT_CSD_DDR_FLAG); 1868 if (err) 1869 goto error; 1870 mmc_set_bus_width(mmc, bus_width(ecbw->cap)); 1871 1872 /* configure the bus speed (card) */ 1873 err = mmc_set_card_speed(mmc, mwt->mode); 1874 if (err) 1875 goto error; 1876 1877 /* 1878 * configure the bus width AND the ddr mode (card) 1879 * The host side will be taken care of in the next step 1880 */ 1881 if (ecbw->ext_csd_bits & EXT_CSD_DDR_FLAG) { 1882 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 1883 EXT_CSD_BUS_WIDTH, 1884 ecbw->ext_csd_bits); 1885 if (err) 1886 goto error; 1887 } 1888 1889 /* configure the bus mode (host) */ 1890 mmc_select_mode(mmc, mwt->mode); 1891 mmc_set_clock(mmc, mmc->tran_speed, MMC_CLK_ENABLE); 1892 #ifdef MMC_SUPPORTS_TUNING 1893 1894 /* execute tuning if needed */ 1895 if (mwt->tuning) { 1896 err = mmc_execute_tuning(mmc, mwt->tuning); 1897 if (err) { 1898 pr_debug("tuning failed\n"); 1899 goto error; 1900 } 1901 } 1902 #endif 1903 1904 /* do a transfer to check the configuration */ 1905 err = mmc_read_and_compare_ext_csd(mmc); 1906 if (!err) 1907 return 0; 1908 error: 1909 mmc_set_signal_voltage(mmc, old_voltage); 1910 /* if an error occured, revert to a safer bus mode */ 1911 mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 1912 EXT_CSD_BUS_WIDTH, EXT_CSD_BUS_WIDTH_1); 1913 mmc_select_mode(mmc, MMC_LEGACY); 1914 mmc_set_bus_width(mmc, 1); 1915 } 1916 } 1917 1918 pr_err("unable to select a mode\n"); 1919 1920 return -ENOTSUPP; 1921 } 1922 #endif 1923 1924 #if CONFIG_IS_ENABLED(MMC_TINY) 1925 DEFINE_CACHE_ALIGN_BUFFER(u8, ext_csd_bkup, MMC_MAX_BLOCK_LEN); 1926 #endif 1927 1928 static int mmc_startup_v4(struct mmc *mmc) 1929 { 1930 int err, i; 1931 u64 capacity; 1932 bool has_parts = false; 1933 bool part_completed; 1934 static const u32 mmc_versions[] = { 1935 MMC_VERSION_4, 1936 MMC_VERSION_4_1, 1937 MMC_VERSION_4_2, 1938 MMC_VERSION_4_3, 1939 MMC_VERSION_4_4, 1940 MMC_VERSION_4_41, 1941 MMC_VERSION_4_5, 1942 MMC_VERSION_5_0, 1943 MMC_VERSION_5_1 1944 }; 1945 1946 #if CONFIG_IS_ENABLED(MMC_TINY) 1947 u8 *ext_csd = ext_csd_bkup; 1948 1949 if (IS_SD(mmc) || mmc->version < MMC_VERSION_4) 1950 return 0; 1951 1952 if (!mmc->ext_csd) 1953 memset(ext_csd_bkup, 0, sizeof(ext_csd_bkup)); 1954 1955 err = mmc_send_ext_csd(mmc, ext_csd); 1956 if (err) 1957 goto error; 1958 1959 /* store the ext csd for future reference */ 1960 if (!mmc->ext_csd) 1961 mmc->ext_csd = ext_csd; 1962 #else 1963 ALLOC_CACHE_ALIGN_BUFFER(u8, ext_csd, MMC_MAX_BLOCK_LEN); 1964 1965 if (IS_SD(mmc) || (mmc->version < MMC_VERSION_4)) 1966 return 0; 1967 1968 /* check ext_csd version and capacity */ 1969 err = mmc_send_ext_csd(mmc, ext_csd); 1970 if (err) 1971 goto error; 1972 1973 /* store the ext csd for future reference */ 1974 if (!mmc->ext_csd) 1975 mmc->ext_csd = malloc(MMC_MAX_BLOCK_LEN); 1976 if (!mmc->ext_csd) 1977 return -ENOMEM; 1978 memcpy(mmc->ext_csd, ext_csd, MMC_MAX_BLOCK_LEN); 1979 #endif 1980 if (ext_csd[EXT_CSD_REV] >= ARRAY_SIZE(mmc_versions)) 1981 return -EINVAL; 1982 1983 mmc->version = mmc_versions[ext_csd[EXT_CSD_REV]]; 1984 1985 if (mmc->version >= MMC_VERSION_4_2) { 1986 /* 1987 * According to the JEDEC Standard, the value of 1988 * ext_csd's capacity is valid if the value is more 1989 * than 2GB 1990 */ 1991 capacity = ext_csd[EXT_CSD_SEC_CNT] << 0 1992 | ext_csd[EXT_CSD_SEC_CNT + 1] << 8 1993 | ext_csd[EXT_CSD_SEC_CNT + 2] << 16 1994 | ext_csd[EXT_CSD_SEC_CNT + 3] << 24; 1995 capacity *= MMC_MAX_BLOCK_LEN; 1996 if ((capacity >> 20) > 2 * 1024) 1997 mmc->capacity_user = capacity; 1998 } 1999 2000 /* The partition data may be non-zero but it is only 2001 * effective if PARTITION_SETTING_COMPLETED is set in 2002 * EXT_CSD, so ignore any data if this bit is not set, 2003 * except for enabling the high-capacity group size 2004 * definition (see below). 2005 */ 2006 part_completed = !!(ext_csd[EXT_CSD_PARTITION_SETTING] & 2007 EXT_CSD_PARTITION_SETTING_COMPLETED); 2008 2009 /* store the partition info of emmc */ 2010 mmc->part_support = ext_csd[EXT_CSD_PARTITIONING_SUPPORT]; 2011 if ((ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & PART_SUPPORT) || 2012 ext_csd[EXT_CSD_BOOT_MULT]) 2013 mmc->part_config = ext_csd[EXT_CSD_PART_CONF]; 2014 if (part_completed && 2015 (ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & ENHNCD_SUPPORT)) 2016 mmc->part_attr = ext_csd[EXT_CSD_PARTITIONS_ATTRIBUTE]; 2017 2018 mmc->capacity_boot = ext_csd[EXT_CSD_BOOT_MULT] << 17; 2019 2020 mmc->capacity_rpmb = ext_csd[EXT_CSD_RPMB_MULT] << 17; 2021 2022 for (i = 0; i < 4; i++) { 2023 int idx = EXT_CSD_GP_SIZE_MULT + i * 3; 2024 uint mult = (ext_csd[idx + 2] << 16) + 2025 (ext_csd[idx + 1] << 8) + ext_csd[idx]; 2026 if (mult) 2027 has_parts = true; 2028 if (!part_completed) 2029 continue; 2030 mmc->capacity_gp[i] = mult; 2031 mmc->capacity_gp[i] *= 2032 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]; 2033 mmc->capacity_gp[i] *= ext_csd[EXT_CSD_HC_WP_GRP_SIZE]; 2034 mmc->capacity_gp[i] <<= 19; 2035 } 2036 2037 #ifndef CONFIG_SPL_BUILD 2038 if (part_completed) { 2039 mmc->enh_user_size = 2040 (ext_csd[EXT_CSD_ENH_SIZE_MULT + 2] << 16) + 2041 (ext_csd[EXT_CSD_ENH_SIZE_MULT + 1] << 8) + 2042 ext_csd[EXT_CSD_ENH_SIZE_MULT]; 2043 mmc->enh_user_size *= ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]; 2044 mmc->enh_user_size *= ext_csd[EXT_CSD_HC_WP_GRP_SIZE]; 2045 mmc->enh_user_size <<= 19; 2046 mmc->enh_user_start = 2047 (ext_csd[EXT_CSD_ENH_START_ADDR + 3] << 24) + 2048 (ext_csd[EXT_CSD_ENH_START_ADDR + 2] << 16) + 2049 (ext_csd[EXT_CSD_ENH_START_ADDR + 1] << 8) + 2050 ext_csd[EXT_CSD_ENH_START_ADDR]; 2051 if (mmc->high_capacity) 2052 mmc->enh_user_start <<= 9; 2053 } 2054 #endif 2055 2056 /* 2057 * Host needs to enable ERASE_GRP_DEF bit if device is 2058 * partitioned. This bit will be lost every time after a reset 2059 * or power off. This will affect erase size. 2060 */ 2061 if (part_completed) 2062 has_parts = true; 2063 if ((ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & PART_SUPPORT) && 2064 (ext_csd[EXT_CSD_PARTITIONS_ATTRIBUTE] & PART_ENH_ATTRIB)) 2065 has_parts = true; 2066 if (has_parts) { 2067 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 2068 EXT_CSD_ERASE_GROUP_DEF, 1); 2069 2070 if (err) 2071 goto error; 2072 2073 ext_csd[EXT_CSD_ERASE_GROUP_DEF] = 1; 2074 } 2075 2076 if (ext_csd[EXT_CSD_ERASE_GROUP_DEF] & 0x01) { 2077 #if CONFIG_IS_ENABLED(MMC_WRITE) 2078 /* Read out group size from ext_csd */ 2079 mmc->erase_grp_size = 2080 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] * 1024; 2081 #endif 2082 /* 2083 * if high capacity and partition setting completed 2084 * SEC_COUNT is valid even if it is smaller than 2 GiB 2085 * JEDEC Standard JESD84-B45, 6.2.4 2086 */ 2087 if (mmc->high_capacity && part_completed) { 2088 capacity = (ext_csd[EXT_CSD_SEC_CNT]) | 2089 (ext_csd[EXT_CSD_SEC_CNT + 1] << 8) | 2090 (ext_csd[EXT_CSD_SEC_CNT + 2] << 16) | 2091 (ext_csd[EXT_CSD_SEC_CNT + 3] << 24); 2092 capacity *= MMC_MAX_BLOCK_LEN; 2093 mmc->capacity_user = capacity; 2094 } 2095 } 2096 #if CONFIG_IS_ENABLED(MMC_WRITE) 2097 else { 2098 /* Calculate the group size from the csd value. */ 2099 int erase_gsz, erase_gmul; 2100 2101 erase_gsz = (mmc->csd[2] & 0x00007c00) >> 10; 2102 erase_gmul = (mmc->csd[2] & 0x000003e0) >> 5; 2103 mmc->erase_grp_size = (erase_gsz + 1) 2104 * (erase_gmul + 1); 2105 } 2106 #endif 2107 #if CONFIG_IS_ENABLED(MMC_HW_PARTITIONING) 2108 mmc->hc_wp_grp_size = 1024 2109 * ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] 2110 * ext_csd[EXT_CSD_HC_WP_GRP_SIZE]; 2111 #endif 2112 2113 mmc->wr_rel_set = ext_csd[EXT_CSD_WR_REL_SET]; 2114 2115 return 0; 2116 error: 2117 if (mmc->ext_csd) { 2118 #if !CONFIG_IS_ENABLED(MMC_TINY) 2119 free(mmc->ext_csd); 2120 #endif 2121 mmc->ext_csd = NULL; 2122 } 2123 return err; 2124 } 2125 2126 static int mmc_startup(struct mmc *mmc) 2127 { 2128 int err, i; 2129 uint mult, freq; 2130 u64 cmult, csize; 2131 struct mmc_cmd cmd; 2132 struct blk_desc *bdesc; 2133 2134 #ifdef CONFIG_MMC_SPI_CRC_ON 2135 if (mmc_host_is_spi(mmc)) { /* enable CRC check for spi */ 2136 cmd.cmdidx = MMC_CMD_SPI_CRC_ON_OFF; 2137 cmd.resp_type = MMC_RSP_R1; 2138 cmd.cmdarg = 1; 2139 err = mmc_send_cmd(mmc, &cmd, NULL); 2140 if (err) 2141 return err; 2142 } 2143 #endif 2144 2145 /* Put the Card in Identify Mode */ 2146 cmd.cmdidx = mmc_host_is_spi(mmc) ? MMC_CMD_SEND_CID : 2147 MMC_CMD_ALL_SEND_CID; /* cmd not supported in spi */ 2148 cmd.resp_type = MMC_RSP_R2; 2149 cmd.cmdarg = 0; 2150 2151 err = mmc_send_cmd(mmc, &cmd, NULL); 2152 2153 #ifdef CONFIG_MMC_QUIRKS 2154 if (err && (mmc->quirks & MMC_QUIRK_RETRY_SEND_CID)) { 2155 int retries = 4; 2156 /* 2157 * It has been seen that SEND_CID may fail on the first 2158 * attempt, let's try a few more time 2159 */ 2160 do { 2161 err = mmc_send_cmd(mmc, &cmd, NULL); 2162 if (!err) 2163 break; 2164 } while (retries--); 2165 } 2166 #endif 2167 2168 if (err) 2169 return err; 2170 2171 memcpy(mmc->cid, cmd.response, 16); 2172 2173 /* 2174 * For MMC cards, set the Relative Address. 2175 * For SD cards, get the Relatvie Address. 2176 * This also puts the cards into Standby State 2177 */ 2178 if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */ 2179 cmd.cmdidx = SD_CMD_SEND_RELATIVE_ADDR; 2180 cmd.cmdarg = mmc->rca << 16; 2181 cmd.resp_type = MMC_RSP_R6; 2182 2183 err = mmc_send_cmd(mmc, &cmd, NULL); 2184 2185 if (err) 2186 return err; 2187 2188 if (IS_SD(mmc)) 2189 mmc->rca = (cmd.response[0] >> 16) & 0xffff; 2190 } 2191 2192 /* Get the Card-Specific Data */ 2193 cmd.cmdidx = MMC_CMD_SEND_CSD; 2194 cmd.resp_type = MMC_RSP_R2; 2195 cmd.cmdarg = mmc->rca << 16; 2196 2197 err = mmc_send_cmd(mmc, &cmd, NULL); 2198 2199 if (err) 2200 return err; 2201 2202 mmc->csd[0] = cmd.response[0]; 2203 mmc->csd[1] = cmd.response[1]; 2204 mmc->csd[2] = cmd.response[2]; 2205 mmc->csd[3] = cmd.response[3]; 2206 2207 if (mmc->version == MMC_VERSION_UNKNOWN) { 2208 int version = (cmd.response[0] >> 26) & 0xf; 2209 2210 switch (version) { 2211 case 0: 2212 mmc->version = MMC_VERSION_1_2; 2213 break; 2214 case 1: 2215 mmc->version = MMC_VERSION_1_4; 2216 break; 2217 case 2: 2218 mmc->version = MMC_VERSION_2_2; 2219 break; 2220 case 3: 2221 mmc->version = MMC_VERSION_3; 2222 break; 2223 case 4: 2224 mmc->version = MMC_VERSION_4; 2225 break; 2226 default: 2227 mmc->version = MMC_VERSION_1_2; 2228 break; 2229 } 2230 } 2231 2232 /* divide frequency by 10, since the mults are 10x bigger */ 2233 freq = fbase[(cmd.response[0] & 0x7)]; 2234 mult = multipliers[((cmd.response[0] >> 3) & 0xf)]; 2235 2236 mmc->legacy_speed = freq * mult; 2237 mmc_select_mode(mmc, MMC_LEGACY); 2238 2239 mmc->dsr_imp = ((cmd.response[1] >> 12) & 0x1); 2240 mmc->read_bl_len = 1 << ((cmd.response[1] >> 16) & 0xf); 2241 #if CONFIG_IS_ENABLED(MMC_WRITE) 2242 2243 if (IS_SD(mmc)) 2244 mmc->write_bl_len = mmc->read_bl_len; 2245 else 2246 mmc->write_bl_len = 1 << ((cmd.response[3] >> 22) & 0xf); 2247 #endif 2248 2249 if (mmc->high_capacity) { 2250 csize = (mmc->csd[1] & 0x3f) << 16 2251 | (mmc->csd[2] & 0xffff0000) >> 16; 2252 cmult = 8; 2253 } else { 2254 csize = (mmc->csd[1] & 0x3ff) << 2 2255 | (mmc->csd[2] & 0xc0000000) >> 30; 2256 cmult = (mmc->csd[2] & 0x00038000) >> 15; 2257 } 2258 2259 mmc->capacity_user = (csize + 1) << (cmult + 2); 2260 mmc->capacity_user *= mmc->read_bl_len; 2261 mmc->capacity_boot = 0; 2262 mmc->capacity_rpmb = 0; 2263 for (i = 0; i < 4; i++) 2264 mmc->capacity_gp[i] = 0; 2265 2266 if (mmc->read_bl_len > MMC_MAX_BLOCK_LEN) 2267 mmc->read_bl_len = MMC_MAX_BLOCK_LEN; 2268 2269 #if CONFIG_IS_ENABLED(MMC_WRITE) 2270 if (mmc->write_bl_len > MMC_MAX_BLOCK_LEN) 2271 mmc->write_bl_len = MMC_MAX_BLOCK_LEN; 2272 #endif 2273 2274 if ((mmc->dsr_imp) && (0xffffffff != mmc->dsr)) { 2275 cmd.cmdidx = MMC_CMD_SET_DSR; 2276 cmd.cmdarg = (mmc->dsr & 0xffff) << 16; 2277 cmd.resp_type = MMC_RSP_NONE; 2278 if (mmc_send_cmd(mmc, &cmd, NULL)) 2279 pr_warn("MMC: SET_DSR failed\n"); 2280 } 2281 2282 /* Select the card, and put it into Transfer Mode */ 2283 if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */ 2284 cmd.cmdidx = MMC_CMD_SELECT_CARD; 2285 cmd.resp_type = MMC_RSP_R1; 2286 cmd.cmdarg = mmc->rca << 16; 2287 err = mmc_send_cmd(mmc, &cmd, NULL); 2288 2289 if (err) 2290 return err; 2291 } 2292 2293 /* 2294 * For SD, its erase group is always one sector 2295 */ 2296 #if CONFIG_IS_ENABLED(MMC_WRITE) 2297 mmc->erase_grp_size = 1; 2298 #endif 2299 mmc->part_config = MMCPART_NOAVAILABLE; 2300 2301 err = mmc_startup_v4(mmc); 2302 if (err) 2303 return err; 2304 2305 err = mmc_set_capacity(mmc, mmc_get_blk_desc(mmc)->hwpart); 2306 if (err) 2307 return err; 2308 2309 #if CONFIG_IS_ENABLED(MMC_TINY) 2310 mmc_set_clock(mmc, mmc->legacy_speed, false); 2311 mmc_select_mode(mmc, IS_SD(mmc) ? SD_LEGACY : MMC_LEGACY); 2312 mmc_set_bus_width(mmc, 1); 2313 #else 2314 if (IS_SD(mmc)) { 2315 err = sd_get_capabilities(mmc); 2316 if (err) 2317 return err; 2318 err = sd_select_mode_and_width(mmc, mmc->card_caps); 2319 } else { 2320 err = mmc_get_capabilities(mmc); 2321 if (err) 2322 return err; 2323 mmc_select_mode_and_width(mmc, mmc->card_caps); 2324 } 2325 #endif 2326 if (err) 2327 return err; 2328 2329 mmc->best_mode = mmc->selected_mode; 2330 2331 /* Fix the block length for DDR mode */ 2332 if (mmc->ddr_mode) { 2333 mmc->read_bl_len = MMC_MAX_BLOCK_LEN; 2334 #if CONFIG_IS_ENABLED(MMC_WRITE) 2335 mmc->write_bl_len = MMC_MAX_BLOCK_LEN; 2336 #endif 2337 } 2338 2339 /* fill in device description */ 2340 bdesc = mmc_get_blk_desc(mmc); 2341 bdesc->lun = 0; 2342 bdesc->hwpart = 0; 2343 bdesc->type = 0; 2344 bdesc->blksz = mmc->read_bl_len; 2345 bdesc->log2blksz = LOG2(bdesc->blksz); 2346 bdesc->lba = lldiv(mmc->capacity, mmc->read_bl_len); 2347 #if !defined(CONFIG_SPL_BUILD) || \ 2348 (defined(CONFIG_SPL_LIBCOMMON_SUPPORT) && \ 2349 !defined(CONFIG_USE_TINY_PRINTF)) 2350 sprintf(bdesc->vendor, "Man %06x Snr %04x%04x", 2351 mmc->cid[0] >> 24, (mmc->cid[2] & 0xffff), 2352 (mmc->cid[3] >> 16) & 0xffff); 2353 sprintf(bdesc->product, "%c%c%c%c%c%c", mmc->cid[0] & 0xff, 2354 (mmc->cid[1] >> 24), (mmc->cid[1] >> 16) & 0xff, 2355 (mmc->cid[1] >> 8) & 0xff, mmc->cid[1] & 0xff, 2356 (mmc->cid[2] >> 24) & 0xff); 2357 sprintf(bdesc->revision, "%d.%d", (mmc->cid[2] >> 20) & 0xf, 2358 (mmc->cid[2] >> 16) & 0xf); 2359 #else 2360 bdesc->vendor[0] = 0; 2361 bdesc->product[0] = 0; 2362 bdesc->revision[0] = 0; 2363 #endif 2364 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBDISK_SUPPORT) 2365 part_init(bdesc); 2366 #endif 2367 2368 return 0; 2369 } 2370 2371 static int mmc_send_if_cond(struct mmc *mmc) 2372 { 2373 struct mmc_cmd cmd; 2374 int err; 2375 2376 cmd.cmdidx = SD_CMD_SEND_IF_COND; 2377 /* We set the bit if the host supports voltages between 2.7 and 3.6 V */ 2378 cmd.cmdarg = ((mmc->cfg->voltages & 0xff8000) != 0) << 8 | 0xaa; 2379 cmd.resp_type = MMC_RSP_R7; 2380 2381 err = mmc_send_cmd(mmc, &cmd, NULL); 2382 2383 if (err) 2384 return err; 2385 2386 if ((cmd.response[0] & 0xff) != 0xaa) 2387 return -EOPNOTSUPP; 2388 else 2389 mmc->version = SD_VERSION_2; 2390 2391 return 0; 2392 } 2393 2394 #if !CONFIG_IS_ENABLED(DM_MMC) 2395 /* board-specific MMC power initializations. */ 2396 __weak void board_mmc_power_init(void) 2397 { 2398 } 2399 #endif 2400 2401 static int mmc_power_init(struct mmc *mmc) 2402 { 2403 #if CONFIG_IS_ENABLED(DM_MMC) 2404 #if CONFIG_IS_ENABLED(DM_REGULATOR) 2405 int ret; 2406 2407 ret = device_get_supply_regulator(mmc->dev, "vmmc-supply", 2408 &mmc->vmmc_supply); 2409 if (ret) 2410 pr_debug("%s: No vmmc supply\n", mmc->dev->name); 2411 2412 ret = device_get_supply_regulator(mmc->dev, "vqmmc-supply", 2413 &mmc->vqmmc_supply); 2414 if (ret) 2415 pr_debug("%s: No vqmmc supply\n", mmc->dev->name); 2416 #endif 2417 #else /* !CONFIG_DM_MMC */ 2418 /* 2419 * Driver model should use a regulator, as above, rather than calling 2420 * out to board code. 2421 */ 2422 board_mmc_power_init(); 2423 #endif 2424 return 0; 2425 } 2426 2427 /* 2428 * put the host in the initial state: 2429 * - turn on Vdd (card power supply) 2430 * - configure the bus width and clock to minimal values 2431 */ 2432 static void mmc_set_initial_state(struct mmc *mmc) 2433 { 2434 int err; 2435 2436 /* First try to set 3.3V. If it fails set to 1.8V */ 2437 err = mmc_set_signal_voltage(mmc, MMC_SIGNAL_VOLTAGE_330); 2438 if (err != 0) 2439 err = mmc_set_signal_voltage(mmc, MMC_SIGNAL_VOLTAGE_180); 2440 if (err != 0) 2441 pr_warn("mmc: failed to set signal voltage\n"); 2442 2443 mmc_select_mode(mmc, MMC_LEGACY); 2444 mmc_set_bus_width(mmc, 1); 2445 mmc_set_clock(mmc, 0, MMC_CLK_ENABLE); 2446 } 2447 2448 static int mmc_power_on(struct mmc *mmc) 2449 { 2450 #if CONFIG_IS_ENABLED(DM_MMC) && CONFIG_IS_ENABLED(DM_REGULATOR) 2451 if (mmc->vmmc_supply) { 2452 int ret = regulator_set_enable(mmc->vmmc_supply, true); 2453 2454 if (ret) { 2455 puts("Error enabling VMMC supply\n"); 2456 return ret; 2457 } 2458 } 2459 #endif 2460 return 0; 2461 } 2462 2463 static int mmc_power_off(struct mmc *mmc) 2464 { 2465 mmc_set_clock(mmc, 0, MMC_CLK_DISABLE); 2466 #if CONFIG_IS_ENABLED(DM_MMC) && CONFIG_IS_ENABLED(DM_REGULATOR) 2467 if (mmc->vmmc_supply) { 2468 int ret = regulator_set_enable(mmc->vmmc_supply, false); 2469 2470 if (ret) { 2471 pr_debug("Error disabling VMMC supply\n"); 2472 return ret; 2473 } 2474 } 2475 #endif 2476 return 0; 2477 } 2478 2479 static int mmc_power_cycle(struct mmc *mmc) 2480 { 2481 int ret; 2482 2483 ret = mmc_power_off(mmc); 2484 if (ret) 2485 return ret; 2486 /* 2487 * SD spec recommends at least 1ms of delay. Let's wait for 2ms 2488 * to be on the safer side. 2489 */ 2490 udelay(2000); 2491 return mmc_power_on(mmc); 2492 } 2493 2494 int mmc_get_op_cond(struct mmc *mmc) 2495 { 2496 bool uhs_en = supports_uhs(mmc->cfg->host_caps); 2497 int err; 2498 2499 if (mmc->has_init) 2500 return 0; 2501 2502 #ifdef CONFIG_FSL_ESDHC_ADAPTER_IDENT 2503 mmc_adapter_card_type_ident(); 2504 #endif 2505 err = mmc_power_init(mmc); 2506 if (err) 2507 return err; 2508 2509 #ifdef CONFIG_MMC_QUIRKS 2510 mmc->quirks = MMC_QUIRK_RETRY_SET_BLOCKLEN | 2511 MMC_QUIRK_RETRY_SEND_CID; 2512 #endif 2513 2514 err = mmc_power_cycle(mmc); 2515 if (err) { 2516 /* 2517 * if power cycling is not supported, we should not try 2518 * to use the UHS modes, because we wouldn't be able to 2519 * recover from an error during the UHS initialization. 2520 */ 2521 pr_debug("Unable to do a full power cycle. Disabling the UHS modes for safety\n"); 2522 uhs_en = false; 2523 mmc->host_caps &= ~UHS_CAPS; 2524 err = mmc_power_on(mmc); 2525 } 2526 if (err) 2527 return err; 2528 2529 #if CONFIG_IS_ENABLED(DM_MMC) 2530 /* The device has already been probed ready for use */ 2531 #else 2532 /* made sure it's not NULL earlier */ 2533 err = mmc->cfg->ops->init(mmc); 2534 if (err) 2535 return err; 2536 #endif 2537 mmc->ddr_mode = 0; 2538 2539 retry: 2540 mmc_set_initial_state(mmc); 2541 mmc_send_init_stream(mmc); 2542 2543 /* Reset the Card */ 2544 err = mmc_go_idle(mmc); 2545 2546 if (err) 2547 return err; 2548 2549 /* The internal partition reset to user partition(0) at every CMD0*/ 2550 mmc_get_blk_desc(mmc)->hwpart = 0; 2551 2552 /* Test for SD version 2 */ 2553 err = mmc_send_if_cond(mmc); 2554 2555 /* Now try to get the SD card's operating condition */ 2556 err = sd_send_op_cond(mmc, uhs_en); 2557 if (err && uhs_en) { 2558 uhs_en = false; 2559 mmc_power_cycle(mmc); 2560 goto retry; 2561 } 2562 2563 /* If the command timed out, we check for an MMC card */ 2564 if (err == -ETIMEDOUT) { 2565 err = mmc_send_op_cond(mmc); 2566 2567 if (err) { 2568 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 2569 pr_err("Card did not respond to voltage select!\n"); 2570 #endif 2571 return -EOPNOTSUPP; 2572 } 2573 } 2574 2575 return err; 2576 } 2577 2578 int mmc_start_init(struct mmc *mmc) 2579 { 2580 bool no_card; 2581 int err = 0; 2582 2583 /* 2584 * all hosts are capable of 1 bit bus-width and able to use the legacy 2585 * timings. 2586 */ 2587 mmc->host_caps = mmc->cfg->host_caps | MMC_CAP(SD_LEGACY) | 2588 MMC_CAP(MMC_LEGACY) | MMC_MODE_1BIT; 2589 2590 #if !defined(CONFIG_MMC_BROKEN_CD) 2591 /* we pretend there's no card when init is NULL */ 2592 no_card = mmc_getcd(mmc) == 0; 2593 #else 2594 no_card = 0; 2595 #endif 2596 #if !CONFIG_IS_ENABLED(DM_MMC) 2597 no_card = no_card || (mmc->cfg->ops->init == NULL); 2598 #endif 2599 if (no_card) { 2600 mmc->has_init = 0; 2601 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 2602 pr_err("MMC: no card present\n"); 2603 #endif 2604 return -ENOMEDIUM; 2605 } 2606 2607 err = mmc_get_op_cond(mmc); 2608 2609 if (!err) 2610 mmc->init_in_progress = 1; 2611 2612 return err; 2613 } 2614 2615 static int mmc_complete_init(struct mmc *mmc) 2616 { 2617 int err = 0; 2618 2619 mmc->init_in_progress = 0; 2620 if (mmc->op_cond_pending) 2621 err = mmc_complete_op_cond(mmc); 2622 2623 if (!err) 2624 err = mmc_startup(mmc); 2625 if (err) 2626 mmc->has_init = 0; 2627 else 2628 mmc->has_init = 1; 2629 return err; 2630 } 2631 2632 int mmc_init(struct mmc *mmc) 2633 { 2634 int err = 0; 2635 __maybe_unused ulong start; 2636 #if CONFIG_IS_ENABLED(DM_MMC) 2637 struct mmc_uclass_priv *upriv = dev_get_uclass_priv(mmc->dev); 2638 2639 upriv->mmc = mmc; 2640 #endif 2641 if (mmc->has_init) 2642 return 0; 2643 2644 start = get_timer(0); 2645 2646 if (!mmc->init_in_progress) 2647 err = mmc_start_init(mmc); 2648 2649 if (!err) 2650 err = mmc_complete_init(mmc); 2651 if (err) 2652 pr_info("%s: %d, time %lu\n", __func__, err, get_timer(start)); 2653 2654 return err; 2655 } 2656 2657 int mmc_set_dsr(struct mmc *mmc, u16 val) 2658 { 2659 mmc->dsr = val; 2660 return 0; 2661 } 2662 2663 /* CPU-specific MMC initializations */ 2664 __weak int cpu_mmc_init(bd_t *bis) 2665 { 2666 return -1; 2667 } 2668 2669 /* board-specific MMC initializations. */ 2670 __weak int board_mmc_init(bd_t *bis) 2671 { 2672 return -1; 2673 } 2674 2675 void mmc_set_preinit(struct mmc *mmc, int preinit) 2676 { 2677 mmc->preinit = preinit; 2678 } 2679 2680 #if CONFIG_IS_ENABLED(DM_MMC) 2681 static int mmc_probe(bd_t *bis) 2682 { 2683 int ret, i; 2684 struct uclass *uc; 2685 struct udevice *dev; 2686 2687 ret = uclass_get(UCLASS_MMC, &uc); 2688 if (ret) 2689 return ret; 2690 2691 /* 2692 * Try to add them in sequence order. Really with driver model we 2693 * should allow holes, but the current MMC list does not allow that. 2694 * So if we request 0, 1, 3 we will get 0, 1, 2. 2695 */ 2696 for (i = 0; ; i++) { 2697 ret = uclass_get_device_by_seq(UCLASS_MMC, i, &dev); 2698 if (ret == -ENODEV) 2699 break; 2700 } 2701 uclass_foreach_dev(dev, uc) { 2702 ret = device_probe(dev); 2703 if (ret) 2704 pr_err("%s - probe failed: %d\n", dev->name, ret); 2705 } 2706 2707 return 0; 2708 } 2709 #else 2710 static int mmc_probe(bd_t *bis) 2711 { 2712 if (board_mmc_init(bis) < 0) 2713 cpu_mmc_init(bis); 2714 2715 return 0; 2716 } 2717 #endif 2718 2719 int mmc_initialize(bd_t *bis) 2720 { 2721 static int initialized = 0; 2722 int ret; 2723 if (initialized) /* Avoid initializing mmc multiple times */ 2724 return 0; 2725 initialized = 1; 2726 2727 #if !CONFIG_IS_ENABLED(BLK) 2728 #if !CONFIG_IS_ENABLED(MMC_TINY) 2729 mmc_list_init(); 2730 #endif 2731 #endif 2732 ret = mmc_probe(bis); 2733 if (ret) 2734 return ret; 2735 2736 #ifndef CONFIG_SPL_BUILD 2737 print_mmc_devices(','); 2738 #endif 2739 2740 mmc_do_preinit(); 2741 return 0; 2742 } 2743 2744 #ifdef CONFIG_CMD_BKOPS_ENABLE 2745 int mmc_set_bkops_enable(struct mmc *mmc) 2746 { 2747 int err; 2748 ALLOC_CACHE_ALIGN_BUFFER(u8, ext_csd, MMC_MAX_BLOCK_LEN); 2749 2750 err = mmc_send_ext_csd(mmc, ext_csd); 2751 if (err) { 2752 puts("Could not get ext_csd register values\n"); 2753 return err; 2754 } 2755 2756 if (!(ext_csd[EXT_CSD_BKOPS_SUPPORT] & 0x1)) { 2757 puts("Background operations not supported on device\n"); 2758 return -EMEDIUMTYPE; 2759 } 2760 2761 if (ext_csd[EXT_CSD_BKOPS_EN] & 0x1) { 2762 puts("Background operations already enabled\n"); 2763 return 0; 2764 } 2765 2766 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_BKOPS_EN, 1); 2767 if (err) { 2768 puts("Failed to enable manual background operations\n"); 2769 return err; 2770 } 2771 2772 puts("Enabled manual background operations\n"); 2773 2774 return 0; 2775 } 2776 #endif 2777