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