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 <mmc.h> 34 #include <div64.h> 35 36 static struct list_head mmc_devices; 37 static int cur_dev_num = -1; 38 39 int __board_mmc_getcd(u8 *cd, struct mmc *mmc) { 40 return -1; 41 } 42 43 int board_mmc_getcd(u8 *cd, struct mmc *mmc)__attribute__((weak, 44 alias("__board_mmc_getcd"))); 45 46 int mmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data) 47 { 48 return mmc->send_cmd(mmc, cmd, data); 49 } 50 51 int mmc_set_blocklen(struct mmc *mmc, int len) 52 { 53 struct mmc_cmd cmd; 54 55 cmd.cmdidx = MMC_CMD_SET_BLOCKLEN; 56 cmd.resp_type = MMC_RSP_R1; 57 cmd.cmdarg = len; 58 cmd.flags = 0; 59 60 return mmc_send_cmd(mmc, &cmd, NULL); 61 } 62 63 struct mmc *find_mmc_device(int dev_num) 64 { 65 struct mmc *m; 66 struct list_head *entry; 67 68 list_for_each(entry, &mmc_devices) { 69 m = list_entry(entry, struct mmc, link); 70 71 if (m->block_dev.dev == dev_num) 72 return m; 73 } 74 75 printf("MMC Device %d not found\n", dev_num); 76 77 return NULL; 78 } 79 80 static ulong 81 mmc_bwrite(int dev_num, ulong start, lbaint_t blkcnt, const void*src) 82 { 83 struct mmc_cmd cmd; 84 struct mmc_data data; 85 int err; 86 int stoperr = 0; 87 struct mmc *mmc = find_mmc_device(dev_num); 88 int blklen; 89 90 if (!mmc) 91 return -1; 92 93 blklen = mmc->write_bl_len; 94 95 if ((start + blkcnt) > mmc->block_dev.lba) { 96 printf("MMC: block number 0x%lx exceeds max(0x%lx)", 97 start + blkcnt, mmc->block_dev.lba); 98 return 0; 99 } 100 err = mmc_set_blocklen(mmc, mmc->write_bl_len); 101 102 if (err) { 103 printf("set write bl len failed\n\r"); 104 return err; 105 } 106 107 if (blkcnt > 1) 108 cmd.cmdidx = MMC_CMD_WRITE_MULTIPLE_BLOCK; 109 else 110 cmd.cmdidx = MMC_CMD_WRITE_SINGLE_BLOCK; 111 112 if (mmc->high_capacity) 113 cmd.cmdarg = start; 114 else 115 cmd.cmdarg = start * blklen; 116 117 cmd.resp_type = MMC_RSP_R1; 118 cmd.flags = 0; 119 120 data.src = src; 121 data.blocks = blkcnt; 122 data.blocksize = blklen; 123 data.flags = MMC_DATA_WRITE; 124 125 err = mmc_send_cmd(mmc, &cmd, &data); 126 127 if (err) { 128 printf("mmc write failed\n\r"); 129 return err; 130 } 131 132 if (blkcnt > 1) { 133 cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION; 134 cmd.cmdarg = 0; 135 cmd.resp_type = MMC_RSP_R1b; 136 cmd.flags = 0; 137 stoperr = mmc_send_cmd(mmc, &cmd, NULL); 138 } 139 140 return blkcnt; 141 } 142 143 int mmc_read_block(struct mmc *mmc, void *dst, uint blocknum) 144 { 145 struct mmc_cmd cmd; 146 struct mmc_data data; 147 148 cmd.cmdidx = MMC_CMD_READ_SINGLE_BLOCK; 149 150 if (mmc->high_capacity) 151 cmd.cmdarg = blocknum; 152 else 153 cmd.cmdarg = blocknum * mmc->read_bl_len; 154 155 cmd.resp_type = MMC_RSP_R1; 156 cmd.flags = 0; 157 158 data.dest = dst; 159 data.blocks = 1; 160 data.blocksize = mmc->read_bl_len; 161 data.flags = MMC_DATA_READ; 162 163 return mmc_send_cmd(mmc, &cmd, &data); 164 } 165 166 int mmc_read(struct mmc *mmc, u64 src, uchar *dst, int size) 167 { 168 char *buffer; 169 int i; 170 int blklen = mmc->read_bl_len; 171 int startblock = lldiv(src, mmc->read_bl_len); 172 int endblock = lldiv(src + size - 1, mmc->read_bl_len); 173 int err = 0; 174 175 /* Make a buffer big enough to hold all the blocks we might read */ 176 buffer = malloc(blklen); 177 178 if (!buffer) { 179 printf("Could not allocate buffer for MMC read!\n"); 180 return -1; 181 } 182 183 /* We always do full block reads from the card */ 184 err = mmc_set_blocklen(mmc, mmc->read_bl_len); 185 186 if (err) 187 goto free_buffer; 188 189 for (i = startblock; i <= endblock; i++) { 190 int segment_size; 191 int offset; 192 193 err = mmc_read_block(mmc, buffer, i); 194 195 if (err) 196 goto free_buffer; 197 198 /* 199 * The first block may not be aligned, so we 200 * copy from the desired point in the block 201 */ 202 offset = (src & (blklen - 1)); 203 segment_size = MIN(blklen - offset, size); 204 205 memcpy(dst, buffer + offset, segment_size); 206 207 dst += segment_size; 208 src += segment_size; 209 size -= segment_size; 210 } 211 212 free_buffer: 213 free(buffer); 214 215 return err; 216 } 217 218 static ulong mmc_bread(int dev_num, ulong start, lbaint_t blkcnt, void *dst) 219 { 220 int err; 221 int i; 222 struct mmc *mmc = find_mmc_device(dev_num); 223 224 if (!mmc) 225 return 0; 226 227 if ((start + blkcnt) > mmc->block_dev.lba) { 228 printf("MMC: block number 0x%lx exceeds max(0x%lx)", 229 start + blkcnt, mmc->block_dev.lba); 230 return 0; 231 } 232 /* We always do full block reads from the card */ 233 err = mmc_set_blocklen(mmc, mmc->read_bl_len); 234 235 if (err) { 236 return 0; 237 } 238 239 for (i = start; i < start + blkcnt; i++, dst += mmc->read_bl_len) { 240 err = mmc_read_block(mmc, dst, i); 241 242 if (err) { 243 printf("block read failed: %d\n", err); 244 return i - start; 245 } 246 } 247 248 return blkcnt; 249 } 250 251 int mmc_go_idle(struct mmc* mmc) 252 { 253 struct mmc_cmd cmd; 254 int err; 255 256 udelay(1000); 257 258 cmd.cmdidx = MMC_CMD_GO_IDLE_STATE; 259 cmd.cmdarg = 0; 260 cmd.resp_type = MMC_RSP_NONE; 261 cmd.flags = 0; 262 263 err = mmc_send_cmd(mmc, &cmd, NULL); 264 265 if (err) 266 return err; 267 268 udelay(2000); 269 270 return 0; 271 } 272 273 int 274 sd_send_op_cond(struct mmc *mmc) 275 { 276 int timeout = 1000; 277 int err; 278 struct mmc_cmd cmd; 279 280 do { 281 cmd.cmdidx = MMC_CMD_APP_CMD; 282 cmd.resp_type = MMC_RSP_R1; 283 cmd.cmdarg = 0; 284 cmd.flags = 0; 285 286 err = mmc_send_cmd(mmc, &cmd, NULL); 287 288 if (err) 289 return err; 290 291 cmd.cmdidx = SD_CMD_APP_SEND_OP_COND; 292 cmd.resp_type = MMC_RSP_R3; 293 294 /* 295 * Most cards do not answer if some reserved bits 296 * in the ocr are set. However, Some controller 297 * can set bit 7 (reserved for low voltages), but 298 * how to manage low voltages SD card is not yet 299 * specified. 300 */ 301 cmd.cmdarg = mmc->voltages & 0xff8000; 302 303 if (mmc->version == SD_VERSION_2) 304 cmd.cmdarg |= OCR_HCS; 305 306 err = mmc_send_cmd(mmc, &cmd, NULL); 307 308 if (err) 309 return err; 310 311 udelay(1000); 312 } while ((!(cmd.response[0] & OCR_BUSY)) && timeout--); 313 314 if (timeout <= 0) 315 return UNUSABLE_ERR; 316 317 if (mmc->version != SD_VERSION_2) 318 mmc->version = SD_VERSION_1_0; 319 320 mmc->ocr = cmd.response[0]; 321 322 mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS); 323 mmc->rca = 0; 324 325 return 0; 326 } 327 328 int mmc_send_op_cond(struct mmc *mmc) 329 { 330 int timeout = 1000; 331 struct mmc_cmd cmd; 332 int err; 333 334 /* Some cards seem to need this */ 335 mmc_go_idle(mmc); 336 337 do { 338 cmd.cmdidx = MMC_CMD_SEND_OP_COND; 339 cmd.resp_type = MMC_RSP_R3; 340 cmd.cmdarg = OCR_HCS | mmc->voltages; 341 cmd.flags = 0; 342 343 err = mmc_send_cmd(mmc, &cmd, NULL); 344 345 if (err) 346 return err; 347 348 udelay(1000); 349 } while (!(cmd.response[0] & OCR_BUSY) && timeout--); 350 351 if (timeout <= 0) 352 return UNUSABLE_ERR; 353 354 mmc->version = MMC_VERSION_UNKNOWN; 355 mmc->ocr = cmd.response[0]; 356 357 mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS); 358 mmc->rca = 0; 359 360 return 0; 361 } 362 363 364 int mmc_send_ext_csd(struct mmc *mmc, char *ext_csd) 365 { 366 struct mmc_cmd cmd; 367 struct mmc_data data; 368 int err; 369 370 /* Get the Card Status Register */ 371 cmd.cmdidx = MMC_CMD_SEND_EXT_CSD; 372 cmd.resp_type = MMC_RSP_R1; 373 cmd.cmdarg = 0; 374 cmd.flags = 0; 375 376 data.dest = ext_csd; 377 data.blocks = 1; 378 data.blocksize = 512; 379 data.flags = MMC_DATA_READ; 380 381 err = mmc_send_cmd(mmc, &cmd, &data); 382 383 return err; 384 } 385 386 387 int mmc_switch(struct mmc *mmc, u8 set, u8 index, u8 value) 388 { 389 struct mmc_cmd cmd; 390 391 cmd.cmdidx = MMC_CMD_SWITCH; 392 cmd.resp_type = MMC_RSP_R1b; 393 cmd.cmdarg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) | 394 (index << 16) | 395 (value << 8); 396 cmd.flags = 0; 397 398 return mmc_send_cmd(mmc, &cmd, NULL); 399 } 400 401 int mmc_change_freq(struct mmc *mmc) 402 { 403 char ext_csd[512]; 404 char cardtype; 405 int err; 406 407 mmc->card_caps = 0; 408 409 /* Only version 4 supports high-speed */ 410 if (mmc->version < MMC_VERSION_4) 411 return 0; 412 413 mmc->card_caps |= MMC_MODE_4BIT; 414 415 err = mmc_send_ext_csd(mmc, ext_csd); 416 417 if (err) 418 return err; 419 420 if (ext_csd[212] || ext_csd[213] || ext_csd[214] || ext_csd[215]) 421 mmc->high_capacity = 1; 422 423 cardtype = ext_csd[196] & 0xf; 424 425 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING, 1); 426 427 if (err) 428 return err; 429 430 /* Now check to see that it worked */ 431 err = mmc_send_ext_csd(mmc, ext_csd); 432 433 if (err) 434 return err; 435 436 /* No high-speed support */ 437 if (!ext_csd[185]) 438 return 0; 439 440 /* High Speed is set, there are two types: 52MHz and 26MHz */ 441 if (cardtype & MMC_HS_52MHZ) 442 mmc->card_caps |= MMC_MODE_HS_52MHz | MMC_MODE_HS; 443 else 444 mmc->card_caps |= MMC_MODE_HS; 445 446 return 0; 447 } 448 449 int sd_switch(struct mmc *mmc, int mode, int group, u8 value, u8 *resp) 450 { 451 struct mmc_cmd cmd; 452 struct mmc_data data; 453 454 /* Switch the frequency */ 455 cmd.cmdidx = SD_CMD_SWITCH_FUNC; 456 cmd.resp_type = MMC_RSP_R1; 457 cmd.cmdarg = (mode << 31) | 0xffffff; 458 cmd.cmdarg &= ~(0xf << (group * 4)); 459 cmd.cmdarg |= value << (group * 4); 460 cmd.flags = 0; 461 462 data.dest = (char *)resp; 463 data.blocksize = 64; 464 data.blocks = 1; 465 data.flags = MMC_DATA_READ; 466 467 return mmc_send_cmd(mmc, &cmd, &data); 468 } 469 470 471 int sd_change_freq(struct mmc *mmc) 472 { 473 int err; 474 struct mmc_cmd cmd; 475 uint scr[2]; 476 uint switch_status[16]; 477 struct mmc_data data; 478 int timeout; 479 480 mmc->card_caps = 0; 481 482 /* Read the SCR to find out if this card supports higher speeds */ 483 cmd.cmdidx = MMC_CMD_APP_CMD; 484 cmd.resp_type = MMC_RSP_R1; 485 cmd.cmdarg = mmc->rca << 16; 486 cmd.flags = 0; 487 488 err = mmc_send_cmd(mmc, &cmd, NULL); 489 490 if (err) 491 return err; 492 493 cmd.cmdidx = SD_CMD_APP_SEND_SCR; 494 cmd.resp_type = MMC_RSP_R1; 495 cmd.cmdarg = 0; 496 cmd.flags = 0; 497 498 timeout = 3; 499 500 retry_scr: 501 data.dest = (char *)&scr; 502 data.blocksize = 8; 503 data.blocks = 1; 504 data.flags = MMC_DATA_READ; 505 506 err = mmc_send_cmd(mmc, &cmd, &data); 507 508 if (err) { 509 if (timeout--) 510 goto retry_scr; 511 512 return err; 513 } 514 515 mmc->scr[0] = __be32_to_cpu(scr[0]); 516 mmc->scr[1] = __be32_to_cpu(scr[1]); 517 518 switch ((mmc->scr[0] >> 24) & 0xf) { 519 case 0: 520 mmc->version = SD_VERSION_1_0; 521 break; 522 case 1: 523 mmc->version = SD_VERSION_1_10; 524 break; 525 case 2: 526 mmc->version = SD_VERSION_2; 527 break; 528 default: 529 mmc->version = SD_VERSION_1_0; 530 break; 531 } 532 533 /* Version 1.0 doesn't support switching */ 534 if (mmc->version == SD_VERSION_1_0) 535 return 0; 536 537 timeout = 4; 538 while (timeout--) { 539 err = sd_switch(mmc, SD_SWITCH_CHECK, 0, 1, 540 (u8 *)&switch_status); 541 542 if (err) 543 return err; 544 545 /* The high-speed function is busy. Try again */ 546 if (!(__be32_to_cpu(switch_status[7]) & SD_HIGHSPEED_BUSY)) 547 break; 548 } 549 550 if (mmc->scr[0] & SD_DATA_4BIT) 551 mmc->card_caps |= MMC_MODE_4BIT; 552 553 /* If high-speed isn't supported, we return */ 554 if (!(__be32_to_cpu(switch_status[3]) & SD_HIGHSPEED_SUPPORTED)) 555 return 0; 556 557 err = sd_switch(mmc, SD_SWITCH_SWITCH, 0, 1, (u8 *)&switch_status); 558 559 if (err) 560 return err; 561 562 if ((__be32_to_cpu(switch_status[4]) & 0x0f000000) == 0x01000000) 563 mmc->card_caps |= MMC_MODE_HS; 564 565 return 0; 566 } 567 568 /* frequency bases */ 569 /* divided by 10 to be nice to platforms without floating point */ 570 int fbase[] = { 571 10000, 572 100000, 573 1000000, 574 10000000, 575 }; 576 577 /* Multiplier values for TRAN_SPEED. Multiplied by 10 to be nice 578 * to platforms without floating point. 579 */ 580 int multipliers[] = { 581 0, /* reserved */ 582 10, 583 12, 584 13, 585 15, 586 20, 587 25, 588 30, 589 35, 590 40, 591 45, 592 50, 593 55, 594 60, 595 70, 596 80, 597 }; 598 599 void mmc_set_ios(struct mmc *mmc) 600 { 601 mmc->set_ios(mmc); 602 } 603 604 void mmc_set_clock(struct mmc *mmc, uint clock) 605 { 606 if (clock > mmc->f_max) 607 clock = mmc->f_max; 608 609 if (clock < mmc->f_min) 610 clock = mmc->f_min; 611 612 mmc->clock = clock; 613 614 mmc_set_ios(mmc); 615 } 616 617 void mmc_set_bus_width(struct mmc *mmc, uint width) 618 { 619 mmc->bus_width = width; 620 621 mmc_set_ios(mmc); 622 } 623 624 int mmc_startup(struct mmc *mmc) 625 { 626 int err; 627 uint mult, freq; 628 u64 cmult, csize; 629 struct mmc_cmd cmd; 630 char ext_csd[512]; 631 632 /* Put the Card in Identify Mode */ 633 cmd.cmdidx = MMC_CMD_ALL_SEND_CID; 634 cmd.resp_type = MMC_RSP_R2; 635 cmd.cmdarg = 0; 636 cmd.flags = 0; 637 638 err = mmc_send_cmd(mmc, &cmd, NULL); 639 640 if (err) 641 return err; 642 643 memcpy(mmc->cid, cmd.response, 16); 644 645 /* 646 * For MMC cards, set the Relative Address. 647 * For SD cards, get the Relatvie Address. 648 * This also puts the cards into Standby State 649 */ 650 cmd.cmdidx = SD_CMD_SEND_RELATIVE_ADDR; 651 cmd.cmdarg = mmc->rca << 16; 652 cmd.resp_type = MMC_RSP_R6; 653 cmd.flags = 0; 654 655 err = mmc_send_cmd(mmc, &cmd, NULL); 656 657 if (err) 658 return err; 659 660 if (IS_SD(mmc)) 661 mmc->rca = (cmd.response[0] >> 16) & 0xffff; 662 663 /* Get the Card-Specific Data */ 664 cmd.cmdidx = MMC_CMD_SEND_CSD; 665 cmd.resp_type = MMC_RSP_R2; 666 cmd.cmdarg = mmc->rca << 16; 667 cmd.flags = 0; 668 669 err = mmc_send_cmd(mmc, &cmd, NULL); 670 671 if (err) 672 return err; 673 674 mmc->csd[0] = cmd.response[0]; 675 mmc->csd[1] = cmd.response[1]; 676 mmc->csd[2] = cmd.response[2]; 677 mmc->csd[3] = cmd.response[3]; 678 679 if (mmc->version == MMC_VERSION_UNKNOWN) { 680 int version = (cmd.response[0] >> 26) & 0xf; 681 682 switch (version) { 683 case 0: 684 mmc->version = MMC_VERSION_1_2; 685 break; 686 case 1: 687 mmc->version = MMC_VERSION_1_4; 688 break; 689 case 2: 690 mmc->version = MMC_VERSION_2_2; 691 break; 692 case 3: 693 mmc->version = MMC_VERSION_3; 694 break; 695 case 4: 696 mmc->version = MMC_VERSION_4; 697 break; 698 default: 699 mmc->version = MMC_VERSION_1_2; 700 break; 701 } 702 } 703 704 /* divide frequency by 10, since the mults are 10x bigger */ 705 freq = fbase[(cmd.response[0] & 0x7)]; 706 mult = multipliers[((cmd.response[0] >> 3) & 0xf)]; 707 708 mmc->tran_speed = freq * mult; 709 710 mmc->read_bl_len = 1 << ((cmd.response[1] >> 16) & 0xf); 711 712 if (IS_SD(mmc)) 713 mmc->write_bl_len = mmc->read_bl_len; 714 else 715 mmc->write_bl_len = 1 << ((cmd.response[3] >> 22) & 0xf); 716 717 if (mmc->high_capacity) { 718 csize = (mmc->csd[1] & 0x3f) << 16 719 | (mmc->csd[2] & 0xffff0000) >> 16; 720 cmult = 8; 721 } else { 722 csize = (mmc->csd[1] & 0x3ff) << 2 723 | (mmc->csd[2] & 0xc0000000) >> 30; 724 cmult = (mmc->csd[2] & 0x00038000) >> 15; 725 } 726 727 mmc->capacity = (csize + 1) << (cmult + 2); 728 mmc->capacity *= mmc->read_bl_len; 729 730 if (mmc->read_bl_len > 512) 731 mmc->read_bl_len = 512; 732 733 if (mmc->write_bl_len > 512) 734 mmc->write_bl_len = 512; 735 736 /* Select the card, and put it into Transfer Mode */ 737 cmd.cmdidx = MMC_CMD_SELECT_CARD; 738 cmd.resp_type = MMC_RSP_R1b; 739 cmd.cmdarg = mmc->rca << 16; 740 cmd.flags = 0; 741 err = mmc_send_cmd(mmc, &cmd, NULL); 742 743 if (err) 744 return err; 745 746 if (!IS_SD(mmc) && (mmc->version >= MMC_VERSION_4)) { 747 /* check ext_csd version and capacity */ 748 err = mmc_send_ext_csd(mmc, ext_csd); 749 if (!err & (ext_csd[192] >= 2)) { 750 mmc->capacity = ext_csd[212] << 0 | ext_csd[213] << 8 | 751 ext_csd[214] << 16 | ext_csd[215] << 24; 752 mmc->capacity *= 512; 753 } 754 } 755 756 if (IS_SD(mmc)) 757 err = sd_change_freq(mmc); 758 else 759 err = mmc_change_freq(mmc); 760 761 if (err) 762 return err; 763 764 /* Restrict card's capabilities by what the host can do */ 765 mmc->card_caps &= mmc->host_caps; 766 767 if (IS_SD(mmc)) { 768 if (mmc->card_caps & MMC_MODE_4BIT) { 769 cmd.cmdidx = MMC_CMD_APP_CMD; 770 cmd.resp_type = MMC_RSP_R1; 771 cmd.cmdarg = mmc->rca << 16; 772 cmd.flags = 0; 773 774 err = mmc_send_cmd(mmc, &cmd, NULL); 775 if (err) 776 return err; 777 778 cmd.cmdidx = SD_CMD_APP_SET_BUS_WIDTH; 779 cmd.resp_type = MMC_RSP_R1; 780 cmd.cmdarg = 2; 781 cmd.flags = 0; 782 err = mmc_send_cmd(mmc, &cmd, NULL); 783 if (err) 784 return err; 785 786 mmc_set_bus_width(mmc, 4); 787 } 788 789 if (mmc->card_caps & MMC_MODE_HS) 790 mmc_set_clock(mmc, 50000000); 791 else 792 mmc_set_clock(mmc, 25000000); 793 } else { 794 if (mmc->card_caps & MMC_MODE_4BIT) { 795 /* Set the card to use 4 bit*/ 796 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 797 EXT_CSD_BUS_WIDTH, 798 EXT_CSD_BUS_WIDTH_4); 799 800 if (err) 801 return err; 802 803 mmc_set_bus_width(mmc, 4); 804 } else if (mmc->card_caps & MMC_MODE_8BIT) { 805 /* Set the card to use 8 bit*/ 806 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 807 EXT_CSD_BUS_WIDTH, 808 EXT_CSD_BUS_WIDTH_8); 809 810 if (err) 811 return err; 812 813 mmc_set_bus_width(mmc, 8); 814 } 815 816 if (mmc->card_caps & MMC_MODE_HS) { 817 if (mmc->card_caps & MMC_MODE_HS_52MHz) 818 mmc_set_clock(mmc, 52000000); 819 else 820 mmc_set_clock(mmc, 26000000); 821 } else 822 mmc_set_clock(mmc, 20000000); 823 } 824 825 /* fill in device description */ 826 mmc->block_dev.lun = 0; 827 mmc->block_dev.type = 0; 828 mmc->block_dev.blksz = mmc->read_bl_len; 829 mmc->block_dev.lba = lldiv(mmc->capacity, mmc->read_bl_len); 830 sprintf(mmc->block_dev.vendor, "Man %06x Snr %08x", mmc->cid[0] >> 8, 831 (mmc->cid[2] << 8) | (mmc->cid[3] >> 24)); 832 sprintf(mmc->block_dev.product, "%c%c%c%c%c", mmc->cid[0] & 0xff, 833 (mmc->cid[1] >> 24), (mmc->cid[1] >> 16) & 0xff, 834 (mmc->cid[1] >> 8) & 0xff, mmc->cid[1] & 0xff); 835 sprintf(mmc->block_dev.revision, "%d.%d", mmc->cid[2] >> 28, 836 (mmc->cid[2] >> 24) & 0xf); 837 init_part(&mmc->block_dev); 838 839 return 0; 840 } 841 842 int mmc_send_if_cond(struct mmc *mmc) 843 { 844 struct mmc_cmd cmd; 845 int err; 846 847 cmd.cmdidx = SD_CMD_SEND_IF_COND; 848 /* We set the bit if the host supports voltages between 2.7 and 3.6 V */ 849 cmd.cmdarg = ((mmc->voltages & 0xff8000) != 0) << 8 | 0xaa; 850 cmd.resp_type = MMC_RSP_R7; 851 cmd.flags = 0; 852 853 err = mmc_send_cmd(mmc, &cmd, NULL); 854 855 if (err) 856 return err; 857 858 if ((cmd.response[0] & 0xff) != 0xaa) 859 return UNUSABLE_ERR; 860 else 861 mmc->version = SD_VERSION_2; 862 863 return 0; 864 } 865 866 int mmc_register(struct mmc *mmc) 867 { 868 /* Setup the universal parts of the block interface just once */ 869 mmc->block_dev.if_type = IF_TYPE_MMC; 870 mmc->block_dev.dev = cur_dev_num++; 871 mmc->block_dev.removable = 1; 872 mmc->block_dev.block_read = mmc_bread; 873 mmc->block_dev.block_write = mmc_bwrite; 874 875 INIT_LIST_HEAD (&mmc->link); 876 877 list_add_tail (&mmc->link, &mmc_devices); 878 879 return 0; 880 } 881 882 block_dev_desc_t *mmc_get_dev(int dev) 883 { 884 struct mmc *mmc = find_mmc_device(dev); 885 886 return mmc ? &mmc->block_dev : NULL; 887 } 888 889 int mmc_init(struct mmc *mmc) 890 { 891 int err; 892 893 err = mmc->init(mmc); 894 895 if (err) 896 return err; 897 898 mmc_set_bus_width(mmc, 1); 899 mmc_set_clock(mmc, 1); 900 901 /* Reset the Card */ 902 err = mmc_go_idle(mmc); 903 904 if (err) 905 return err; 906 907 /* Test for SD version 2 */ 908 err = mmc_send_if_cond(mmc); 909 910 /* Now try to get the SD card's operating condition */ 911 err = sd_send_op_cond(mmc); 912 913 /* If the command timed out, we check for an MMC card */ 914 if (err == TIMEOUT) { 915 err = mmc_send_op_cond(mmc); 916 917 if (err) { 918 printf("Card did not respond to voltage select!\n"); 919 return UNUSABLE_ERR; 920 } 921 } 922 923 return mmc_startup(mmc); 924 } 925 926 /* 927 * CPU and board-specific MMC initializations. Aliased function 928 * signals caller to move on 929 */ 930 static int __def_mmc_init(bd_t *bis) 931 { 932 return -1; 933 } 934 935 int cpu_mmc_init(bd_t *bis) __attribute__((weak, alias("__def_mmc_init"))); 936 int board_mmc_init(bd_t *bis) __attribute__((weak, alias("__def_mmc_init"))); 937 938 void print_mmc_devices(char separator) 939 { 940 struct mmc *m; 941 struct list_head *entry; 942 943 list_for_each(entry, &mmc_devices) { 944 m = list_entry(entry, struct mmc, link); 945 946 printf("%s: %d", m->name, m->block_dev.dev); 947 948 if (entry->next != &mmc_devices) 949 printf("%c ", separator); 950 } 951 952 printf("\n"); 953 } 954 955 int mmc_initialize(bd_t *bis) 956 { 957 INIT_LIST_HEAD (&mmc_devices); 958 cur_dev_num = 0; 959 960 if (board_mmc_init(bis) < 0) 961 cpu_mmc_init(bis); 962 963 print_mmc_devices(','); 964 965 return 0; 966 } 967