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