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