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