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