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