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 = 10000; 371 struct mmc_cmd cmd; 372 int err; 373 374 /* Some cards seem to need this */ 375 mmc_go_idle(mmc); 376 377 /* Asking to the card its capabilities */ 378 cmd.cmdidx = MMC_CMD_SEND_OP_COND; 379 cmd.resp_type = MMC_RSP_R3; 380 cmd.cmdarg = 0; 381 cmd.flags = 0; 382 383 err = mmc_send_cmd(mmc, &cmd, NULL); 384 385 if (err) 386 return err; 387 388 udelay(1000); 389 390 do { 391 cmd.cmdidx = MMC_CMD_SEND_OP_COND; 392 cmd.resp_type = MMC_RSP_R3; 393 cmd.cmdarg = (mmc_host_is_spi(mmc) ? 0 : 394 (mmc->voltages & 395 (cmd.response[0] & OCR_VOLTAGE_MASK)) | 396 (cmd.response[0] & OCR_ACCESS_MODE)); 397 cmd.flags = 0; 398 399 err = mmc_send_cmd(mmc, &cmd, NULL); 400 401 if (err) 402 return err; 403 404 udelay(1000); 405 } while (!(cmd.response[0] & OCR_BUSY) && timeout--); 406 407 if (timeout <= 0) 408 return UNUSABLE_ERR; 409 410 if (mmc_host_is_spi(mmc)) { /* read OCR for spi */ 411 cmd.cmdidx = MMC_CMD_SPI_READ_OCR; 412 cmd.resp_type = MMC_RSP_R3; 413 cmd.cmdarg = 0; 414 cmd.flags = 0; 415 416 err = mmc_send_cmd(mmc, &cmd, NULL); 417 418 if (err) 419 return err; 420 } 421 422 mmc->version = MMC_VERSION_UNKNOWN; 423 mmc->ocr = cmd.response[0]; 424 425 mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS); 426 mmc->rca = 0; 427 428 return 0; 429 } 430 431 432 int mmc_send_ext_csd(struct mmc *mmc, char *ext_csd) 433 { 434 struct mmc_cmd cmd; 435 struct mmc_data data; 436 int err; 437 438 /* Get the Card Status Register */ 439 cmd.cmdidx = MMC_CMD_SEND_EXT_CSD; 440 cmd.resp_type = MMC_RSP_R1; 441 cmd.cmdarg = 0; 442 cmd.flags = 0; 443 444 data.dest = ext_csd; 445 data.blocks = 1; 446 data.blocksize = 512; 447 data.flags = MMC_DATA_READ; 448 449 err = mmc_send_cmd(mmc, &cmd, &data); 450 451 return err; 452 } 453 454 455 int mmc_switch(struct mmc *mmc, u8 set, u8 index, u8 value) 456 { 457 struct mmc_cmd cmd; 458 int timeout = 1000; 459 int ret; 460 461 cmd.cmdidx = MMC_CMD_SWITCH; 462 cmd.resp_type = MMC_RSP_R1b; 463 cmd.cmdarg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) | 464 (index << 16) | 465 (value << 8); 466 cmd.flags = 0; 467 468 ret = mmc_send_cmd(mmc, &cmd, NULL); 469 470 /* Waiting for the ready status */ 471 mmc_send_status(mmc, timeout); 472 473 return ret; 474 475 } 476 477 int mmc_change_freq(struct mmc *mmc) 478 { 479 char ext_csd[512]; 480 char cardtype; 481 int err; 482 483 mmc->card_caps = 0; 484 485 if (mmc_host_is_spi(mmc)) 486 return 0; 487 488 /* Only version 4 supports high-speed */ 489 if (mmc->version < MMC_VERSION_4) 490 return 0; 491 492 mmc->card_caps |= MMC_MODE_4BIT; 493 494 err = mmc_send_ext_csd(mmc, ext_csd); 495 496 if (err) 497 return err; 498 499 if (ext_csd[212] || ext_csd[213] || ext_csd[214] || ext_csd[215]) 500 mmc->high_capacity = 1; 501 502 cardtype = ext_csd[196] & 0xf; 503 504 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING, 1); 505 506 if (err) 507 return err; 508 509 /* Now check to see that it worked */ 510 err = mmc_send_ext_csd(mmc, ext_csd); 511 512 if (err) 513 return err; 514 515 /* No high-speed support */ 516 if (!ext_csd[185]) 517 return 0; 518 519 /* High Speed is set, there are two types: 52MHz and 26MHz */ 520 if (cardtype & MMC_HS_52MHZ) 521 mmc->card_caps |= MMC_MODE_HS_52MHz | MMC_MODE_HS; 522 else 523 mmc->card_caps |= MMC_MODE_HS; 524 525 return 0; 526 } 527 528 int sd_switch(struct mmc *mmc, int mode, int group, u8 value, u8 *resp) 529 { 530 struct mmc_cmd cmd; 531 struct mmc_data data; 532 533 /* Switch the frequency */ 534 cmd.cmdidx = SD_CMD_SWITCH_FUNC; 535 cmd.resp_type = MMC_RSP_R1; 536 cmd.cmdarg = (mode << 31) | 0xffffff; 537 cmd.cmdarg &= ~(0xf << (group * 4)); 538 cmd.cmdarg |= value << (group * 4); 539 cmd.flags = 0; 540 541 data.dest = (char *)resp; 542 data.blocksize = 64; 543 data.blocks = 1; 544 data.flags = MMC_DATA_READ; 545 546 return mmc_send_cmd(mmc, &cmd, &data); 547 } 548 549 550 int sd_change_freq(struct mmc *mmc) 551 { 552 int err; 553 struct mmc_cmd cmd; 554 uint scr[2]; 555 uint switch_status[16]; 556 struct mmc_data data; 557 int timeout; 558 559 mmc->card_caps = 0; 560 561 if (mmc_host_is_spi(mmc)) 562 return 0; 563 564 /* Read the SCR to find out if this card supports higher speeds */ 565 cmd.cmdidx = MMC_CMD_APP_CMD; 566 cmd.resp_type = MMC_RSP_R1; 567 cmd.cmdarg = mmc->rca << 16; 568 cmd.flags = 0; 569 570 err = mmc_send_cmd(mmc, &cmd, NULL); 571 572 if (err) 573 return err; 574 575 cmd.cmdidx = SD_CMD_APP_SEND_SCR; 576 cmd.resp_type = MMC_RSP_R1; 577 cmd.cmdarg = 0; 578 cmd.flags = 0; 579 580 timeout = 3; 581 582 retry_scr: 583 data.dest = (char *)&scr; 584 data.blocksize = 8; 585 data.blocks = 1; 586 data.flags = MMC_DATA_READ; 587 588 err = mmc_send_cmd(mmc, &cmd, &data); 589 590 if (err) { 591 if (timeout--) 592 goto retry_scr; 593 594 return err; 595 } 596 597 mmc->scr[0] = __be32_to_cpu(scr[0]); 598 mmc->scr[1] = __be32_to_cpu(scr[1]); 599 600 switch ((mmc->scr[0] >> 24) & 0xf) { 601 case 0: 602 mmc->version = SD_VERSION_1_0; 603 break; 604 case 1: 605 mmc->version = SD_VERSION_1_10; 606 break; 607 case 2: 608 mmc->version = SD_VERSION_2; 609 break; 610 default: 611 mmc->version = SD_VERSION_1_0; 612 break; 613 } 614 615 if (mmc->scr[0] & SD_DATA_4BIT) 616 mmc->card_caps |= MMC_MODE_4BIT; 617 618 /* Version 1.0 doesn't support switching */ 619 if (mmc->version == SD_VERSION_1_0) 620 return 0; 621 622 timeout = 4; 623 while (timeout--) { 624 err = sd_switch(mmc, SD_SWITCH_CHECK, 0, 1, 625 (u8 *)&switch_status); 626 627 if (err) 628 return err; 629 630 /* The high-speed function is busy. Try again */ 631 if (!(__be32_to_cpu(switch_status[7]) & SD_HIGHSPEED_BUSY)) 632 break; 633 } 634 635 /* If high-speed isn't supported, we return */ 636 if (!(__be32_to_cpu(switch_status[3]) & SD_HIGHSPEED_SUPPORTED)) 637 return 0; 638 639 err = sd_switch(mmc, SD_SWITCH_SWITCH, 0, 1, (u8 *)&switch_status); 640 641 if (err) 642 return err; 643 644 if ((__be32_to_cpu(switch_status[4]) & 0x0f000000) == 0x01000000) 645 mmc->card_caps |= MMC_MODE_HS; 646 647 return 0; 648 } 649 650 /* frequency bases */ 651 /* divided by 10 to be nice to platforms without floating point */ 652 static const int fbase[] = { 653 10000, 654 100000, 655 1000000, 656 10000000, 657 }; 658 659 /* Multiplier values for TRAN_SPEED. Multiplied by 10 to be nice 660 * to platforms without floating point. 661 */ 662 static const int multipliers[] = { 663 0, /* reserved */ 664 10, 665 12, 666 13, 667 15, 668 20, 669 25, 670 30, 671 35, 672 40, 673 45, 674 50, 675 55, 676 60, 677 70, 678 80, 679 }; 680 681 void mmc_set_ios(struct mmc *mmc) 682 { 683 mmc->set_ios(mmc); 684 } 685 686 void mmc_set_clock(struct mmc *mmc, uint clock) 687 { 688 if (clock > mmc->f_max) 689 clock = mmc->f_max; 690 691 if (clock < mmc->f_min) 692 clock = mmc->f_min; 693 694 mmc->clock = clock; 695 696 mmc_set_ios(mmc); 697 } 698 699 void mmc_set_bus_width(struct mmc *mmc, uint width) 700 { 701 mmc->bus_width = width; 702 703 mmc_set_ios(mmc); 704 } 705 706 int mmc_startup(struct mmc *mmc) 707 { 708 int err; 709 uint mult, freq; 710 u64 cmult, csize; 711 struct mmc_cmd cmd; 712 char ext_csd[512]; 713 int timeout = 1000; 714 715 #ifdef CONFIG_MMC_SPI_CRC_ON 716 if (mmc_host_is_spi(mmc)) { /* enable CRC check for spi */ 717 cmd.cmdidx = MMC_CMD_SPI_CRC_ON_OFF; 718 cmd.resp_type = MMC_RSP_R1; 719 cmd.cmdarg = 1; 720 cmd.flags = 0; 721 err = mmc_send_cmd(mmc, &cmd, NULL); 722 723 if (err) 724 return err; 725 } 726 #endif 727 728 /* Put the Card in Identify Mode */ 729 cmd.cmdidx = mmc_host_is_spi(mmc) ? MMC_CMD_SEND_CID : 730 MMC_CMD_ALL_SEND_CID; /* cmd not supported in spi */ 731 cmd.resp_type = MMC_RSP_R2; 732 cmd.cmdarg = 0; 733 cmd.flags = 0; 734 735 err = mmc_send_cmd(mmc, &cmd, NULL); 736 737 if (err) 738 return err; 739 740 memcpy(mmc->cid, cmd.response, 16); 741 742 /* 743 * For MMC cards, set the Relative Address. 744 * For SD cards, get the Relatvie Address. 745 * This also puts the cards into Standby State 746 */ 747 if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */ 748 cmd.cmdidx = SD_CMD_SEND_RELATIVE_ADDR; 749 cmd.cmdarg = mmc->rca << 16; 750 cmd.resp_type = MMC_RSP_R6; 751 cmd.flags = 0; 752 753 err = mmc_send_cmd(mmc, &cmd, NULL); 754 755 if (err) 756 return err; 757 758 if (IS_SD(mmc)) 759 mmc->rca = (cmd.response[0] >> 16) & 0xffff; 760 } 761 762 /* Get the Card-Specific Data */ 763 cmd.cmdidx = MMC_CMD_SEND_CSD; 764 cmd.resp_type = MMC_RSP_R2; 765 cmd.cmdarg = mmc->rca << 16; 766 cmd.flags = 0; 767 768 err = mmc_send_cmd(mmc, &cmd, NULL); 769 770 /* Waiting for the ready status */ 771 mmc_send_status(mmc, timeout); 772 773 if (err) 774 return err; 775 776 mmc->csd[0] = cmd.response[0]; 777 mmc->csd[1] = cmd.response[1]; 778 mmc->csd[2] = cmd.response[2]; 779 mmc->csd[3] = cmd.response[3]; 780 781 if (mmc->version == MMC_VERSION_UNKNOWN) { 782 int version = (cmd.response[0] >> 26) & 0xf; 783 784 switch (version) { 785 case 0: 786 mmc->version = MMC_VERSION_1_2; 787 break; 788 case 1: 789 mmc->version = MMC_VERSION_1_4; 790 break; 791 case 2: 792 mmc->version = MMC_VERSION_2_2; 793 break; 794 case 3: 795 mmc->version = MMC_VERSION_3; 796 break; 797 case 4: 798 mmc->version = MMC_VERSION_4; 799 break; 800 default: 801 mmc->version = MMC_VERSION_1_2; 802 break; 803 } 804 } 805 806 /* divide frequency by 10, since the mults are 10x bigger */ 807 freq = fbase[(cmd.response[0] & 0x7)]; 808 mult = multipliers[((cmd.response[0] >> 3) & 0xf)]; 809 810 mmc->tran_speed = freq * mult; 811 812 mmc->read_bl_len = 1 << ((cmd.response[1] >> 16) & 0xf); 813 814 if (IS_SD(mmc)) 815 mmc->write_bl_len = mmc->read_bl_len; 816 else 817 mmc->write_bl_len = 1 << ((cmd.response[3] >> 22) & 0xf); 818 819 if (mmc->high_capacity) { 820 csize = (mmc->csd[1] & 0x3f) << 16 821 | (mmc->csd[2] & 0xffff0000) >> 16; 822 cmult = 8; 823 } else { 824 csize = (mmc->csd[1] & 0x3ff) << 2 825 | (mmc->csd[2] & 0xc0000000) >> 30; 826 cmult = (mmc->csd[2] & 0x00038000) >> 15; 827 } 828 829 mmc->capacity = (csize + 1) << (cmult + 2); 830 mmc->capacity *= mmc->read_bl_len; 831 832 if (mmc->read_bl_len > 512) 833 mmc->read_bl_len = 512; 834 835 if (mmc->write_bl_len > 512) 836 mmc->write_bl_len = 512; 837 838 /* Select the card, and put it into Transfer Mode */ 839 if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */ 840 cmd.cmdidx = MMC_CMD_SELECT_CARD; 841 cmd.resp_type = MMC_RSP_R1b; 842 cmd.cmdarg = mmc->rca << 16; 843 cmd.flags = 0; 844 err = mmc_send_cmd(mmc, &cmd, NULL); 845 846 if (err) 847 return err; 848 } 849 850 if (!IS_SD(mmc) && (mmc->version >= MMC_VERSION_4)) { 851 /* check ext_csd version and capacity */ 852 err = mmc_send_ext_csd(mmc, ext_csd); 853 if (!err & (ext_csd[192] >= 2)) { 854 mmc->capacity = ext_csd[212] << 0 | ext_csd[213] << 8 | 855 ext_csd[214] << 16 | ext_csd[215] << 24; 856 mmc->capacity *= 512; 857 } 858 } 859 860 if (IS_SD(mmc)) 861 err = sd_change_freq(mmc); 862 else 863 err = mmc_change_freq(mmc); 864 865 if (err) 866 return err; 867 868 /* Restrict card's capabilities by what the host can do */ 869 mmc->card_caps &= mmc->host_caps; 870 871 if (IS_SD(mmc)) { 872 if (mmc->card_caps & MMC_MODE_4BIT) { 873 cmd.cmdidx = MMC_CMD_APP_CMD; 874 cmd.resp_type = MMC_RSP_R1; 875 cmd.cmdarg = mmc->rca << 16; 876 cmd.flags = 0; 877 878 err = mmc_send_cmd(mmc, &cmd, NULL); 879 if (err) 880 return err; 881 882 cmd.cmdidx = SD_CMD_APP_SET_BUS_WIDTH; 883 cmd.resp_type = MMC_RSP_R1; 884 cmd.cmdarg = 2; 885 cmd.flags = 0; 886 err = mmc_send_cmd(mmc, &cmd, NULL); 887 if (err) 888 return err; 889 890 mmc_set_bus_width(mmc, 4); 891 } 892 893 if (mmc->card_caps & MMC_MODE_HS) 894 mmc_set_clock(mmc, 50000000); 895 else 896 mmc_set_clock(mmc, 25000000); 897 } else { 898 if (mmc->card_caps & MMC_MODE_4BIT) { 899 /* Set the card to use 4 bit*/ 900 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 901 EXT_CSD_BUS_WIDTH, 902 EXT_CSD_BUS_WIDTH_4); 903 904 if (err) 905 return err; 906 907 mmc_set_bus_width(mmc, 4); 908 } else if (mmc->card_caps & MMC_MODE_8BIT) { 909 /* Set the card to use 8 bit*/ 910 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 911 EXT_CSD_BUS_WIDTH, 912 EXT_CSD_BUS_WIDTH_8); 913 914 if (err) 915 return err; 916 917 mmc_set_bus_width(mmc, 8); 918 } 919 920 if (mmc->card_caps & MMC_MODE_HS) { 921 if (mmc->card_caps & MMC_MODE_HS_52MHz) 922 mmc_set_clock(mmc, 52000000); 923 else 924 mmc_set_clock(mmc, 26000000); 925 } else 926 mmc_set_clock(mmc, 20000000); 927 } 928 929 /* fill in device description */ 930 mmc->block_dev.lun = 0; 931 mmc->block_dev.type = 0; 932 mmc->block_dev.blksz = mmc->read_bl_len; 933 mmc->block_dev.lba = lldiv(mmc->capacity, mmc->read_bl_len); 934 sprintf(mmc->block_dev.vendor, "Man %06x Snr %08x", mmc->cid[0] >> 8, 935 (mmc->cid[2] << 8) | (mmc->cid[3] >> 24)); 936 sprintf(mmc->block_dev.product, "%c%c%c%c%c", mmc->cid[0] & 0xff, 937 (mmc->cid[1] >> 24), (mmc->cid[1] >> 16) & 0xff, 938 (mmc->cid[1] >> 8) & 0xff, mmc->cid[1] & 0xff); 939 sprintf(mmc->block_dev.revision, "%d.%d", mmc->cid[2] >> 28, 940 (mmc->cid[2] >> 24) & 0xf); 941 init_part(&mmc->block_dev); 942 943 return 0; 944 } 945 946 int mmc_send_if_cond(struct mmc *mmc) 947 { 948 struct mmc_cmd cmd; 949 int err; 950 951 cmd.cmdidx = SD_CMD_SEND_IF_COND; 952 /* We set the bit if the host supports voltages between 2.7 and 3.6 V */ 953 cmd.cmdarg = ((mmc->voltages & 0xff8000) != 0) << 8 | 0xaa; 954 cmd.resp_type = MMC_RSP_R7; 955 cmd.flags = 0; 956 957 err = mmc_send_cmd(mmc, &cmd, NULL); 958 959 if (err) 960 return err; 961 962 if ((cmd.response[0] & 0xff) != 0xaa) 963 return UNUSABLE_ERR; 964 else 965 mmc->version = SD_VERSION_2; 966 967 return 0; 968 } 969 970 int mmc_register(struct mmc *mmc) 971 { 972 /* Setup the universal parts of the block interface just once */ 973 mmc->block_dev.if_type = IF_TYPE_MMC; 974 mmc->block_dev.dev = cur_dev_num++; 975 mmc->block_dev.removable = 1; 976 mmc->block_dev.block_read = mmc_bread; 977 mmc->block_dev.block_write = mmc_bwrite; 978 979 INIT_LIST_HEAD (&mmc->link); 980 981 list_add_tail (&mmc->link, &mmc_devices); 982 983 return 0; 984 } 985 986 block_dev_desc_t *mmc_get_dev(int dev) 987 { 988 struct mmc *mmc = find_mmc_device(dev); 989 990 return mmc ? &mmc->block_dev : NULL; 991 } 992 993 int mmc_init(struct mmc *mmc) 994 { 995 int err; 996 997 err = mmc->init(mmc); 998 999 if (err) 1000 return err; 1001 1002 mmc_set_bus_width(mmc, 1); 1003 mmc_set_clock(mmc, 1); 1004 1005 /* Reset the Card */ 1006 err = mmc_go_idle(mmc); 1007 1008 if (err) 1009 return err; 1010 1011 /* Test for SD version 2 */ 1012 err = mmc_send_if_cond(mmc); 1013 1014 /* Now try to get the SD card's operating condition */ 1015 err = sd_send_op_cond(mmc); 1016 1017 /* If the command timed out, we check for an MMC card */ 1018 if (err == TIMEOUT) { 1019 err = mmc_send_op_cond(mmc); 1020 1021 if (err) { 1022 printf("Card did not respond to voltage select!\n"); 1023 return UNUSABLE_ERR; 1024 } 1025 } 1026 1027 return mmc_startup(mmc); 1028 } 1029 1030 /* 1031 * CPU and board-specific MMC initializations. Aliased function 1032 * signals caller to move on 1033 */ 1034 static int __def_mmc_init(bd_t *bis) 1035 { 1036 return -1; 1037 } 1038 1039 int cpu_mmc_init(bd_t *bis) __attribute__((weak, alias("__def_mmc_init"))); 1040 int board_mmc_init(bd_t *bis) __attribute__((weak, alias("__def_mmc_init"))); 1041 1042 void print_mmc_devices(char separator) 1043 { 1044 struct mmc *m; 1045 struct list_head *entry; 1046 1047 list_for_each(entry, &mmc_devices) { 1048 m = list_entry(entry, struct mmc, link); 1049 1050 printf("%s: %d", m->name, m->block_dev.dev); 1051 1052 if (entry->next != &mmc_devices) 1053 printf("%c ", separator); 1054 } 1055 1056 printf("\n"); 1057 } 1058 1059 int mmc_initialize(bd_t *bis) 1060 { 1061 INIT_LIST_HEAD (&mmc_devices); 1062 cur_dev_num = 0; 1063 1064 if (board_mmc_init(bis) < 0) 1065 cpu_mmc_init(bis); 1066 1067 print_mmc_devices(','); 1068 1069 return 0; 1070 } 1071