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