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