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