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