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 int __weak 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 int __board_mmc_getcd(struct mmc *mmc) { 46 return -1; 47 } 48 49 int board_mmc_getcd(struct mmc *mmc)__attribute__((weak, 50 alias("__board_mmc_getcd"))); 51 52 int mmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data) 53 { 54 int ret; 55 56 #ifdef CONFIG_MMC_TRACE 57 int i; 58 u8 *ptr; 59 60 printf("CMD_SEND:%d\n", cmd->cmdidx); 61 printf("\t\tARG\t\t\t 0x%08X\n", cmd->cmdarg); 62 ret = mmc->cfg->ops->send_cmd(mmc, cmd, data); 63 switch (cmd->resp_type) { 64 case MMC_RSP_NONE: 65 printf("\t\tMMC_RSP_NONE\n"); 66 break; 67 case MMC_RSP_R1: 68 printf("\t\tMMC_RSP_R1,5,6,7 \t 0x%08X \n", 69 cmd->response[0]); 70 break; 71 case MMC_RSP_R1b: 72 printf("\t\tMMC_RSP_R1b\t\t 0x%08X \n", 73 cmd->response[0]); 74 break; 75 case MMC_RSP_R2: 76 printf("\t\tMMC_RSP_R2\t\t 0x%08X \n", 77 cmd->response[0]); 78 printf("\t\t \t\t 0x%08X \n", 79 cmd->response[1]); 80 printf("\t\t \t\t 0x%08X \n", 81 cmd->response[2]); 82 printf("\t\t \t\t 0x%08X \n", 83 cmd->response[3]); 84 printf("\n"); 85 printf("\t\t\t\t\tDUMPING DATA\n"); 86 for (i = 0; i < 4; i++) { 87 int j; 88 printf("\t\t\t\t\t%03d - ", i*4); 89 ptr = (u8 *)&cmd->response[i]; 90 ptr += 3; 91 for (j = 0; j < 4; j++) 92 printf("%02X ", *ptr--); 93 printf("\n"); 94 } 95 break; 96 case MMC_RSP_R3: 97 printf("\t\tMMC_RSP_R3,4\t\t 0x%08X \n", 98 cmd->response[0]); 99 break; 100 default: 101 printf("\t\tERROR MMC rsp not supported\n"); 102 break; 103 } 104 #else 105 ret = mmc->cfg->ops->send_cmd(mmc, cmd, data); 106 #endif 107 return ret; 108 } 109 110 int mmc_send_status(struct mmc *mmc, int timeout) 111 { 112 struct mmc_cmd cmd; 113 int err, retries = 5; 114 #ifdef CONFIG_MMC_TRACE 115 int status; 116 #endif 117 118 cmd.cmdidx = MMC_CMD_SEND_STATUS; 119 cmd.resp_type = MMC_RSP_R1; 120 if (!mmc_host_is_spi(mmc)) 121 cmd.cmdarg = mmc->rca << 16; 122 123 do { 124 err = mmc_send_cmd(mmc, &cmd, NULL); 125 if (!err) { 126 if ((cmd.response[0] & MMC_STATUS_RDY_FOR_DATA) && 127 (cmd.response[0] & MMC_STATUS_CURR_STATE) != 128 MMC_STATE_PRG) 129 break; 130 else if (cmd.response[0] & MMC_STATUS_MASK) { 131 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 132 printf("Status Error: 0x%08X\n", 133 cmd.response[0]); 134 #endif 135 return COMM_ERR; 136 } 137 } else if (--retries < 0) 138 return err; 139 140 udelay(1000); 141 142 } while (timeout--); 143 144 #ifdef CONFIG_MMC_TRACE 145 status = (cmd.response[0] & MMC_STATUS_CURR_STATE) >> 9; 146 printf("CURR STATE:%d\n", status); 147 #endif 148 if (timeout <= 0) { 149 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 150 printf("Timeout waiting card ready\n"); 151 #endif 152 return TIMEOUT; 153 } 154 if (cmd.response[0] & MMC_STATUS_SWITCH_ERROR) 155 return SWITCH_ERR; 156 157 return 0; 158 } 159 160 int mmc_set_blocklen(struct mmc *mmc, int len) 161 { 162 struct mmc_cmd cmd; 163 164 if (mmc->card_caps & MMC_MODE_DDR_52MHz) 165 return 0; 166 167 cmd.cmdidx = MMC_CMD_SET_BLOCKLEN; 168 cmd.resp_type = MMC_RSP_R1; 169 cmd.cmdarg = len; 170 171 return mmc_send_cmd(mmc, &cmd, NULL); 172 } 173 174 struct mmc *find_mmc_device(int dev_num) 175 { 176 struct mmc *m; 177 struct list_head *entry; 178 179 list_for_each(entry, &mmc_devices) { 180 m = list_entry(entry, struct mmc, link); 181 182 if (m->block_dev.dev == dev_num) 183 return m; 184 } 185 186 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 187 printf("MMC Device %d not found\n", dev_num); 188 #endif 189 190 return NULL; 191 } 192 193 static int mmc_read_blocks(struct mmc *mmc, void *dst, lbaint_t start, 194 lbaint_t blkcnt) 195 { 196 struct mmc_cmd cmd; 197 struct mmc_data data; 198 199 if (blkcnt > 1) 200 cmd.cmdidx = MMC_CMD_READ_MULTIPLE_BLOCK; 201 else 202 cmd.cmdidx = MMC_CMD_READ_SINGLE_BLOCK; 203 204 if (mmc->high_capacity) 205 cmd.cmdarg = start; 206 else 207 cmd.cmdarg = start * mmc->read_bl_len; 208 209 cmd.resp_type = MMC_RSP_R1; 210 211 data.dest = dst; 212 data.blocks = blkcnt; 213 data.blocksize = mmc->read_bl_len; 214 data.flags = MMC_DATA_READ; 215 216 if (mmc_send_cmd(mmc, &cmd, &data)) 217 return 0; 218 219 if (blkcnt > 1) { 220 cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION; 221 cmd.cmdarg = 0; 222 cmd.resp_type = MMC_RSP_R1b; 223 if (mmc_send_cmd(mmc, &cmd, NULL)) { 224 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 225 printf("mmc fail to send stop cmd\n"); 226 #endif 227 return 0; 228 } 229 } 230 231 return blkcnt; 232 } 233 234 static ulong mmc_bread(int dev_num, lbaint_t start, lbaint_t blkcnt, void *dst) 235 { 236 lbaint_t cur, blocks_todo = blkcnt; 237 238 if (blkcnt == 0) 239 return 0; 240 241 struct mmc *mmc = find_mmc_device(dev_num); 242 if (!mmc) 243 return 0; 244 245 if ((start + blkcnt) > mmc->block_dev.lba) { 246 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 247 printf("MMC: block number 0x" LBAF " exceeds max(0x" LBAF ")\n", 248 start + blkcnt, mmc->block_dev.lba); 249 #endif 250 return 0; 251 } 252 253 if (mmc_set_blocklen(mmc, mmc->read_bl_len)) 254 return 0; 255 256 do { 257 cur = (blocks_todo > mmc->cfg->b_max) ? 258 mmc->cfg->b_max : blocks_todo; 259 if(mmc_read_blocks(mmc, dst, start, cur) != cur) 260 return 0; 261 blocks_todo -= cur; 262 start += cur; 263 dst += cur * mmc->read_bl_len; 264 } while (blocks_todo > 0); 265 266 return blkcnt; 267 } 268 269 static int mmc_go_idle(struct mmc *mmc) 270 { 271 struct mmc_cmd cmd; 272 int err; 273 274 udelay(1000); 275 276 cmd.cmdidx = MMC_CMD_GO_IDLE_STATE; 277 cmd.cmdarg = 0; 278 cmd.resp_type = MMC_RSP_NONE; 279 280 err = mmc_send_cmd(mmc, &cmd, NULL); 281 282 if (err) 283 return err; 284 285 udelay(2000); 286 287 return 0; 288 } 289 290 static int sd_send_op_cond(struct mmc *mmc) 291 { 292 int timeout = 1000; 293 int err; 294 struct mmc_cmd cmd; 295 296 do { 297 cmd.cmdidx = MMC_CMD_APP_CMD; 298 cmd.resp_type = MMC_RSP_R1; 299 cmd.cmdarg = 0; 300 301 err = mmc_send_cmd(mmc, &cmd, NULL); 302 303 if (err) 304 return err; 305 306 cmd.cmdidx = SD_CMD_APP_SEND_OP_COND; 307 cmd.resp_type = MMC_RSP_R3; 308 309 /* 310 * Most cards do not answer if some reserved bits 311 * in the ocr are set. However, Some controller 312 * can set bit 7 (reserved for low voltages), but 313 * how to manage low voltages SD card is not yet 314 * specified. 315 */ 316 cmd.cmdarg = mmc_host_is_spi(mmc) ? 0 : 317 (mmc->cfg->voltages & 0xff8000); 318 319 if (mmc->version == SD_VERSION_2) 320 cmd.cmdarg |= OCR_HCS; 321 322 err = mmc_send_cmd(mmc, &cmd, NULL); 323 324 if (err) 325 return err; 326 327 udelay(1000); 328 } while ((!(cmd.response[0] & OCR_BUSY)) && timeout--); 329 330 if (timeout <= 0) 331 return UNUSABLE_ERR; 332 333 if (mmc->version != SD_VERSION_2) 334 mmc->version = SD_VERSION_1_0; 335 336 if (mmc_host_is_spi(mmc)) { /* read OCR for spi */ 337 cmd.cmdidx = MMC_CMD_SPI_READ_OCR; 338 cmd.resp_type = MMC_RSP_R3; 339 cmd.cmdarg = 0; 340 341 err = mmc_send_cmd(mmc, &cmd, NULL); 342 343 if (err) 344 return err; 345 } 346 347 mmc->ocr = cmd.response[0]; 348 349 mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS); 350 mmc->rca = 0; 351 352 return 0; 353 } 354 355 /* We pass in the cmd since otherwise the init seems to fail */ 356 static int mmc_send_op_cond_iter(struct mmc *mmc, struct mmc_cmd *cmd, 357 int use_arg) 358 { 359 int err; 360 361 cmd->cmdidx = MMC_CMD_SEND_OP_COND; 362 cmd->resp_type = MMC_RSP_R3; 363 cmd->cmdarg = 0; 364 if (use_arg && !mmc_host_is_spi(mmc)) { 365 cmd->cmdarg = 366 (mmc->cfg->voltages & 367 (mmc->op_cond_response & OCR_VOLTAGE_MASK)) | 368 (mmc->op_cond_response & OCR_ACCESS_MODE); 369 370 if (mmc->cfg->host_caps & MMC_MODE_HC) 371 cmd->cmdarg |= OCR_HCS; 372 } 373 err = mmc_send_cmd(mmc, cmd, NULL); 374 if (err) 375 return err; 376 mmc->op_cond_response = cmd->response[0]; 377 return 0; 378 } 379 380 int mmc_send_op_cond(struct mmc *mmc) 381 { 382 struct mmc_cmd cmd; 383 int err, i; 384 385 /* Some cards seem to need this */ 386 mmc_go_idle(mmc); 387 388 /* Asking to the card its capabilities */ 389 mmc->op_cond_pending = 1; 390 for (i = 0; i < 2; i++) { 391 err = mmc_send_op_cond_iter(mmc, &cmd, i != 0); 392 if (err) 393 return err; 394 395 /* exit if not busy (flag seems to be inverted) */ 396 if (mmc->op_cond_response & OCR_BUSY) 397 return 0; 398 } 399 return IN_PROGRESS; 400 } 401 402 int mmc_complete_op_cond(struct mmc *mmc) 403 { 404 struct mmc_cmd cmd; 405 int timeout = 1000; 406 uint start; 407 int err; 408 409 mmc->op_cond_pending = 0; 410 start = get_timer(0); 411 do { 412 err = mmc_send_op_cond_iter(mmc, &cmd, 1); 413 if (err) 414 return err; 415 if (get_timer(start) > timeout) 416 return UNUSABLE_ERR; 417 udelay(100); 418 } while (!(mmc->op_cond_response & OCR_BUSY)); 419 420 if (mmc_host_is_spi(mmc)) { /* read OCR for spi */ 421 cmd.cmdidx = MMC_CMD_SPI_READ_OCR; 422 cmd.resp_type = MMC_RSP_R3; 423 cmd.cmdarg = 0; 424 425 err = mmc_send_cmd(mmc, &cmd, NULL); 426 427 if (err) 428 return err; 429 } 430 431 mmc->version = MMC_VERSION_UNKNOWN; 432 mmc->ocr = cmd.response[0]; 433 434 mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS); 435 mmc->rca = 1; 436 437 return 0; 438 } 439 440 441 static int mmc_send_ext_csd(struct mmc *mmc, u8 *ext_csd) 442 { 443 struct mmc_cmd cmd; 444 struct mmc_data data; 445 int err; 446 447 /* Get the Card Status Register */ 448 cmd.cmdidx = MMC_CMD_SEND_EXT_CSD; 449 cmd.resp_type = MMC_RSP_R1; 450 cmd.cmdarg = 0; 451 452 data.dest = (char *)ext_csd; 453 data.blocks = 1; 454 data.blocksize = MMC_MAX_BLOCK_LEN; 455 data.flags = MMC_DATA_READ; 456 457 err = mmc_send_cmd(mmc, &cmd, &data); 458 459 return err; 460 } 461 462 463 static int mmc_switch(struct mmc *mmc, u8 set, u8 index, u8 value) 464 { 465 struct mmc_cmd cmd; 466 int timeout = 1000; 467 int ret; 468 469 cmd.cmdidx = MMC_CMD_SWITCH; 470 cmd.resp_type = MMC_RSP_R1b; 471 cmd.cmdarg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) | 472 (index << 16) | 473 (value << 8); 474 475 ret = mmc_send_cmd(mmc, &cmd, NULL); 476 477 /* Waiting for the ready status */ 478 if (!ret) 479 ret = mmc_send_status(mmc, timeout); 480 481 return ret; 482 483 } 484 485 static int mmc_change_freq(struct mmc *mmc) 486 { 487 ALLOC_CACHE_ALIGN_BUFFER(u8, ext_csd, MMC_MAX_BLOCK_LEN); 488 char cardtype; 489 int err; 490 491 mmc->card_caps = 0; 492 493 if (mmc_host_is_spi(mmc)) 494 return 0; 495 496 /* Only version 4 supports high-speed */ 497 if (mmc->version < MMC_VERSION_4) 498 return 0; 499 500 err = mmc_send_ext_csd(mmc, ext_csd); 501 502 if (err) 503 return err; 504 505 cardtype = ext_csd[EXT_CSD_CARD_TYPE] & 0xf; 506 507 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING, 1); 508 509 if (err) 510 return err == SWITCH_ERR ? 0 : err; 511 512 /* Now check to see that it worked */ 513 err = mmc_send_ext_csd(mmc, ext_csd); 514 515 if (err) 516 return err; 517 518 /* No high-speed support */ 519 if (!ext_csd[EXT_CSD_HS_TIMING]) 520 return 0; 521 522 /* High Speed is set, there are two types: 52MHz and 26MHz */ 523 if (cardtype & EXT_CSD_CARD_TYPE_52) { 524 if (cardtype & EXT_CSD_CARD_TYPE_DDR_52) 525 mmc->card_caps |= MMC_MODE_DDR_52MHz; 526 mmc->card_caps |= MMC_MODE_HS_52MHz | MMC_MODE_HS; 527 } else { 528 mmc->card_caps |= MMC_MODE_HS; 529 } 530 531 return 0; 532 } 533 534 static int mmc_set_capacity(struct mmc *mmc, int part_num) 535 { 536 switch (part_num) { 537 case 0: 538 mmc->capacity = mmc->capacity_user; 539 break; 540 case 1: 541 case 2: 542 mmc->capacity = mmc->capacity_boot; 543 break; 544 case 3: 545 mmc->capacity = mmc->capacity_rpmb; 546 break; 547 case 4: 548 case 5: 549 case 6: 550 case 7: 551 mmc->capacity = mmc->capacity_gp[part_num - 4]; 552 break; 553 default: 554 return -1; 555 } 556 557 mmc->block_dev.lba = lldiv(mmc->capacity, mmc->read_bl_len); 558 559 return 0; 560 } 561 562 int mmc_select_hwpart(int dev_num, int hwpart) 563 { 564 struct mmc *mmc = find_mmc_device(dev_num); 565 int ret; 566 567 if (!mmc) 568 return -ENODEV; 569 570 if (mmc->part_num == hwpart) 571 return 0; 572 573 if (mmc->part_config == MMCPART_NOAVAILABLE) { 574 printf("Card doesn't support part_switch\n"); 575 return -EMEDIUMTYPE; 576 } 577 578 ret = mmc_switch_part(dev_num, hwpart); 579 if (ret) 580 return ret; 581 582 mmc->part_num = hwpart; 583 584 return 0; 585 } 586 587 588 int mmc_switch_part(int dev_num, unsigned int part_num) 589 { 590 struct mmc *mmc = find_mmc_device(dev_num); 591 int ret; 592 593 if (!mmc) 594 return -1; 595 596 ret = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONF, 597 (mmc->part_config & ~PART_ACCESS_MASK) 598 | (part_num & PART_ACCESS_MASK)); 599 if (ret) 600 return ret; 601 602 return mmc_set_capacity(mmc, part_num); 603 } 604 605 int mmc_getcd(struct mmc *mmc) 606 { 607 int cd; 608 609 cd = board_mmc_getcd(mmc); 610 611 if (cd < 0) { 612 if (mmc->cfg->ops->getcd) 613 cd = mmc->cfg->ops->getcd(mmc); 614 else 615 cd = 1; 616 } 617 618 return cd; 619 } 620 621 static int sd_switch(struct mmc *mmc, int mode, int group, u8 value, u8 *resp) 622 { 623 struct mmc_cmd cmd; 624 struct mmc_data data; 625 626 /* Switch the frequency */ 627 cmd.cmdidx = SD_CMD_SWITCH_FUNC; 628 cmd.resp_type = MMC_RSP_R1; 629 cmd.cmdarg = (mode << 31) | 0xffffff; 630 cmd.cmdarg &= ~(0xf << (group * 4)); 631 cmd.cmdarg |= value << (group * 4); 632 633 data.dest = (char *)resp; 634 data.blocksize = 64; 635 data.blocks = 1; 636 data.flags = MMC_DATA_READ; 637 638 return mmc_send_cmd(mmc, &cmd, &data); 639 } 640 641 642 static int sd_change_freq(struct mmc *mmc) 643 { 644 int err; 645 struct mmc_cmd cmd; 646 ALLOC_CACHE_ALIGN_BUFFER(uint, scr, 2); 647 ALLOC_CACHE_ALIGN_BUFFER(uint, switch_status, 16); 648 struct mmc_data data; 649 int timeout; 650 651 mmc->card_caps = 0; 652 653 if (mmc_host_is_spi(mmc)) 654 return 0; 655 656 /* Read the SCR to find out if this card supports higher speeds */ 657 cmd.cmdidx = MMC_CMD_APP_CMD; 658 cmd.resp_type = MMC_RSP_R1; 659 cmd.cmdarg = mmc->rca << 16; 660 661 err = mmc_send_cmd(mmc, &cmd, NULL); 662 663 if (err) 664 return err; 665 666 cmd.cmdidx = SD_CMD_APP_SEND_SCR; 667 cmd.resp_type = MMC_RSP_R1; 668 cmd.cmdarg = 0; 669 670 timeout = 3; 671 672 retry_scr: 673 data.dest = (char *)scr; 674 data.blocksize = 8; 675 data.blocks = 1; 676 data.flags = MMC_DATA_READ; 677 678 err = mmc_send_cmd(mmc, &cmd, &data); 679 680 if (err) { 681 if (timeout--) 682 goto retry_scr; 683 684 return err; 685 } 686 687 mmc->scr[0] = __be32_to_cpu(scr[0]); 688 mmc->scr[1] = __be32_to_cpu(scr[1]); 689 690 switch ((mmc->scr[0] >> 24) & 0xf) { 691 case 0: 692 mmc->version = SD_VERSION_1_0; 693 break; 694 case 1: 695 mmc->version = SD_VERSION_1_10; 696 break; 697 case 2: 698 mmc->version = SD_VERSION_2; 699 if ((mmc->scr[0] >> 15) & 0x1) 700 mmc->version = SD_VERSION_3; 701 break; 702 default: 703 mmc->version = SD_VERSION_1_0; 704 break; 705 } 706 707 if (mmc->scr[0] & SD_DATA_4BIT) 708 mmc->card_caps |= MMC_MODE_4BIT; 709 710 /* Version 1.0 doesn't support switching */ 711 if (mmc->version == SD_VERSION_1_0) 712 return 0; 713 714 timeout = 4; 715 while (timeout--) { 716 err = sd_switch(mmc, SD_SWITCH_CHECK, 0, 1, 717 (u8 *)switch_status); 718 719 if (err) 720 return err; 721 722 /* The high-speed function is busy. Try again */ 723 if (!(__be32_to_cpu(switch_status[7]) & SD_HIGHSPEED_BUSY)) 724 break; 725 } 726 727 /* If high-speed isn't supported, we return */ 728 if (!(__be32_to_cpu(switch_status[3]) & SD_HIGHSPEED_SUPPORTED)) 729 return 0; 730 731 /* 732 * If the host doesn't support SD_HIGHSPEED, do not switch card to 733 * HIGHSPEED mode even if the card support SD_HIGHSPPED. 734 * This can avoid furthur problem when the card runs in different 735 * mode between the host. 736 */ 737 if (!((mmc->cfg->host_caps & MMC_MODE_HS_52MHz) && 738 (mmc->cfg->host_caps & MMC_MODE_HS))) 739 return 0; 740 741 err = sd_switch(mmc, SD_SWITCH_SWITCH, 0, 1, (u8 *)switch_status); 742 743 if (err) 744 return err; 745 746 if ((__be32_to_cpu(switch_status[4]) & 0x0f000000) == 0x01000000) 747 mmc->card_caps |= MMC_MODE_HS; 748 749 return 0; 750 } 751 752 /* frequency bases */ 753 /* divided by 10 to be nice to platforms without floating point */ 754 static const int fbase[] = { 755 10000, 756 100000, 757 1000000, 758 10000000, 759 }; 760 761 /* Multiplier values for TRAN_SPEED. Multiplied by 10 to be nice 762 * to platforms without floating point. 763 */ 764 static const int multipliers[] = { 765 0, /* reserved */ 766 10, 767 12, 768 13, 769 15, 770 20, 771 25, 772 30, 773 35, 774 40, 775 45, 776 50, 777 55, 778 60, 779 70, 780 80, 781 }; 782 783 static void mmc_set_ios(struct mmc *mmc) 784 { 785 if (mmc->cfg->ops->set_ios) 786 mmc->cfg->ops->set_ios(mmc); 787 } 788 789 void mmc_set_clock(struct mmc *mmc, uint clock) 790 { 791 if (clock > mmc->cfg->f_max) 792 clock = mmc->cfg->f_max; 793 794 if (clock < mmc->cfg->f_min) 795 clock = mmc->cfg->f_min; 796 797 mmc->clock = clock; 798 799 mmc_set_ios(mmc); 800 } 801 802 static void mmc_set_bus_width(struct mmc *mmc, uint width) 803 { 804 mmc->bus_width = width; 805 806 mmc_set_ios(mmc); 807 } 808 809 static int mmc_startup(struct mmc *mmc) 810 { 811 int err, i; 812 uint mult, freq; 813 u64 cmult, csize, capacity; 814 struct mmc_cmd cmd; 815 ALLOC_CACHE_ALIGN_BUFFER(u8, ext_csd, MMC_MAX_BLOCK_LEN); 816 ALLOC_CACHE_ALIGN_BUFFER(u8, test_csd, MMC_MAX_BLOCK_LEN); 817 int timeout = 1000; 818 819 #ifdef CONFIG_MMC_SPI_CRC_ON 820 if (mmc_host_is_spi(mmc)) { /* enable CRC check for spi */ 821 cmd.cmdidx = MMC_CMD_SPI_CRC_ON_OFF; 822 cmd.resp_type = MMC_RSP_R1; 823 cmd.cmdarg = 1; 824 err = mmc_send_cmd(mmc, &cmd, NULL); 825 826 if (err) 827 return err; 828 } 829 #endif 830 831 /* Put the Card in Identify Mode */ 832 cmd.cmdidx = mmc_host_is_spi(mmc) ? MMC_CMD_SEND_CID : 833 MMC_CMD_ALL_SEND_CID; /* cmd not supported in spi */ 834 cmd.resp_type = MMC_RSP_R2; 835 cmd.cmdarg = 0; 836 837 err = mmc_send_cmd(mmc, &cmd, NULL); 838 839 if (err) 840 return err; 841 842 memcpy(mmc->cid, cmd.response, 16); 843 844 /* 845 * For MMC cards, set the Relative Address. 846 * For SD cards, get the Relatvie Address. 847 * This also puts the cards into Standby State 848 */ 849 if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */ 850 cmd.cmdidx = SD_CMD_SEND_RELATIVE_ADDR; 851 cmd.cmdarg = mmc->rca << 16; 852 cmd.resp_type = MMC_RSP_R6; 853 854 err = mmc_send_cmd(mmc, &cmd, NULL); 855 856 if (err) 857 return err; 858 859 if (IS_SD(mmc)) 860 mmc->rca = (cmd.response[0] >> 16) & 0xffff; 861 } 862 863 /* Get the Card-Specific Data */ 864 cmd.cmdidx = MMC_CMD_SEND_CSD; 865 cmd.resp_type = MMC_RSP_R2; 866 cmd.cmdarg = mmc->rca << 16; 867 868 err = mmc_send_cmd(mmc, &cmd, NULL); 869 870 /* Waiting for the ready status */ 871 mmc_send_status(mmc, timeout); 872 873 if (err) 874 return err; 875 876 mmc->csd[0] = cmd.response[0]; 877 mmc->csd[1] = cmd.response[1]; 878 mmc->csd[2] = cmd.response[2]; 879 mmc->csd[3] = cmd.response[3]; 880 881 if (mmc->version == MMC_VERSION_UNKNOWN) { 882 int version = (cmd.response[0] >> 26) & 0xf; 883 884 switch (version) { 885 case 0: 886 mmc->version = MMC_VERSION_1_2; 887 break; 888 case 1: 889 mmc->version = MMC_VERSION_1_4; 890 break; 891 case 2: 892 mmc->version = MMC_VERSION_2_2; 893 break; 894 case 3: 895 mmc->version = MMC_VERSION_3; 896 break; 897 case 4: 898 mmc->version = MMC_VERSION_4; 899 break; 900 default: 901 mmc->version = MMC_VERSION_1_2; 902 break; 903 } 904 } 905 906 /* divide frequency by 10, since the mults are 10x bigger */ 907 freq = fbase[(cmd.response[0] & 0x7)]; 908 mult = multipliers[((cmd.response[0] >> 3) & 0xf)]; 909 910 mmc->tran_speed = freq * mult; 911 912 mmc->dsr_imp = ((cmd.response[1] >> 12) & 0x1); 913 mmc->read_bl_len = 1 << ((cmd.response[1] >> 16) & 0xf); 914 915 if (IS_SD(mmc)) 916 mmc->write_bl_len = mmc->read_bl_len; 917 else 918 mmc->write_bl_len = 1 << ((cmd.response[3] >> 22) & 0xf); 919 920 if (mmc->high_capacity) { 921 csize = (mmc->csd[1] & 0x3f) << 16 922 | (mmc->csd[2] & 0xffff0000) >> 16; 923 cmult = 8; 924 } else { 925 csize = (mmc->csd[1] & 0x3ff) << 2 926 | (mmc->csd[2] & 0xc0000000) >> 30; 927 cmult = (mmc->csd[2] & 0x00038000) >> 15; 928 } 929 930 mmc->capacity_user = (csize + 1) << (cmult + 2); 931 mmc->capacity_user *= mmc->read_bl_len; 932 mmc->capacity_boot = 0; 933 mmc->capacity_rpmb = 0; 934 for (i = 0; i < 4; i++) 935 mmc->capacity_gp[i] = 0; 936 937 if (mmc->read_bl_len > MMC_MAX_BLOCK_LEN) 938 mmc->read_bl_len = MMC_MAX_BLOCK_LEN; 939 940 if (mmc->write_bl_len > MMC_MAX_BLOCK_LEN) 941 mmc->write_bl_len = MMC_MAX_BLOCK_LEN; 942 943 if ((mmc->dsr_imp) && (0xffffffff != mmc->dsr)) { 944 cmd.cmdidx = MMC_CMD_SET_DSR; 945 cmd.cmdarg = (mmc->dsr & 0xffff) << 16; 946 cmd.resp_type = MMC_RSP_NONE; 947 if (mmc_send_cmd(mmc, &cmd, NULL)) 948 printf("MMC: SET_DSR failed\n"); 949 } 950 951 /* Select the card, and put it into Transfer Mode */ 952 if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */ 953 cmd.cmdidx = MMC_CMD_SELECT_CARD; 954 cmd.resp_type = MMC_RSP_R1; 955 cmd.cmdarg = mmc->rca << 16; 956 err = mmc_send_cmd(mmc, &cmd, NULL); 957 958 if (err) 959 return err; 960 } 961 962 /* 963 * For SD, its erase group is always one sector 964 */ 965 mmc->erase_grp_size = 1; 966 mmc->part_config = MMCPART_NOAVAILABLE; 967 if (!IS_SD(mmc) && (mmc->version >= MMC_VERSION_4)) { 968 /* check ext_csd version and capacity */ 969 err = mmc_send_ext_csd(mmc, ext_csd); 970 if (!err && (ext_csd[EXT_CSD_REV] >= 2)) { 971 /* 972 * According to the JEDEC Standard, the value of 973 * ext_csd's capacity is valid if the value is more 974 * than 2GB 975 */ 976 capacity = ext_csd[EXT_CSD_SEC_CNT] << 0 977 | ext_csd[EXT_CSD_SEC_CNT + 1] << 8 978 | ext_csd[EXT_CSD_SEC_CNT + 2] << 16 979 | ext_csd[EXT_CSD_SEC_CNT + 3] << 24; 980 capacity *= MMC_MAX_BLOCK_LEN; 981 if ((capacity >> 20) > 2 * 1024) 982 mmc->capacity_user = capacity; 983 } 984 985 switch (ext_csd[EXT_CSD_REV]) { 986 case 1: 987 mmc->version = MMC_VERSION_4_1; 988 break; 989 case 2: 990 mmc->version = MMC_VERSION_4_2; 991 break; 992 case 3: 993 mmc->version = MMC_VERSION_4_3; 994 break; 995 case 5: 996 mmc->version = MMC_VERSION_4_41; 997 break; 998 case 6: 999 mmc->version = MMC_VERSION_4_5; 1000 break; 1001 } 1002 1003 /* 1004 * Host needs to enable ERASE_GRP_DEF bit if device is 1005 * partitioned. This bit will be lost every time after a reset 1006 * or power off. This will affect erase size. 1007 */ 1008 if ((ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & PART_SUPPORT) && 1009 (ext_csd[EXT_CSD_PARTITIONS_ATTRIBUTE] & PART_ENH_ATTRIB)) { 1010 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 1011 EXT_CSD_ERASE_GROUP_DEF, 1); 1012 1013 if (err) 1014 return err; 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 /* 1375 * CPU and board-specific MMC initializations. Aliased function 1376 * signals caller to move on 1377 */ 1378 static int __def_mmc_init(bd_t *bis) 1379 { 1380 return -1; 1381 } 1382 1383 int cpu_mmc_init(bd_t *bis) __attribute__((weak, alias("__def_mmc_init"))); 1384 int board_mmc_init(bd_t *bis) __attribute__((weak, alias("__def_mmc_init"))); 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