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 err = mmc_send_ext_csd(mmc, ext_csd); 635 636 if (err) 637 return err; 638 639 cardtype = ext_csd[EXT_CSD_CARD_TYPE] & 0xf; 640 641 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING, 1); 642 643 if (err) 644 return err; 645 646 /* Now check to see that it worked */ 647 err = mmc_send_ext_csd(mmc, ext_csd); 648 649 if (err) 650 return err; 651 652 /* No high-speed support */ 653 if (!ext_csd[EXT_CSD_HS_TIMING]) 654 return 0; 655 656 /* High Speed is set, there are two types: 52MHz and 26MHz */ 657 if (cardtype & MMC_HS_52MHZ) 658 mmc->card_caps |= MMC_MODE_HS_52MHz | MMC_MODE_HS; 659 else 660 mmc->card_caps |= MMC_MODE_HS; 661 662 return 0; 663 } 664 665 int mmc_switch_part(int dev_num, unsigned int part_num) 666 { 667 struct mmc *mmc = find_mmc_device(dev_num); 668 669 if (!mmc) 670 return -1; 671 672 return mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONF, 673 (mmc->part_config & ~PART_ACCESS_MASK) 674 | (part_num & PART_ACCESS_MASK)); 675 } 676 677 int sd_switch(struct mmc *mmc, int mode, int group, u8 value, u8 *resp) 678 { 679 struct mmc_cmd cmd; 680 struct mmc_data data; 681 682 /* Switch the frequency */ 683 cmd.cmdidx = SD_CMD_SWITCH_FUNC; 684 cmd.resp_type = MMC_RSP_R1; 685 cmd.cmdarg = (mode << 31) | 0xffffff; 686 cmd.cmdarg &= ~(0xf << (group * 4)); 687 cmd.cmdarg |= value << (group * 4); 688 cmd.flags = 0; 689 690 data.dest = (char *)resp; 691 data.blocksize = 64; 692 data.blocks = 1; 693 data.flags = MMC_DATA_READ; 694 695 return mmc_send_cmd(mmc, &cmd, &data); 696 } 697 698 699 int sd_change_freq(struct mmc *mmc) 700 { 701 int err; 702 struct mmc_cmd cmd; 703 ALLOC_CACHE_ALIGN_BUFFER(uint, scr, 2); 704 ALLOC_CACHE_ALIGN_BUFFER(uint, switch_status, 16); 705 struct mmc_data data; 706 int timeout; 707 708 mmc->card_caps = 0; 709 710 if (mmc_host_is_spi(mmc)) 711 return 0; 712 713 /* Read the SCR to find out if this card supports higher speeds */ 714 cmd.cmdidx = MMC_CMD_APP_CMD; 715 cmd.resp_type = MMC_RSP_R1; 716 cmd.cmdarg = mmc->rca << 16; 717 cmd.flags = 0; 718 719 err = mmc_send_cmd(mmc, &cmd, NULL); 720 721 if (err) 722 return err; 723 724 cmd.cmdidx = SD_CMD_APP_SEND_SCR; 725 cmd.resp_type = MMC_RSP_R1; 726 cmd.cmdarg = 0; 727 cmd.flags = 0; 728 729 timeout = 3; 730 731 retry_scr: 732 data.dest = (char *)scr; 733 data.blocksize = 8; 734 data.blocks = 1; 735 data.flags = MMC_DATA_READ; 736 737 err = mmc_send_cmd(mmc, &cmd, &data); 738 739 if (err) { 740 if (timeout--) 741 goto retry_scr; 742 743 return err; 744 } 745 746 mmc->scr[0] = __be32_to_cpu(scr[0]); 747 mmc->scr[1] = __be32_to_cpu(scr[1]); 748 749 switch ((mmc->scr[0] >> 24) & 0xf) { 750 case 0: 751 mmc->version = SD_VERSION_1_0; 752 break; 753 case 1: 754 mmc->version = SD_VERSION_1_10; 755 break; 756 case 2: 757 mmc->version = SD_VERSION_2; 758 break; 759 default: 760 mmc->version = SD_VERSION_1_0; 761 break; 762 } 763 764 if (mmc->scr[0] & SD_DATA_4BIT) 765 mmc->card_caps |= MMC_MODE_4BIT; 766 767 /* Version 1.0 doesn't support switching */ 768 if (mmc->version == SD_VERSION_1_0) 769 return 0; 770 771 timeout = 4; 772 while (timeout--) { 773 err = sd_switch(mmc, SD_SWITCH_CHECK, 0, 1, 774 (u8 *)switch_status); 775 776 if (err) 777 return err; 778 779 /* The high-speed function is busy. Try again */ 780 if (!(__be32_to_cpu(switch_status[7]) & SD_HIGHSPEED_BUSY)) 781 break; 782 } 783 784 /* If high-speed isn't supported, we return */ 785 if (!(__be32_to_cpu(switch_status[3]) & SD_HIGHSPEED_SUPPORTED)) 786 return 0; 787 788 err = sd_switch(mmc, SD_SWITCH_SWITCH, 0, 1, (u8 *)switch_status); 789 790 if (err) 791 return err; 792 793 if ((__be32_to_cpu(switch_status[4]) & 0x0f000000) == 0x01000000) 794 mmc->card_caps |= MMC_MODE_HS; 795 796 return 0; 797 } 798 799 /* frequency bases */ 800 /* divided by 10 to be nice to platforms without floating point */ 801 static const int fbase[] = { 802 10000, 803 100000, 804 1000000, 805 10000000, 806 }; 807 808 /* Multiplier values for TRAN_SPEED. Multiplied by 10 to be nice 809 * to platforms without floating point. 810 */ 811 static const int multipliers[] = { 812 0, /* reserved */ 813 10, 814 12, 815 13, 816 15, 817 20, 818 25, 819 30, 820 35, 821 40, 822 45, 823 50, 824 55, 825 60, 826 70, 827 80, 828 }; 829 830 void mmc_set_ios(struct mmc *mmc) 831 { 832 mmc->set_ios(mmc); 833 } 834 835 void mmc_set_clock(struct mmc *mmc, uint clock) 836 { 837 if (clock > mmc->f_max) 838 clock = mmc->f_max; 839 840 if (clock < mmc->f_min) 841 clock = mmc->f_min; 842 843 mmc->clock = clock; 844 845 mmc_set_ios(mmc); 846 } 847 848 void mmc_set_bus_width(struct mmc *mmc, uint width) 849 { 850 mmc->bus_width = width; 851 852 mmc_set_ios(mmc); 853 } 854 855 int mmc_startup(struct mmc *mmc) 856 { 857 int err, width; 858 uint mult, freq; 859 u64 cmult, csize, capacity; 860 struct mmc_cmd cmd; 861 ALLOC_CACHE_ALIGN_BUFFER(char, ext_csd, 512); 862 ALLOC_CACHE_ALIGN_BUFFER(char, test_csd, 512); 863 int timeout = 1000; 864 865 #ifdef CONFIG_MMC_SPI_CRC_ON 866 if (mmc_host_is_spi(mmc)) { /* enable CRC check for spi */ 867 cmd.cmdidx = MMC_CMD_SPI_CRC_ON_OFF; 868 cmd.resp_type = MMC_RSP_R1; 869 cmd.cmdarg = 1; 870 cmd.flags = 0; 871 err = mmc_send_cmd(mmc, &cmd, NULL); 872 873 if (err) 874 return err; 875 } 876 #endif 877 878 /* Put the Card in Identify Mode */ 879 cmd.cmdidx = mmc_host_is_spi(mmc) ? MMC_CMD_SEND_CID : 880 MMC_CMD_ALL_SEND_CID; /* cmd not supported in spi */ 881 cmd.resp_type = MMC_RSP_R2; 882 cmd.cmdarg = 0; 883 cmd.flags = 0; 884 885 err = mmc_send_cmd(mmc, &cmd, NULL); 886 887 if (err) 888 return err; 889 890 memcpy(mmc->cid, cmd.response, 16); 891 892 /* 893 * For MMC cards, set the Relative Address. 894 * For SD cards, get the Relatvie Address. 895 * This also puts the cards into Standby State 896 */ 897 if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */ 898 cmd.cmdidx = SD_CMD_SEND_RELATIVE_ADDR; 899 cmd.cmdarg = mmc->rca << 16; 900 cmd.resp_type = MMC_RSP_R6; 901 cmd.flags = 0; 902 903 err = mmc_send_cmd(mmc, &cmd, NULL); 904 905 if (err) 906 return err; 907 908 if (IS_SD(mmc)) 909 mmc->rca = (cmd.response[0] >> 16) & 0xffff; 910 } 911 912 /* Get the Card-Specific Data */ 913 cmd.cmdidx = MMC_CMD_SEND_CSD; 914 cmd.resp_type = MMC_RSP_R2; 915 cmd.cmdarg = mmc->rca << 16; 916 cmd.flags = 0; 917 918 err = mmc_send_cmd(mmc, &cmd, NULL); 919 920 /* Waiting for the ready status */ 921 mmc_send_status(mmc, timeout); 922 923 if (err) 924 return err; 925 926 mmc->csd[0] = cmd.response[0]; 927 mmc->csd[1] = cmd.response[1]; 928 mmc->csd[2] = cmd.response[2]; 929 mmc->csd[3] = cmd.response[3]; 930 931 if (mmc->version == MMC_VERSION_UNKNOWN) { 932 int version = (cmd.response[0] >> 26) & 0xf; 933 934 switch (version) { 935 case 0: 936 mmc->version = MMC_VERSION_1_2; 937 break; 938 case 1: 939 mmc->version = MMC_VERSION_1_4; 940 break; 941 case 2: 942 mmc->version = MMC_VERSION_2_2; 943 break; 944 case 3: 945 mmc->version = MMC_VERSION_3; 946 break; 947 case 4: 948 mmc->version = MMC_VERSION_4; 949 break; 950 default: 951 mmc->version = MMC_VERSION_1_2; 952 break; 953 } 954 } 955 956 /* divide frequency by 10, since the mults are 10x bigger */ 957 freq = fbase[(cmd.response[0] & 0x7)]; 958 mult = multipliers[((cmd.response[0] >> 3) & 0xf)]; 959 960 mmc->tran_speed = freq * mult; 961 962 mmc->read_bl_len = 1 << ((cmd.response[1] >> 16) & 0xf); 963 964 if (IS_SD(mmc)) 965 mmc->write_bl_len = mmc->read_bl_len; 966 else 967 mmc->write_bl_len = 1 << ((cmd.response[3] >> 22) & 0xf); 968 969 if (mmc->high_capacity) { 970 csize = (mmc->csd[1] & 0x3f) << 16 971 | (mmc->csd[2] & 0xffff0000) >> 16; 972 cmult = 8; 973 } else { 974 csize = (mmc->csd[1] & 0x3ff) << 2 975 | (mmc->csd[2] & 0xc0000000) >> 30; 976 cmult = (mmc->csd[2] & 0x00038000) >> 15; 977 } 978 979 mmc->capacity = (csize + 1) << (cmult + 2); 980 mmc->capacity *= mmc->read_bl_len; 981 982 if (mmc->read_bl_len > 512) 983 mmc->read_bl_len = 512; 984 985 if (mmc->write_bl_len > 512) 986 mmc->write_bl_len = 512; 987 988 /* Select the card, and put it into Transfer Mode */ 989 if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */ 990 cmd.cmdidx = MMC_CMD_SELECT_CARD; 991 cmd.resp_type = MMC_RSP_R1; 992 cmd.cmdarg = mmc->rca << 16; 993 cmd.flags = 0; 994 err = mmc_send_cmd(mmc, &cmd, NULL); 995 996 if (err) 997 return err; 998 } 999 1000 /* 1001 * For SD, its erase group is always one sector 1002 */ 1003 mmc->erase_grp_size = 1; 1004 mmc->part_config = MMCPART_NOAVAILABLE; 1005 if (!IS_SD(mmc) && (mmc->version >= MMC_VERSION_4)) { 1006 /* check ext_csd version and capacity */ 1007 err = mmc_send_ext_csd(mmc, ext_csd); 1008 if (!err & (ext_csd[EXT_CSD_REV] >= 2)) { 1009 /* 1010 * According to the JEDEC Standard, the value of 1011 * ext_csd's capacity is valid if the value is more 1012 * than 2GB 1013 */ 1014 capacity = ext_csd[EXT_CSD_SEC_CNT] << 0 1015 | ext_csd[EXT_CSD_SEC_CNT + 1] << 8 1016 | ext_csd[EXT_CSD_SEC_CNT + 2] << 16 1017 | ext_csd[EXT_CSD_SEC_CNT + 3] << 24; 1018 capacity *= 512; 1019 if ((capacity >> 20) > 2 * 1024) 1020 mmc->capacity = capacity; 1021 } 1022 1023 /* 1024 * Check whether GROUP_DEF is set, if yes, read out 1025 * group size from ext_csd directly, or calculate 1026 * the group size from the csd value. 1027 */ 1028 if (ext_csd[EXT_CSD_ERASE_GROUP_DEF]) 1029 mmc->erase_grp_size = 1030 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] * 512 * 1024; 1031 else { 1032 int erase_gsz, erase_gmul; 1033 erase_gsz = (mmc->csd[2] & 0x00007c00) >> 10; 1034 erase_gmul = (mmc->csd[2] & 0x000003e0) >> 5; 1035 mmc->erase_grp_size = (erase_gsz + 1) 1036 * (erase_gmul + 1); 1037 } 1038 1039 /* store the partition info of emmc */ 1040 if (ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & PART_SUPPORT) 1041 mmc->part_config = ext_csd[EXT_CSD_PART_CONF]; 1042 } 1043 1044 if (IS_SD(mmc)) 1045 err = sd_change_freq(mmc); 1046 else 1047 err = mmc_change_freq(mmc); 1048 1049 if (err) 1050 return err; 1051 1052 /* Restrict card's capabilities by what the host can do */ 1053 mmc->card_caps &= mmc->host_caps; 1054 1055 if (IS_SD(mmc)) { 1056 if (mmc->card_caps & MMC_MODE_4BIT) { 1057 cmd.cmdidx = MMC_CMD_APP_CMD; 1058 cmd.resp_type = MMC_RSP_R1; 1059 cmd.cmdarg = mmc->rca << 16; 1060 cmd.flags = 0; 1061 1062 err = mmc_send_cmd(mmc, &cmd, NULL); 1063 if (err) 1064 return err; 1065 1066 cmd.cmdidx = SD_CMD_APP_SET_BUS_WIDTH; 1067 cmd.resp_type = MMC_RSP_R1; 1068 cmd.cmdarg = 2; 1069 cmd.flags = 0; 1070 err = mmc_send_cmd(mmc, &cmd, NULL); 1071 if (err) 1072 return err; 1073 1074 mmc_set_bus_width(mmc, 4); 1075 } 1076 1077 if (mmc->card_caps & MMC_MODE_HS) 1078 mmc_set_clock(mmc, 50000000); 1079 else 1080 mmc_set_clock(mmc, 25000000); 1081 } else { 1082 for (width = EXT_CSD_BUS_WIDTH_8; width >= 0; width--) { 1083 /* Set the card to use 4 bit*/ 1084 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 1085 EXT_CSD_BUS_WIDTH, width); 1086 1087 if (err) 1088 continue; 1089 1090 if (!width) { 1091 mmc_set_bus_width(mmc, 1); 1092 break; 1093 } else 1094 mmc_set_bus_width(mmc, 4 * width); 1095 1096 err = mmc_send_ext_csd(mmc, test_csd); 1097 if (!err && ext_csd[EXT_CSD_PARTITIONING_SUPPORT] \ 1098 == test_csd[EXT_CSD_PARTITIONING_SUPPORT] 1099 && ext_csd[EXT_CSD_ERASE_GROUP_DEF] \ 1100 == test_csd[EXT_CSD_ERASE_GROUP_DEF] \ 1101 && ext_csd[EXT_CSD_REV] \ 1102 == test_csd[EXT_CSD_REV] 1103 && ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] \ 1104 == test_csd[EXT_CSD_HC_ERASE_GRP_SIZE] 1105 && memcmp(&ext_csd[EXT_CSD_SEC_CNT], \ 1106 &test_csd[EXT_CSD_SEC_CNT], 4) == 0) { 1107 1108 mmc->card_caps |= width; 1109 break; 1110 } 1111 } 1112 1113 if (mmc->card_caps & MMC_MODE_HS) { 1114 if (mmc->card_caps & MMC_MODE_HS_52MHz) 1115 mmc_set_clock(mmc, 52000000); 1116 else 1117 mmc_set_clock(mmc, 26000000); 1118 } else 1119 mmc_set_clock(mmc, 20000000); 1120 } 1121 1122 /* fill in device description */ 1123 mmc->block_dev.lun = 0; 1124 mmc->block_dev.type = 0; 1125 mmc->block_dev.blksz = mmc->read_bl_len; 1126 mmc->block_dev.lba = lldiv(mmc->capacity, mmc->read_bl_len); 1127 sprintf(mmc->block_dev.vendor, "Man %06x Snr %08x", mmc->cid[0] >> 8, 1128 (mmc->cid[2] << 8) | (mmc->cid[3] >> 24)); 1129 sprintf(mmc->block_dev.product, "%c%c%c%c%c", mmc->cid[0] & 0xff, 1130 (mmc->cid[1] >> 24), (mmc->cid[1] >> 16) & 0xff, 1131 (mmc->cid[1] >> 8) & 0xff, mmc->cid[1] & 0xff); 1132 sprintf(mmc->block_dev.revision, "%d.%d", mmc->cid[2] >> 28, 1133 (mmc->cid[2] >> 24) & 0xf); 1134 init_part(&mmc->block_dev); 1135 1136 return 0; 1137 } 1138 1139 int mmc_send_if_cond(struct mmc *mmc) 1140 { 1141 struct mmc_cmd cmd; 1142 int err; 1143 1144 cmd.cmdidx = SD_CMD_SEND_IF_COND; 1145 /* We set the bit if the host supports voltages between 2.7 and 3.6 V */ 1146 cmd.cmdarg = ((mmc->voltages & 0xff8000) != 0) << 8 | 0xaa; 1147 cmd.resp_type = MMC_RSP_R7; 1148 cmd.flags = 0; 1149 1150 err = mmc_send_cmd(mmc, &cmd, NULL); 1151 1152 if (err) 1153 return err; 1154 1155 if ((cmd.response[0] & 0xff) != 0xaa) 1156 return UNUSABLE_ERR; 1157 else 1158 mmc->version = SD_VERSION_2; 1159 1160 return 0; 1161 } 1162 1163 int mmc_register(struct mmc *mmc) 1164 { 1165 /* Setup the universal parts of the block interface just once */ 1166 mmc->block_dev.if_type = IF_TYPE_MMC; 1167 mmc->block_dev.dev = cur_dev_num++; 1168 mmc->block_dev.removable = 1; 1169 mmc->block_dev.block_read = mmc_bread; 1170 mmc->block_dev.block_write = mmc_bwrite; 1171 mmc->block_dev.block_erase = mmc_berase; 1172 if (!mmc->b_max) 1173 mmc->b_max = CONFIG_SYS_MMC_MAX_BLK_COUNT; 1174 1175 INIT_LIST_HEAD (&mmc->link); 1176 1177 list_add_tail (&mmc->link, &mmc_devices); 1178 1179 return 0; 1180 } 1181 1182 #ifdef CONFIG_PARTITIONS 1183 block_dev_desc_t *mmc_get_dev(int dev) 1184 { 1185 struct mmc *mmc = find_mmc_device(dev); 1186 1187 return mmc ? &mmc->block_dev : NULL; 1188 } 1189 #endif 1190 1191 int mmc_init(struct mmc *mmc) 1192 { 1193 int err, retry = 3; 1194 1195 if (mmc->has_init) 1196 return 0; 1197 1198 err = mmc->init(mmc); 1199 1200 if (err) 1201 return err; 1202 1203 mmc_set_bus_width(mmc, 1); 1204 mmc_set_clock(mmc, 1); 1205 1206 /* Reset the Card */ 1207 err = mmc_go_idle(mmc); 1208 1209 if (err) 1210 return err; 1211 1212 /* The internal partition reset to user partition(0) at every CMD0*/ 1213 mmc->part_num = 0; 1214 1215 /* Test for SD version 2 */ 1216 /* 1217 * retry here for 3 times, as for some controller it has dynamic 1218 * clock gating, and only toggle out clk when the first cmd0 send 1219 * out, while some card strictly obey the 74 clocks rule, the interval 1220 * may not be sufficient between the cmd0 and this cmd8, retry to 1221 * fulfil the clock requirement 1222 */ 1223 do { 1224 err = mmc_send_if_cond(mmc); 1225 } while (--retry > 0 && err); 1226 1227 if (err) 1228 return err; 1229 1230 /* Now try to get the SD card's operating condition */ 1231 err = sd_send_op_cond(mmc); 1232 1233 /* If the command timed out, we check for an MMC card */ 1234 if (err == TIMEOUT) { 1235 err = mmc_send_op_cond(mmc); 1236 1237 if (err) { 1238 printf("Card did not respond to voltage select!\n"); 1239 return UNUSABLE_ERR; 1240 } 1241 } 1242 1243 err = mmc_startup(mmc); 1244 if (err) 1245 mmc->has_init = 0; 1246 else 1247 mmc->has_init = 1; 1248 return err; 1249 } 1250 1251 /* 1252 * CPU and board-specific MMC initializations. Aliased function 1253 * signals caller to move on 1254 */ 1255 static int __def_mmc_init(bd_t *bis) 1256 { 1257 return -1; 1258 } 1259 1260 int cpu_mmc_init(bd_t *bis) __attribute__((weak, alias("__def_mmc_init"))); 1261 int board_mmc_init(bd_t *bis) __attribute__((weak, alias("__def_mmc_init"))); 1262 1263 void print_mmc_devices(char separator) 1264 { 1265 struct mmc *m; 1266 struct list_head *entry; 1267 1268 list_for_each(entry, &mmc_devices) { 1269 m = list_entry(entry, struct mmc, link); 1270 1271 printf("%s: %d", m->name, m->block_dev.dev); 1272 1273 if (entry->next != &mmc_devices) 1274 printf("%c ", separator); 1275 } 1276 1277 printf("\n"); 1278 } 1279 1280 int get_mmc_num(void) 1281 { 1282 return cur_dev_num; 1283 } 1284 1285 int mmc_initialize(bd_t *bis) 1286 { 1287 INIT_LIST_HEAD (&mmc_devices); 1288 cur_dev_num = 0; 1289 1290 if (board_mmc_init(bis) < 0) 1291 cpu_mmc_init(bis); 1292 1293 print_mmc_devices(','); 1294 1295 return 0; 1296 } 1297