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