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