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