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