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