1 /* 2 * Copyright 2008, Freescale Semiconductor, Inc 3 * Andy Fleming 4 * 5 * Based vaguely on the Linux code 6 * 7 * SPDX-License-Identifier: GPL-2.0+ 8 */ 9 10 #include <config.h> 11 #include <common.h> 12 #include <command.h> 13 #include <errno.h> 14 #include <mmc.h> 15 #include <part.h> 16 #include <malloc.h> 17 #include <linux/list.h> 18 #include <div64.h> 19 #include "mmc_private.h" 20 21 static struct list_head mmc_devices; 22 static int cur_dev_num = -1; 23 24 __weak int board_mmc_getwp(struct mmc *mmc) 25 { 26 return -1; 27 } 28 29 int mmc_getwp(struct mmc *mmc) 30 { 31 int wp; 32 33 wp = board_mmc_getwp(mmc); 34 35 if (wp < 0) { 36 if (mmc->cfg->ops->getwp) 37 wp = mmc->cfg->ops->getwp(mmc); 38 else 39 wp = 0; 40 } 41 42 return wp; 43 } 44 45 __weak int board_mmc_getcd(struct mmc *mmc) 46 { 47 return -1; 48 } 49 50 int mmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data) 51 { 52 int ret; 53 54 #ifdef CONFIG_MMC_TRACE 55 int i; 56 u8 *ptr; 57 58 printf("CMD_SEND:%d\n", cmd->cmdidx); 59 printf("\t\tARG\t\t\t 0x%08X\n", cmd->cmdarg); 60 ret = mmc->cfg->ops->send_cmd(mmc, cmd, data); 61 switch (cmd->resp_type) { 62 case MMC_RSP_NONE: 63 printf("\t\tMMC_RSP_NONE\n"); 64 break; 65 case MMC_RSP_R1: 66 printf("\t\tMMC_RSP_R1,5,6,7 \t 0x%08X \n", 67 cmd->response[0]); 68 break; 69 case MMC_RSP_R1b: 70 printf("\t\tMMC_RSP_R1b\t\t 0x%08X \n", 71 cmd->response[0]); 72 break; 73 case MMC_RSP_R2: 74 printf("\t\tMMC_RSP_R2\t\t 0x%08X \n", 75 cmd->response[0]); 76 printf("\t\t \t\t 0x%08X \n", 77 cmd->response[1]); 78 printf("\t\t \t\t 0x%08X \n", 79 cmd->response[2]); 80 printf("\t\t \t\t 0x%08X \n", 81 cmd->response[3]); 82 printf("\n"); 83 printf("\t\t\t\t\tDUMPING DATA\n"); 84 for (i = 0; i < 4; i++) { 85 int j; 86 printf("\t\t\t\t\t%03d - ", i*4); 87 ptr = (u8 *)&cmd->response[i]; 88 ptr += 3; 89 for (j = 0; j < 4; j++) 90 printf("%02X ", *ptr--); 91 printf("\n"); 92 } 93 break; 94 case MMC_RSP_R3: 95 printf("\t\tMMC_RSP_R3,4\t\t 0x%08X \n", 96 cmd->response[0]); 97 break; 98 default: 99 printf("\t\tERROR MMC rsp not supported\n"); 100 break; 101 } 102 #else 103 ret = mmc->cfg->ops->send_cmd(mmc, cmd, data); 104 #endif 105 return ret; 106 } 107 108 int mmc_send_status(struct mmc *mmc, int timeout) 109 { 110 struct mmc_cmd cmd; 111 int err, retries = 5; 112 #ifdef CONFIG_MMC_TRACE 113 int status; 114 #endif 115 116 cmd.cmdidx = MMC_CMD_SEND_STATUS; 117 cmd.resp_type = MMC_RSP_R1; 118 if (!mmc_host_is_spi(mmc)) 119 cmd.cmdarg = mmc->rca << 16; 120 121 do { 122 err = mmc_send_cmd(mmc, &cmd, NULL); 123 if (!err) { 124 if ((cmd.response[0] & MMC_STATUS_RDY_FOR_DATA) && 125 (cmd.response[0] & MMC_STATUS_CURR_STATE) != 126 MMC_STATE_PRG) 127 break; 128 else if (cmd.response[0] & MMC_STATUS_MASK) { 129 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 130 printf("Status Error: 0x%08X\n", 131 cmd.response[0]); 132 #endif 133 return COMM_ERR; 134 } 135 } else if (--retries < 0) 136 return err; 137 138 udelay(1000); 139 140 } while (timeout--); 141 142 #ifdef CONFIG_MMC_TRACE 143 status = (cmd.response[0] & MMC_STATUS_CURR_STATE) >> 9; 144 printf("CURR STATE:%d\n", status); 145 #endif 146 if (timeout <= 0) { 147 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 148 printf("Timeout waiting card ready\n"); 149 #endif 150 return TIMEOUT; 151 } 152 if (cmd.response[0] & MMC_STATUS_SWITCH_ERROR) 153 return SWITCH_ERR; 154 155 return 0; 156 } 157 158 int mmc_set_blocklen(struct mmc *mmc, int len) 159 { 160 struct mmc_cmd cmd; 161 162 if (mmc->card_caps & MMC_MODE_DDR_52MHz) 163 return 0; 164 165 cmd.cmdidx = MMC_CMD_SET_BLOCKLEN; 166 cmd.resp_type = MMC_RSP_R1; 167 cmd.cmdarg = len; 168 169 return mmc_send_cmd(mmc, &cmd, NULL); 170 } 171 172 struct mmc *find_mmc_device(int dev_num) 173 { 174 struct mmc *m; 175 struct list_head *entry; 176 177 list_for_each(entry, &mmc_devices) { 178 m = list_entry(entry, struct mmc, link); 179 180 if (m->block_dev.dev == dev_num) 181 return m; 182 } 183 184 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 185 printf("MMC Device %d not found\n", dev_num); 186 #endif 187 188 return NULL; 189 } 190 191 static int mmc_read_blocks(struct mmc *mmc, void *dst, lbaint_t start, 192 lbaint_t blkcnt) 193 { 194 struct mmc_cmd cmd; 195 struct mmc_data data; 196 197 if (blkcnt > 1) 198 cmd.cmdidx = MMC_CMD_READ_MULTIPLE_BLOCK; 199 else 200 cmd.cmdidx = MMC_CMD_READ_SINGLE_BLOCK; 201 202 if (mmc->high_capacity) 203 cmd.cmdarg = start; 204 else 205 cmd.cmdarg = start * mmc->read_bl_len; 206 207 cmd.resp_type = MMC_RSP_R1; 208 209 data.dest = dst; 210 data.blocks = blkcnt; 211 data.blocksize = mmc->read_bl_len; 212 data.flags = MMC_DATA_READ; 213 214 if (mmc_send_cmd(mmc, &cmd, &data)) 215 return 0; 216 217 if (blkcnt > 1) { 218 cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION; 219 cmd.cmdarg = 0; 220 cmd.resp_type = MMC_RSP_R1b; 221 if (mmc_send_cmd(mmc, &cmd, NULL)) { 222 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 223 printf("mmc fail to send stop cmd\n"); 224 #endif 225 return 0; 226 } 227 } 228 229 return blkcnt; 230 } 231 232 static ulong mmc_bread(int dev_num, lbaint_t start, lbaint_t blkcnt, void *dst) 233 { 234 lbaint_t cur, blocks_todo = blkcnt; 235 236 if (blkcnt == 0) 237 return 0; 238 239 struct mmc *mmc = find_mmc_device(dev_num); 240 if (!mmc) 241 return 0; 242 243 if ((start + blkcnt) > mmc->block_dev.lba) { 244 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 245 printf("MMC: block number 0x" LBAF " exceeds max(0x" LBAF ")\n", 246 start + blkcnt, mmc->block_dev.lba); 247 #endif 248 return 0; 249 } 250 251 if (mmc_set_blocklen(mmc, mmc->read_bl_len)) 252 return 0; 253 254 do { 255 cur = (blocks_todo > mmc->cfg->b_max) ? 256 mmc->cfg->b_max : blocks_todo; 257 if(mmc_read_blocks(mmc, dst, start, cur) != cur) 258 return 0; 259 blocks_todo -= cur; 260 start += cur; 261 dst += cur * mmc->read_bl_len; 262 } while (blocks_todo > 0); 263 264 return blkcnt; 265 } 266 267 static int mmc_go_idle(struct mmc *mmc) 268 { 269 struct mmc_cmd cmd; 270 int err; 271 272 udelay(1000); 273 274 cmd.cmdidx = MMC_CMD_GO_IDLE_STATE; 275 cmd.cmdarg = 0; 276 cmd.resp_type = MMC_RSP_NONE; 277 278 err = mmc_send_cmd(mmc, &cmd, NULL); 279 280 if (err) 281 return err; 282 283 udelay(2000); 284 285 return 0; 286 } 287 288 static int sd_send_op_cond(struct mmc *mmc) 289 { 290 int timeout = 1000; 291 int err; 292 struct mmc_cmd cmd; 293 294 do { 295 cmd.cmdidx = MMC_CMD_APP_CMD; 296 cmd.resp_type = MMC_RSP_R1; 297 cmd.cmdarg = 0; 298 299 err = mmc_send_cmd(mmc, &cmd, NULL); 300 301 if (err) 302 return err; 303 304 cmd.cmdidx = SD_CMD_APP_SEND_OP_COND; 305 cmd.resp_type = MMC_RSP_R3; 306 307 /* 308 * Most cards do not answer if some reserved bits 309 * in the ocr are set. However, Some controller 310 * can set bit 7 (reserved for low voltages), but 311 * how to manage low voltages SD card is not yet 312 * specified. 313 */ 314 cmd.cmdarg = mmc_host_is_spi(mmc) ? 0 : 315 (mmc->cfg->voltages & 0xff8000); 316 317 if (mmc->version == SD_VERSION_2) 318 cmd.cmdarg |= OCR_HCS; 319 320 err = mmc_send_cmd(mmc, &cmd, NULL); 321 322 if (err) 323 return err; 324 325 udelay(1000); 326 } while ((!(cmd.response[0] & OCR_BUSY)) && timeout--); 327 328 if (timeout <= 0) 329 return UNUSABLE_ERR; 330 331 if (mmc->version != SD_VERSION_2) 332 mmc->version = SD_VERSION_1_0; 333 334 if (mmc_host_is_spi(mmc)) { /* read OCR for spi */ 335 cmd.cmdidx = MMC_CMD_SPI_READ_OCR; 336 cmd.resp_type = MMC_RSP_R3; 337 cmd.cmdarg = 0; 338 339 err = mmc_send_cmd(mmc, &cmd, NULL); 340 341 if (err) 342 return err; 343 } 344 345 mmc->ocr = cmd.response[0]; 346 347 mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS); 348 mmc->rca = 0; 349 350 return 0; 351 } 352 353 /* We pass in the cmd since otherwise the init seems to fail */ 354 static int mmc_send_op_cond_iter(struct mmc *mmc, struct mmc_cmd *cmd, 355 int use_arg) 356 { 357 int err; 358 359 cmd->cmdidx = MMC_CMD_SEND_OP_COND; 360 cmd->resp_type = MMC_RSP_R3; 361 cmd->cmdarg = 0; 362 if (use_arg && !mmc_host_is_spi(mmc)) { 363 cmd->cmdarg = 364 (mmc->cfg->voltages & 365 (mmc->op_cond_response & OCR_VOLTAGE_MASK)) | 366 (mmc->op_cond_response & OCR_ACCESS_MODE); 367 368 if (mmc->cfg->host_caps & MMC_MODE_HC) 369 cmd->cmdarg |= OCR_HCS; 370 } 371 err = mmc_send_cmd(mmc, cmd, NULL); 372 if (err) 373 return err; 374 mmc->op_cond_response = cmd->response[0]; 375 return 0; 376 } 377 378 static int mmc_send_op_cond(struct mmc *mmc) 379 { 380 struct mmc_cmd cmd; 381 int err, i; 382 383 /* Some cards seem to need this */ 384 mmc_go_idle(mmc); 385 386 /* Asking to the card its capabilities */ 387 mmc->op_cond_pending = 1; 388 for (i = 0; i < 2; i++) { 389 err = mmc_send_op_cond_iter(mmc, &cmd, i != 0); 390 if (err) 391 return err; 392 393 /* exit if not busy (flag seems to be inverted) */ 394 if (mmc->op_cond_response & OCR_BUSY) 395 return 0; 396 } 397 return IN_PROGRESS; 398 } 399 400 static int mmc_complete_op_cond(struct mmc *mmc) 401 { 402 struct mmc_cmd cmd; 403 int timeout = 1000; 404 uint start; 405 int err; 406 407 mmc->op_cond_pending = 0; 408 start = get_timer(0); 409 do { 410 err = mmc_send_op_cond_iter(mmc, &cmd, 1); 411 if (err) 412 return err; 413 if (get_timer(start) > timeout) 414 return UNUSABLE_ERR; 415 udelay(100); 416 } while (!(mmc->op_cond_response & OCR_BUSY)); 417 418 if (mmc_host_is_spi(mmc)) { /* read OCR for spi */ 419 cmd.cmdidx = MMC_CMD_SPI_READ_OCR; 420 cmd.resp_type = MMC_RSP_R3; 421 cmd.cmdarg = 0; 422 423 err = mmc_send_cmd(mmc, &cmd, NULL); 424 425 if (err) 426 return err; 427 } 428 429 mmc->version = MMC_VERSION_UNKNOWN; 430 mmc->ocr = cmd.response[0]; 431 432 mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS); 433 mmc->rca = 1; 434 435 return 0; 436 } 437 438 439 static int mmc_send_ext_csd(struct mmc *mmc, u8 *ext_csd) 440 { 441 struct mmc_cmd cmd; 442 struct mmc_data data; 443 int err; 444 445 /* Get the Card Status Register */ 446 cmd.cmdidx = MMC_CMD_SEND_EXT_CSD; 447 cmd.resp_type = MMC_RSP_R1; 448 cmd.cmdarg = 0; 449 450 data.dest = (char *)ext_csd; 451 data.blocks = 1; 452 data.blocksize = MMC_MAX_BLOCK_LEN; 453 data.flags = MMC_DATA_READ; 454 455 err = mmc_send_cmd(mmc, &cmd, &data); 456 457 return err; 458 } 459 460 461 static int mmc_switch(struct mmc *mmc, u8 set, u8 index, u8 value) 462 { 463 struct mmc_cmd cmd; 464 int timeout = 1000; 465 int ret; 466 467 cmd.cmdidx = MMC_CMD_SWITCH; 468 cmd.resp_type = MMC_RSP_R1b; 469 cmd.cmdarg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) | 470 (index << 16) | 471 (value << 8); 472 473 ret = mmc_send_cmd(mmc, &cmd, NULL); 474 475 /* Waiting for the ready status */ 476 if (!ret) 477 ret = mmc_send_status(mmc, timeout); 478 479 return ret; 480 481 } 482 483 static int mmc_change_freq(struct mmc *mmc) 484 { 485 ALLOC_CACHE_ALIGN_BUFFER(u8, ext_csd, MMC_MAX_BLOCK_LEN); 486 char cardtype; 487 int err; 488 489 mmc->card_caps = 0; 490 491 if (mmc_host_is_spi(mmc)) 492 return 0; 493 494 /* Only version 4 supports high-speed */ 495 if (mmc->version < MMC_VERSION_4) 496 return 0; 497 498 err = mmc_send_ext_csd(mmc, ext_csd); 499 500 if (err) 501 return err; 502 503 cardtype = ext_csd[EXT_CSD_CARD_TYPE] & 0xf; 504 505 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING, 1); 506 507 if (err) 508 return err == SWITCH_ERR ? 0 : err; 509 510 /* Now check to see that it worked */ 511 err = mmc_send_ext_csd(mmc, ext_csd); 512 513 if (err) 514 return err; 515 516 /* No high-speed support */ 517 if (!ext_csd[EXT_CSD_HS_TIMING]) 518 return 0; 519 520 /* High Speed is set, there are two types: 52MHz and 26MHz */ 521 if (cardtype & EXT_CSD_CARD_TYPE_52) { 522 if (cardtype & EXT_CSD_CARD_TYPE_DDR_52) 523 mmc->card_caps |= MMC_MODE_DDR_52MHz; 524 mmc->card_caps |= MMC_MODE_HS_52MHz | MMC_MODE_HS; 525 } else { 526 mmc->card_caps |= MMC_MODE_HS; 527 } 528 529 return 0; 530 } 531 532 static int mmc_set_capacity(struct mmc *mmc, int part_num) 533 { 534 switch (part_num) { 535 case 0: 536 mmc->capacity = mmc->capacity_user; 537 break; 538 case 1: 539 case 2: 540 mmc->capacity = mmc->capacity_boot; 541 break; 542 case 3: 543 mmc->capacity = mmc->capacity_rpmb; 544 break; 545 case 4: 546 case 5: 547 case 6: 548 case 7: 549 mmc->capacity = mmc->capacity_gp[part_num - 4]; 550 break; 551 default: 552 return -1; 553 } 554 555 mmc->block_dev.lba = lldiv(mmc->capacity, mmc->read_bl_len); 556 557 return 0; 558 } 559 560 int mmc_select_hwpart(int dev_num, int hwpart) 561 { 562 struct mmc *mmc = find_mmc_device(dev_num); 563 int ret; 564 565 if (!mmc) 566 return -ENODEV; 567 568 if (mmc->part_num == hwpart) 569 return 0; 570 571 if (mmc->part_config == MMCPART_NOAVAILABLE) { 572 printf("Card doesn't support part_switch\n"); 573 return -EMEDIUMTYPE; 574 } 575 576 ret = mmc_switch_part(dev_num, hwpart); 577 if (ret) 578 return ret; 579 580 mmc->part_num = hwpart; 581 582 return 0; 583 } 584 585 586 int mmc_switch_part(int dev_num, unsigned int part_num) 587 { 588 struct mmc *mmc = find_mmc_device(dev_num); 589 int ret; 590 591 if (!mmc) 592 return -1; 593 594 ret = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONF, 595 (mmc->part_config & ~PART_ACCESS_MASK) 596 | (part_num & PART_ACCESS_MASK)); 597 if (ret) 598 return ret; 599 600 return mmc_set_capacity(mmc, part_num); 601 } 602 603 int mmc_getcd(struct mmc *mmc) 604 { 605 int cd; 606 607 cd = board_mmc_getcd(mmc); 608 609 if (cd < 0) { 610 if (mmc->cfg->ops->getcd) 611 cd = mmc->cfg->ops->getcd(mmc); 612 else 613 cd = 1; 614 } 615 616 return cd; 617 } 618 619 static int sd_switch(struct mmc *mmc, int mode, int group, u8 value, u8 *resp) 620 { 621 struct mmc_cmd cmd; 622 struct mmc_data data; 623 624 /* Switch the frequency */ 625 cmd.cmdidx = SD_CMD_SWITCH_FUNC; 626 cmd.resp_type = MMC_RSP_R1; 627 cmd.cmdarg = (mode << 31) | 0xffffff; 628 cmd.cmdarg &= ~(0xf << (group * 4)); 629 cmd.cmdarg |= value << (group * 4); 630 631 data.dest = (char *)resp; 632 data.blocksize = 64; 633 data.blocks = 1; 634 data.flags = MMC_DATA_READ; 635 636 return mmc_send_cmd(mmc, &cmd, &data); 637 } 638 639 640 static int sd_change_freq(struct mmc *mmc) 641 { 642 int err; 643 struct mmc_cmd cmd; 644 ALLOC_CACHE_ALIGN_BUFFER(uint, scr, 2); 645 ALLOC_CACHE_ALIGN_BUFFER(uint, switch_status, 16); 646 struct mmc_data data; 647 int timeout; 648 649 mmc->card_caps = 0; 650 651 if (mmc_host_is_spi(mmc)) 652 return 0; 653 654 /* Read the SCR to find out if this card supports higher speeds */ 655 cmd.cmdidx = MMC_CMD_APP_CMD; 656 cmd.resp_type = MMC_RSP_R1; 657 cmd.cmdarg = mmc->rca << 16; 658 659 err = mmc_send_cmd(mmc, &cmd, NULL); 660 661 if (err) 662 return err; 663 664 cmd.cmdidx = SD_CMD_APP_SEND_SCR; 665 cmd.resp_type = MMC_RSP_R1; 666 cmd.cmdarg = 0; 667 668 timeout = 3; 669 670 retry_scr: 671 data.dest = (char *)scr; 672 data.blocksize = 8; 673 data.blocks = 1; 674 data.flags = MMC_DATA_READ; 675 676 err = mmc_send_cmd(mmc, &cmd, &data); 677 678 if (err) { 679 if (timeout--) 680 goto retry_scr; 681 682 return err; 683 } 684 685 mmc->scr[0] = __be32_to_cpu(scr[0]); 686 mmc->scr[1] = __be32_to_cpu(scr[1]); 687 688 switch ((mmc->scr[0] >> 24) & 0xf) { 689 case 0: 690 mmc->version = SD_VERSION_1_0; 691 break; 692 case 1: 693 mmc->version = SD_VERSION_1_10; 694 break; 695 case 2: 696 mmc->version = SD_VERSION_2; 697 if ((mmc->scr[0] >> 15) & 0x1) 698 mmc->version = SD_VERSION_3; 699 break; 700 default: 701 mmc->version = SD_VERSION_1_0; 702 break; 703 } 704 705 if (mmc->scr[0] & SD_DATA_4BIT) 706 mmc->card_caps |= MMC_MODE_4BIT; 707 708 /* Version 1.0 doesn't support switching */ 709 if (mmc->version == SD_VERSION_1_0) 710 return 0; 711 712 timeout = 4; 713 while (timeout--) { 714 err = sd_switch(mmc, SD_SWITCH_CHECK, 0, 1, 715 (u8 *)switch_status); 716 717 if (err) 718 return err; 719 720 /* The high-speed function is busy. Try again */ 721 if (!(__be32_to_cpu(switch_status[7]) & SD_HIGHSPEED_BUSY)) 722 break; 723 } 724 725 /* If high-speed isn't supported, we return */ 726 if (!(__be32_to_cpu(switch_status[3]) & SD_HIGHSPEED_SUPPORTED)) 727 return 0; 728 729 /* 730 * If the host doesn't support SD_HIGHSPEED, do not switch card to 731 * HIGHSPEED mode even if the card support SD_HIGHSPPED. 732 * This can avoid furthur problem when the card runs in different 733 * mode between the host. 734 */ 735 if (!((mmc->cfg->host_caps & MMC_MODE_HS_52MHz) && 736 (mmc->cfg->host_caps & MMC_MODE_HS))) 737 return 0; 738 739 err = sd_switch(mmc, SD_SWITCH_SWITCH, 0, 1, (u8 *)switch_status); 740 741 if (err) 742 return err; 743 744 if ((__be32_to_cpu(switch_status[4]) & 0x0f000000) == 0x01000000) 745 mmc->card_caps |= MMC_MODE_HS; 746 747 return 0; 748 } 749 750 /* frequency bases */ 751 /* divided by 10 to be nice to platforms without floating point */ 752 static const int fbase[] = { 753 10000, 754 100000, 755 1000000, 756 10000000, 757 }; 758 759 /* Multiplier values for TRAN_SPEED. Multiplied by 10 to be nice 760 * to platforms without floating point. 761 */ 762 static const int multipliers[] = { 763 0, /* reserved */ 764 10, 765 12, 766 13, 767 15, 768 20, 769 25, 770 30, 771 35, 772 40, 773 45, 774 50, 775 55, 776 60, 777 70, 778 80, 779 }; 780 781 static void mmc_set_ios(struct mmc *mmc) 782 { 783 if (mmc->cfg->ops->set_ios) 784 mmc->cfg->ops->set_ios(mmc); 785 } 786 787 void mmc_set_clock(struct mmc *mmc, uint clock) 788 { 789 if (clock > mmc->cfg->f_max) 790 clock = mmc->cfg->f_max; 791 792 if (clock < mmc->cfg->f_min) 793 clock = mmc->cfg->f_min; 794 795 mmc->clock = clock; 796 797 mmc_set_ios(mmc); 798 } 799 800 static void mmc_set_bus_width(struct mmc *mmc, uint width) 801 { 802 mmc->bus_width = width; 803 804 mmc_set_ios(mmc); 805 } 806 807 static int mmc_startup(struct mmc *mmc) 808 { 809 int err, i; 810 uint mult, freq; 811 u64 cmult, csize, capacity; 812 struct mmc_cmd cmd; 813 ALLOC_CACHE_ALIGN_BUFFER(u8, ext_csd, MMC_MAX_BLOCK_LEN); 814 ALLOC_CACHE_ALIGN_BUFFER(u8, test_csd, MMC_MAX_BLOCK_LEN); 815 int timeout = 1000; 816 817 #ifdef CONFIG_MMC_SPI_CRC_ON 818 if (mmc_host_is_spi(mmc)) { /* enable CRC check for spi */ 819 cmd.cmdidx = MMC_CMD_SPI_CRC_ON_OFF; 820 cmd.resp_type = MMC_RSP_R1; 821 cmd.cmdarg = 1; 822 err = mmc_send_cmd(mmc, &cmd, NULL); 823 824 if (err) 825 return err; 826 } 827 #endif 828 829 /* Put the Card in Identify Mode */ 830 cmd.cmdidx = mmc_host_is_spi(mmc) ? MMC_CMD_SEND_CID : 831 MMC_CMD_ALL_SEND_CID; /* cmd not supported in spi */ 832 cmd.resp_type = MMC_RSP_R2; 833 cmd.cmdarg = 0; 834 835 err = mmc_send_cmd(mmc, &cmd, NULL); 836 837 if (err) 838 return err; 839 840 memcpy(mmc->cid, cmd.response, 16); 841 842 /* 843 * For MMC cards, set the Relative Address. 844 * For SD cards, get the Relatvie Address. 845 * This also puts the cards into Standby State 846 */ 847 if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */ 848 cmd.cmdidx = SD_CMD_SEND_RELATIVE_ADDR; 849 cmd.cmdarg = mmc->rca << 16; 850 cmd.resp_type = MMC_RSP_R6; 851 852 err = mmc_send_cmd(mmc, &cmd, NULL); 853 854 if (err) 855 return err; 856 857 if (IS_SD(mmc)) 858 mmc->rca = (cmd.response[0] >> 16) & 0xffff; 859 } 860 861 /* Get the Card-Specific Data */ 862 cmd.cmdidx = MMC_CMD_SEND_CSD; 863 cmd.resp_type = MMC_RSP_R2; 864 cmd.cmdarg = mmc->rca << 16; 865 866 err = mmc_send_cmd(mmc, &cmd, NULL); 867 868 /* Waiting for the ready status */ 869 mmc_send_status(mmc, timeout); 870 871 if (err) 872 return err; 873 874 mmc->csd[0] = cmd.response[0]; 875 mmc->csd[1] = cmd.response[1]; 876 mmc->csd[2] = cmd.response[2]; 877 mmc->csd[3] = cmd.response[3]; 878 879 if (mmc->version == MMC_VERSION_UNKNOWN) { 880 int version = (cmd.response[0] >> 26) & 0xf; 881 882 switch (version) { 883 case 0: 884 mmc->version = MMC_VERSION_1_2; 885 break; 886 case 1: 887 mmc->version = MMC_VERSION_1_4; 888 break; 889 case 2: 890 mmc->version = MMC_VERSION_2_2; 891 break; 892 case 3: 893 mmc->version = MMC_VERSION_3; 894 break; 895 case 4: 896 mmc->version = MMC_VERSION_4; 897 break; 898 default: 899 mmc->version = MMC_VERSION_1_2; 900 break; 901 } 902 } 903 904 /* divide frequency by 10, since the mults are 10x bigger */ 905 freq = fbase[(cmd.response[0] & 0x7)]; 906 mult = multipliers[((cmd.response[0] >> 3) & 0xf)]; 907 908 mmc->tran_speed = freq * mult; 909 910 mmc->dsr_imp = ((cmd.response[1] >> 12) & 0x1); 911 mmc->read_bl_len = 1 << ((cmd.response[1] >> 16) & 0xf); 912 913 if (IS_SD(mmc)) 914 mmc->write_bl_len = mmc->read_bl_len; 915 else 916 mmc->write_bl_len = 1 << ((cmd.response[3] >> 22) & 0xf); 917 918 if (mmc->high_capacity) { 919 csize = (mmc->csd[1] & 0x3f) << 16 920 | (mmc->csd[2] & 0xffff0000) >> 16; 921 cmult = 8; 922 } else { 923 csize = (mmc->csd[1] & 0x3ff) << 2 924 | (mmc->csd[2] & 0xc0000000) >> 30; 925 cmult = (mmc->csd[2] & 0x00038000) >> 15; 926 } 927 928 mmc->capacity_user = (csize + 1) << (cmult + 2); 929 mmc->capacity_user *= mmc->read_bl_len; 930 mmc->capacity_boot = 0; 931 mmc->capacity_rpmb = 0; 932 for (i = 0; i < 4; i++) 933 mmc->capacity_gp[i] = 0; 934 935 if (mmc->read_bl_len > MMC_MAX_BLOCK_LEN) 936 mmc->read_bl_len = MMC_MAX_BLOCK_LEN; 937 938 if (mmc->write_bl_len > MMC_MAX_BLOCK_LEN) 939 mmc->write_bl_len = MMC_MAX_BLOCK_LEN; 940 941 if ((mmc->dsr_imp) && (0xffffffff != mmc->dsr)) { 942 cmd.cmdidx = MMC_CMD_SET_DSR; 943 cmd.cmdarg = (mmc->dsr & 0xffff) << 16; 944 cmd.resp_type = MMC_RSP_NONE; 945 if (mmc_send_cmd(mmc, &cmd, NULL)) 946 printf("MMC: SET_DSR failed\n"); 947 } 948 949 /* Select the card, and put it into Transfer Mode */ 950 if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */ 951 cmd.cmdidx = MMC_CMD_SELECT_CARD; 952 cmd.resp_type = MMC_RSP_R1; 953 cmd.cmdarg = mmc->rca << 16; 954 err = mmc_send_cmd(mmc, &cmd, NULL); 955 956 if (err) 957 return err; 958 } 959 960 /* 961 * For SD, its erase group is always one sector 962 */ 963 mmc->erase_grp_size = 1; 964 mmc->part_config = MMCPART_NOAVAILABLE; 965 if (!IS_SD(mmc) && (mmc->version >= MMC_VERSION_4)) { 966 /* check ext_csd version and capacity */ 967 err = mmc_send_ext_csd(mmc, ext_csd); 968 if (!err && (ext_csd[EXT_CSD_REV] >= 2)) { 969 /* 970 * According to the JEDEC Standard, the value of 971 * ext_csd's capacity is valid if the value is more 972 * than 2GB 973 */ 974 capacity = ext_csd[EXT_CSD_SEC_CNT] << 0 975 | ext_csd[EXT_CSD_SEC_CNT + 1] << 8 976 | ext_csd[EXT_CSD_SEC_CNT + 2] << 16 977 | ext_csd[EXT_CSD_SEC_CNT + 3] << 24; 978 capacity *= MMC_MAX_BLOCK_LEN; 979 if ((capacity >> 20) > 2 * 1024) 980 mmc->capacity_user = capacity; 981 } 982 983 switch (ext_csd[EXT_CSD_REV]) { 984 case 1: 985 mmc->version = MMC_VERSION_4_1; 986 break; 987 case 2: 988 mmc->version = MMC_VERSION_4_2; 989 break; 990 case 3: 991 mmc->version = MMC_VERSION_4_3; 992 break; 993 case 5: 994 mmc->version = MMC_VERSION_4_41; 995 break; 996 case 6: 997 mmc->version = MMC_VERSION_4_5; 998 break; 999 } 1000 1001 /* 1002 * Host needs to enable ERASE_GRP_DEF bit if device is 1003 * partitioned. This bit will be lost every time after a reset 1004 * or power off. This will affect erase size. 1005 */ 1006 if ((ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & PART_SUPPORT) && 1007 (ext_csd[EXT_CSD_PARTITIONS_ATTRIBUTE] & PART_ENH_ATTRIB)) { 1008 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 1009 EXT_CSD_ERASE_GROUP_DEF, 1); 1010 1011 if (err) 1012 return err; 1013 else 1014 ext_csd[EXT_CSD_ERASE_GROUP_DEF] = 1; 1015 1016 /* Read out group size from ext_csd */ 1017 mmc->erase_grp_size = 1018 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] * 1019 MMC_MAX_BLOCK_LEN * 1024; 1020 } else { 1021 /* Calculate the group size from the csd value. */ 1022 int erase_gsz, erase_gmul; 1023 erase_gsz = (mmc->csd[2] & 0x00007c00) >> 10; 1024 erase_gmul = (mmc->csd[2] & 0x000003e0) >> 5; 1025 mmc->erase_grp_size = (erase_gsz + 1) 1026 * (erase_gmul + 1); 1027 } 1028 1029 /* store the partition info of emmc */ 1030 if ((ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & PART_SUPPORT) || 1031 ext_csd[EXT_CSD_BOOT_MULT]) 1032 mmc->part_config = ext_csd[EXT_CSD_PART_CONF]; 1033 1034 mmc->capacity_boot = ext_csd[EXT_CSD_BOOT_MULT] << 17; 1035 1036 mmc->capacity_rpmb = ext_csd[EXT_CSD_RPMB_MULT] << 17; 1037 1038 for (i = 0; i < 4; i++) { 1039 int idx = EXT_CSD_GP_SIZE_MULT + i * 3; 1040 mmc->capacity_gp[i] = (ext_csd[idx + 2] << 16) + 1041 (ext_csd[idx + 1] << 8) + ext_csd[idx]; 1042 mmc->capacity_gp[i] *= 1043 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]; 1044 mmc->capacity_gp[i] *= ext_csd[EXT_CSD_HC_WP_GRP_SIZE]; 1045 } 1046 } 1047 1048 err = mmc_set_capacity(mmc, mmc->part_num); 1049 if (err) 1050 return err; 1051 1052 if (IS_SD(mmc)) 1053 err = sd_change_freq(mmc); 1054 else 1055 err = mmc_change_freq(mmc); 1056 1057 if (err) 1058 return err; 1059 1060 /* Restrict card's capabilities by what the host can do */ 1061 mmc->card_caps &= mmc->cfg->host_caps; 1062 1063 if (IS_SD(mmc)) { 1064 if (mmc->card_caps & MMC_MODE_4BIT) { 1065 cmd.cmdidx = MMC_CMD_APP_CMD; 1066 cmd.resp_type = MMC_RSP_R1; 1067 cmd.cmdarg = mmc->rca << 16; 1068 1069 err = mmc_send_cmd(mmc, &cmd, NULL); 1070 if (err) 1071 return err; 1072 1073 cmd.cmdidx = SD_CMD_APP_SET_BUS_WIDTH; 1074 cmd.resp_type = MMC_RSP_R1; 1075 cmd.cmdarg = 2; 1076 err = mmc_send_cmd(mmc, &cmd, NULL); 1077 if (err) 1078 return err; 1079 1080 mmc_set_bus_width(mmc, 4); 1081 } 1082 1083 if (mmc->card_caps & MMC_MODE_HS) 1084 mmc->tran_speed = 50000000; 1085 else 1086 mmc->tran_speed = 25000000; 1087 } else { 1088 int idx; 1089 1090 /* An array of possible bus widths in order of preference */ 1091 static unsigned ext_csd_bits[] = { 1092 EXT_CSD_DDR_BUS_WIDTH_8, 1093 EXT_CSD_DDR_BUS_WIDTH_4, 1094 EXT_CSD_BUS_WIDTH_8, 1095 EXT_CSD_BUS_WIDTH_4, 1096 EXT_CSD_BUS_WIDTH_1, 1097 }; 1098 1099 /* An array to map CSD bus widths to host cap bits */ 1100 static unsigned ext_to_hostcaps[] = { 1101 [EXT_CSD_DDR_BUS_WIDTH_4] = MMC_MODE_DDR_52MHz, 1102 [EXT_CSD_DDR_BUS_WIDTH_8] = MMC_MODE_DDR_52MHz, 1103 [EXT_CSD_BUS_WIDTH_4] = MMC_MODE_4BIT, 1104 [EXT_CSD_BUS_WIDTH_8] = MMC_MODE_8BIT, 1105 }; 1106 1107 /* An array to map chosen bus width to an integer */ 1108 static unsigned widths[] = { 1109 8, 4, 8, 4, 1, 1110 }; 1111 1112 for (idx=0; idx < ARRAY_SIZE(ext_csd_bits); idx++) { 1113 unsigned int extw = ext_csd_bits[idx]; 1114 1115 /* 1116 * Check to make sure the controller supports 1117 * this bus width, if it's more than 1 1118 */ 1119 if (extw != EXT_CSD_BUS_WIDTH_1 && 1120 !(mmc->cfg->host_caps & ext_to_hostcaps[extw])) 1121 continue; 1122 1123 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 1124 EXT_CSD_BUS_WIDTH, extw); 1125 1126 if (err) 1127 continue; 1128 1129 mmc_set_bus_width(mmc, widths[idx]); 1130 1131 err = mmc_send_ext_csd(mmc, test_csd); 1132 if (!err && ext_csd[EXT_CSD_PARTITIONING_SUPPORT] \ 1133 == test_csd[EXT_CSD_PARTITIONING_SUPPORT] 1134 && ext_csd[EXT_CSD_ERASE_GROUP_DEF] \ 1135 == test_csd[EXT_CSD_ERASE_GROUP_DEF] \ 1136 && ext_csd[EXT_CSD_REV] \ 1137 == test_csd[EXT_CSD_REV] 1138 && ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] \ 1139 == test_csd[EXT_CSD_HC_ERASE_GRP_SIZE] 1140 && memcmp(&ext_csd[EXT_CSD_SEC_CNT], \ 1141 &test_csd[EXT_CSD_SEC_CNT], 4) == 0) { 1142 1143 mmc->card_caps |= ext_to_hostcaps[extw]; 1144 break; 1145 } 1146 } 1147 1148 if (mmc->card_caps & MMC_MODE_HS) { 1149 if (mmc->card_caps & MMC_MODE_HS_52MHz) 1150 mmc->tran_speed = 52000000; 1151 else 1152 mmc->tran_speed = 26000000; 1153 } 1154 } 1155 1156 mmc_set_clock(mmc, mmc->tran_speed); 1157 1158 /* fill in device description */ 1159 mmc->block_dev.lun = 0; 1160 mmc->block_dev.type = 0; 1161 mmc->block_dev.blksz = mmc->read_bl_len; 1162 mmc->block_dev.log2blksz = LOG2(mmc->block_dev.blksz); 1163 mmc->block_dev.lba = lldiv(mmc->capacity, mmc->read_bl_len); 1164 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 1165 sprintf(mmc->block_dev.vendor, "Man %06x Snr %04x%04x", 1166 mmc->cid[0] >> 24, (mmc->cid[2] & 0xffff), 1167 (mmc->cid[3] >> 16) & 0xffff); 1168 sprintf(mmc->block_dev.product, "%c%c%c%c%c%c", mmc->cid[0] & 0xff, 1169 (mmc->cid[1] >> 24), (mmc->cid[1] >> 16) & 0xff, 1170 (mmc->cid[1] >> 8) & 0xff, mmc->cid[1] & 0xff, 1171 (mmc->cid[2] >> 24) & 0xff); 1172 sprintf(mmc->block_dev.revision, "%d.%d", (mmc->cid[2] >> 20) & 0xf, 1173 (mmc->cid[2] >> 16) & 0xf); 1174 #else 1175 mmc->block_dev.vendor[0] = 0; 1176 mmc->block_dev.product[0] = 0; 1177 mmc->block_dev.revision[0] = 0; 1178 #endif 1179 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBDISK_SUPPORT) 1180 init_part(&mmc->block_dev); 1181 #endif 1182 1183 return 0; 1184 } 1185 1186 static int mmc_send_if_cond(struct mmc *mmc) 1187 { 1188 struct mmc_cmd cmd; 1189 int err; 1190 1191 cmd.cmdidx = SD_CMD_SEND_IF_COND; 1192 /* We set the bit if the host supports voltages between 2.7 and 3.6 V */ 1193 cmd.cmdarg = ((mmc->cfg->voltages & 0xff8000) != 0) << 8 | 0xaa; 1194 cmd.resp_type = MMC_RSP_R7; 1195 1196 err = mmc_send_cmd(mmc, &cmd, NULL); 1197 1198 if (err) 1199 return err; 1200 1201 if ((cmd.response[0] & 0xff) != 0xaa) 1202 return UNUSABLE_ERR; 1203 else 1204 mmc->version = SD_VERSION_2; 1205 1206 return 0; 1207 } 1208 1209 /* not used any more */ 1210 int __deprecated mmc_register(struct mmc *mmc) 1211 { 1212 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 1213 printf("%s is deprecated! use mmc_create() instead.\n", __func__); 1214 #endif 1215 return -1; 1216 } 1217 1218 struct mmc *mmc_create(const struct mmc_config *cfg, void *priv) 1219 { 1220 struct mmc *mmc; 1221 1222 /* quick validation */ 1223 if (cfg == NULL || cfg->ops == NULL || cfg->ops->send_cmd == NULL || 1224 cfg->f_min == 0 || cfg->f_max == 0 || cfg->b_max == 0) 1225 return NULL; 1226 1227 mmc = calloc(1, sizeof(*mmc)); 1228 if (mmc == NULL) 1229 return NULL; 1230 1231 mmc->cfg = cfg; 1232 mmc->priv = priv; 1233 1234 /* the following chunk was mmc_register() */ 1235 1236 /* Setup dsr related values */ 1237 mmc->dsr_imp = 0; 1238 mmc->dsr = 0xffffffff; 1239 /* Setup the universal parts of the block interface just once */ 1240 mmc->block_dev.if_type = IF_TYPE_MMC; 1241 mmc->block_dev.dev = cur_dev_num++; 1242 mmc->block_dev.removable = 1; 1243 mmc->block_dev.block_read = mmc_bread; 1244 mmc->block_dev.block_write = mmc_bwrite; 1245 mmc->block_dev.block_erase = mmc_berase; 1246 1247 /* setup initial part type */ 1248 mmc->block_dev.part_type = mmc->cfg->part_type; 1249 1250 INIT_LIST_HEAD(&mmc->link); 1251 1252 list_add_tail(&mmc->link, &mmc_devices); 1253 1254 return mmc; 1255 } 1256 1257 void mmc_destroy(struct mmc *mmc) 1258 { 1259 /* only freeing memory for now */ 1260 free(mmc); 1261 } 1262 1263 #ifdef CONFIG_PARTITIONS 1264 block_dev_desc_t *mmc_get_dev(int dev) 1265 { 1266 struct mmc *mmc = find_mmc_device(dev); 1267 if (!mmc || mmc_init(mmc)) 1268 return NULL; 1269 1270 return &mmc->block_dev; 1271 } 1272 #endif 1273 1274 int mmc_start_init(struct mmc *mmc) 1275 { 1276 int err; 1277 1278 /* we pretend there's no card when init is NULL */ 1279 if (mmc_getcd(mmc) == 0 || mmc->cfg->ops->init == NULL) { 1280 mmc->has_init = 0; 1281 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 1282 printf("MMC: no card present\n"); 1283 #endif 1284 return NO_CARD_ERR; 1285 } 1286 1287 if (mmc->has_init) 1288 return 0; 1289 1290 /* made sure it's not NULL earlier */ 1291 err = mmc->cfg->ops->init(mmc); 1292 1293 if (err) 1294 return err; 1295 1296 mmc_set_bus_width(mmc, 1); 1297 mmc_set_clock(mmc, 1); 1298 1299 /* Reset the Card */ 1300 err = mmc_go_idle(mmc); 1301 1302 if (err) 1303 return err; 1304 1305 /* The internal partition reset to user partition(0) at every CMD0*/ 1306 mmc->part_num = 0; 1307 1308 /* Test for SD version 2 */ 1309 err = mmc_send_if_cond(mmc); 1310 1311 /* Now try to get the SD card's operating condition */ 1312 err = sd_send_op_cond(mmc); 1313 1314 /* If the command timed out, we check for an MMC card */ 1315 if (err == TIMEOUT) { 1316 err = mmc_send_op_cond(mmc); 1317 1318 if (err && err != IN_PROGRESS) { 1319 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 1320 printf("Card did not respond to voltage select!\n"); 1321 #endif 1322 return UNUSABLE_ERR; 1323 } 1324 } 1325 1326 if (err == IN_PROGRESS) 1327 mmc->init_in_progress = 1; 1328 1329 return err; 1330 } 1331 1332 static int mmc_complete_init(struct mmc *mmc) 1333 { 1334 int err = 0; 1335 1336 if (mmc->op_cond_pending) 1337 err = mmc_complete_op_cond(mmc); 1338 1339 if (!err) 1340 err = mmc_startup(mmc); 1341 if (err) 1342 mmc->has_init = 0; 1343 else 1344 mmc->has_init = 1; 1345 mmc->init_in_progress = 0; 1346 return err; 1347 } 1348 1349 int mmc_init(struct mmc *mmc) 1350 { 1351 int err = IN_PROGRESS; 1352 unsigned start; 1353 1354 if (mmc->has_init) 1355 return 0; 1356 1357 start = get_timer(0); 1358 1359 if (!mmc->init_in_progress) 1360 err = mmc_start_init(mmc); 1361 1362 if (!err || err == IN_PROGRESS) 1363 err = mmc_complete_init(mmc); 1364 debug("%s: %d, time %lu\n", __func__, err, get_timer(start)); 1365 return err; 1366 } 1367 1368 int mmc_set_dsr(struct mmc *mmc, u16 val) 1369 { 1370 mmc->dsr = val; 1371 return 0; 1372 } 1373 1374 /* CPU-specific MMC initializations */ 1375 __weak int cpu_mmc_init(bd_t *bis) 1376 { 1377 return -1; 1378 } 1379 1380 /* board-specific MMC initializations. */ 1381 __weak int board_mmc_init(bd_t *bis) 1382 { 1383 return -1; 1384 } 1385 1386 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 1387 1388 void print_mmc_devices(char separator) 1389 { 1390 struct mmc *m; 1391 struct list_head *entry; 1392 1393 list_for_each(entry, &mmc_devices) { 1394 m = list_entry(entry, struct mmc, link); 1395 1396 printf("%s: %d", m->cfg->name, m->block_dev.dev); 1397 1398 if (entry->next != &mmc_devices) 1399 printf("%c ", separator); 1400 } 1401 1402 printf("\n"); 1403 } 1404 1405 #else 1406 void print_mmc_devices(char separator) { } 1407 #endif 1408 1409 int get_mmc_num(void) 1410 { 1411 return cur_dev_num; 1412 } 1413 1414 void mmc_set_preinit(struct mmc *mmc, int preinit) 1415 { 1416 mmc->preinit = preinit; 1417 } 1418 1419 static void do_preinit(void) 1420 { 1421 struct mmc *m; 1422 struct list_head *entry; 1423 1424 list_for_each(entry, &mmc_devices) { 1425 m = list_entry(entry, struct mmc, link); 1426 1427 if (m->preinit) 1428 mmc_start_init(m); 1429 } 1430 } 1431 1432 1433 int mmc_initialize(bd_t *bis) 1434 { 1435 INIT_LIST_HEAD (&mmc_devices); 1436 cur_dev_num = 0; 1437 1438 if (board_mmc_init(bis) < 0) 1439 cpu_mmc_init(bis); 1440 1441 #ifndef CONFIG_SPL_BUILD 1442 print_mmc_devices(','); 1443 #endif 1444 1445 do_preinit(); 1446 return 0; 1447 } 1448 1449 #ifdef CONFIG_SUPPORT_EMMC_BOOT 1450 /* 1451 * This function changes the size of boot partition and the size of rpmb 1452 * partition present on EMMC devices. 1453 * 1454 * Input Parameters: 1455 * struct *mmc: pointer for the mmc device strcuture 1456 * bootsize: size of boot partition 1457 * rpmbsize: size of rpmb partition 1458 * 1459 * Returns 0 on success. 1460 */ 1461 1462 int mmc_boot_partition_size_change(struct mmc *mmc, unsigned long bootsize, 1463 unsigned long rpmbsize) 1464 { 1465 int err; 1466 struct mmc_cmd cmd; 1467 1468 /* Only use this command for raw EMMC moviNAND. Enter backdoor mode */ 1469 cmd.cmdidx = MMC_CMD_RES_MAN; 1470 cmd.resp_type = MMC_RSP_R1b; 1471 cmd.cmdarg = MMC_CMD62_ARG1; 1472 1473 err = mmc_send_cmd(mmc, &cmd, NULL); 1474 if (err) { 1475 debug("mmc_boot_partition_size_change: Error1 = %d\n", err); 1476 return err; 1477 } 1478 1479 /* Boot partition changing mode */ 1480 cmd.cmdidx = MMC_CMD_RES_MAN; 1481 cmd.resp_type = MMC_RSP_R1b; 1482 cmd.cmdarg = MMC_CMD62_ARG2; 1483 1484 err = mmc_send_cmd(mmc, &cmd, NULL); 1485 if (err) { 1486 debug("mmc_boot_partition_size_change: Error2 = %d\n", err); 1487 return err; 1488 } 1489 /* boot partition size is multiple of 128KB */ 1490 bootsize = (bootsize * 1024) / 128; 1491 1492 /* Arg: boot partition size */ 1493 cmd.cmdidx = MMC_CMD_RES_MAN; 1494 cmd.resp_type = MMC_RSP_R1b; 1495 cmd.cmdarg = bootsize; 1496 1497 err = mmc_send_cmd(mmc, &cmd, NULL); 1498 if (err) { 1499 debug("mmc_boot_partition_size_change: Error3 = %d\n", err); 1500 return err; 1501 } 1502 /* RPMB partition size is multiple of 128KB */ 1503 rpmbsize = (rpmbsize * 1024) / 128; 1504 /* Arg: RPMB partition size */ 1505 cmd.cmdidx = MMC_CMD_RES_MAN; 1506 cmd.resp_type = MMC_RSP_R1b; 1507 cmd.cmdarg = rpmbsize; 1508 1509 err = mmc_send_cmd(mmc, &cmd, NULL); 1510 if (err) { 1511 debug("mmc_boot_partition_size_change: Error4 = %d\n", err); 1512 return err; 1513 } 1514 return 0; 1515 } 1516 1517 /* 1518 * Modify EXT_CSD[177] which is BOOT_BUS_WIDTH 1519 * based on the passed in values for BOOT_BUS_WIDTH, RESET_BOOT_BUS_WIDTH 1520 * and BOOT_MODE. 1521 * 1522 * Returns 0 on success. 1523 */ 1524 int mmc_set_boot_bus_width(struct mmc *mmc, u8 width, u8 reset, u8 mode) 1525 { 1526 int err; 1527 1528 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_BOOT_BUS_WIDTH, 1529 EXT_CSD_BOOT_BUS_WIDTH_MODE(mode) | 1530 EXT_CSD_BOOT_BUS_WIDTH_RESET(reset) | 1531 EXT_CSD_BOOT_BUS_WIDTH_WIDTH(width)); 1532 1533 if (err) 1534 return err; 1535 return 0; 1536 } 1537 1538 /* 1539 * Modify EXT_CSD[179] which is PARTITION_CONFIG (formerly BOOT_CONFIG) 1540 * based on the passed in values for BOOT_ACK, BOOT_PARTITION_ENABLE and 1541 * PARTITION_ACCESS. 1542 * 1543 * Returns 0 on success. 1544 */ 1545 int mmc_set_part_conf(struct mmc *mmc, u8 ack, u8 part_num, u8 access) 1546 { 1547 int err; 1548 1549 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONF, 1550 EXT_CSD_BOOT_ACK(ack) | 1551 EXT_CSD_BOOT_PART_NUM(part_num) | 1552 EXT_CSD_PARTITION_ACCESS(access)); 1553 1554 if (err) 1555 return err; 1556 return 0; 1557 } 1558 1559 /* 1560 * Modify EXT_CSD[162] which is RST_n_FUNCTION based on the given value 1561 * for enable. Note that this is a write-once field for non-zero values. 1562 * 1563 * Returns 0 on success. 1564 */ 1565 int mmc_set_rst_n_function(struct mmc *mmc, u8 enable) 1566 { 1567 return mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_RST_N_FUNCTION, 1568 enable); 1569 } 1570 #endif 1571