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