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