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