1 /* 2 * Copyright 2008, Freescale Semiconductor, Inc 3 * Andy Fleming 4 * 5 * Based vaguely on the Linux code 6 * 7 * SPDX-License-Identifier: GPL-2.0+ 8 */ 9 10 #include <config.h> 11 #include <common.h> 12 #include <command.h> 13 #include <dm.h> 14 #include <dm/device-internal.h> 15 #include <errno.h> 16 #include <mmc.h> 17 #include <part.h> 18 #include <malloc.h> 19 #include <memalign.h> 20 #include <linux/list.h> 21 #include <div64.h> 22 #include "mmc_private.h" 23 24 __weak int board_mmc_getwp(struct mmc *mmc) 25 { 26 return -1; 27 } 28 29 int mmc_getwp(struct mmc *mmc) 30 { 31 int wp; 32 33 wp = board_mmc_getwp(mmc); 34 35 if (wp < 0) { 36 if (mmc->cfg->ops->getwp) 37 wp = mmc->cfg->ops->getwp(mmc); 38 else 39 wp = 0; 40 } 41 42 return wp; 43 } 44 45 __weak int board_mmc_getcd(struct mmc *mmc) 46 { 47 return -1; 48 } 49 50 int mmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data) 51 { 52 int ret; 53 54 #ifdef CONFIG_MMC_TRACE 55 int i; 56 u8 *ptr; 57 58 printf("CMD_SEND:%d\n", cmd->cmdidx); 59 printf("\t\tARG\t\t\t 0x%08X\n", cmd->cmdarg); 60 ret = mmc->cfg->ops->send_cmd(mmc, cmd, data); 61 if (ret) { 62 printf("\t\tRET\t\t\t %d\n", ret); 63 } else { 64 switch (cmd->resp_type) { 65 case MMC_RSP_NONE: 66 printf("\t\tMMC_RSP_NONE\n"); 67 break; 68 case MMC_RSP_R1: 69 printf("\t\tMMC_RSP_R1,5,6,7 \t 0x%08X \n", 70 cmd->response[0]); 71 break; 72 case MMC_RSP_R1b: 73 printf("\t\tMMC_RSP_R1b\t\t 0x%08X \n", 74 cmd->response[0]); 75 break; 76 case MMC_RSP_R2: 77 printf("\t\tMMC_RSP_R2\t\t 0x%08X \n", 78 cmd->response[0]); 79 printf("\t\t \t\t 0x%08X \n", 80 cmd->response[1]); 81 printf("\t\t \t\t 0x%08X \n", 82 cmd->response[2]); 83 printf("\t\t \t\t 0x%08X \n", 84 cmd->response[3]); 85 printf("\n"); 86 printf("\t\t\t\t\tDUMPING DATA\n"); 87 for (i = 0; i < 4; i++) { 88 int j; 89 printf("\t\t\t\t\t%03d - ", i*4); 90 ptr = (u8 *)&cmd->response[i]; 91 ptr += 3; 92 for (j = 0; j < 4; j++) 93 printf("%02X ", *ptr--); 94 printf("\n"); 95 } 96 break; 97 case MMC_RSP_R3: 98 printf("\t\tMMC_RSP_R3,4\t\t 0x%08X \n", 99 cmd->response[0]); 100 break; 101 default: 102 printf("\t\tERROR MMC rsp not supported\n"); 103 break; 104 } 105 } 106 #else 107 ret = mmc->cfg->ops->send_cmd(mmc, cmd, data); 108 #endif 109 return ret; 110 } 111 112 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 while (1) { 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 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 134 printf("Status Error: 0x%08X\n", 135 cmd.response[0]); 136 #endif 137 return COMM_ERR; 138 } 139 } else if (--retries < 0) 140 return err; 141 142 if (timeout-- <= 0) 143 break; 144 145 udelay(1000); 146 } 147 148 #ifdef CONFIG_MMC_TRACE 149 status = (cmd.response[0] & MMC_STATUS_CURR_STATE) >> 9; 150 printf("CURR STATE:%d\n", status); 151 #endif 152 if (timeout <= 0) { 153 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 154 printf("Timeout waiting card ready\n"); 155 #endif 156 return TIMEOUT; 157 } 158 159 return 0; 160 } 161 162 int mmc_set_blocklen(struct mmc *mmc, int len) 163 { 164 struct mmc_cmd cmd; 165 166 if (mmc->ddr_mode) 167 return 0; 168 169 cmd.cmdidx = MMC_CMD_SET_BLOCKLEN; 170 cmd.resp_type = MMC_RSP_R1; 171 cmd.cmdarg = len; 172 173 return mmc_send_cmd(mmc, &cmd, NULL); 174 } 175 176 static int mmc_read_blocks(struct mmc *mmc, void *dst, lbaint_t start, 177 lbaint_t blkcnt) 178 { 179 struct mmc_cmd cmd; 180 struct mmc_data data; 181 182 if (blkcnt > 1) 183 cmd.cmdidx = MMC_CMD_READ_MULTIPLE_BLOCK; 184 else 185 cmd.cmdidx = MMC_CMD_READ_SINGLE_BLOCK; 186 187 if (mmc->high_capacity) 188 cmd.cmdarg = start; 189 else 190 cmd.cmdarg = start * mmc->read_bl_len; 191 192 cmd.resp_type = MMC_RSP_R1; 193 194 data.dest = dst; 195 data.blocks = blkcnt; 196 data.blocksize = mmc->read_bl_len; 197 data.flags = MMC_DATA_READ; 198 199 if (mmc_send_cmd(mmc, &cmd, &data)) 200 return 0; 201 202 if (blkcnt > 1) { 203 cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION; 204 cmd.cmdarg = 0; 205 cmd.resp_type = MMC_RSP_R1b; 206 if (mmc_send_cmd(mmc, &cmd, NULL)) { 207 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 208 printf("mmc fail to send stop cmd\n"); 209 #endif 210 return 0; 211 } 212 } 213 214 return blkcnt; 215 } 216 217 #ifdef CONFIG_BLK 218 static ulong mmc_bread(struct udevice *dev, lbaint_t start, lbaint_t blkcnt, 219 void *dst) 220 #else 221 static ulong mmc_bread(struct blk_desc *block_dev, lbaint_t start, 222 lbaint_t blkcnt, void *dst) 223 #endif 224 { 225 #ifdef CONFIG_BLK 226 struct blk_desc *block_dev = dev_get_uclass_platdata(dev); 227 #endif 228 int dev_num = block_dev->devnum; 229 int err; 230 lbaint_t cur, blocks_todo = blkcnt; 231 232 if (blkcnt == 0) 233 return 0; 234 235 struct mmc *mmc = find_mmc_device(dev_num); 236 if (!mmc) 237 return 0; 238 239 err = blk_dselect_hwpart(block_dev, block_dev->hwpart); 240 if (err < 0) 241 return 0; 242 243 if ((start + blkcnt) > block_dev->lba) { 244 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 245 printf("MMC: block number 0x" LBAF " exceeds max(0x" LBAF ")\n", 246 start + blkcnt, block_dev->lba); 247 #endif 248 return 0; 249 } 250 251 if (mmc_set_blocklen(mmc, mmc->read_bl_len)) { 252 debug("%s: Failed to set blocklen\n", __func__); 253 return 0; 254 } 255 256 do { 257 cur = (blocks_todo > mmc->cfg->b_max) ? 258 mmc->cfg->b_max : blocks_todo; 259 if (mmc_read_blocks(mmc, dst, start, cur) != cur) { 260 debug("%s: Failed to read blocks\n", __func__); 261 return 0; 262 } 263 blocks_todo -= cur; 264 start += cur; 265 dst += cur * mmc->read_bl_len; 266 } while (blocks_todo > 0); 267 268 return blkcnt; 269 } 270 271 static int mmc_go_idle(struct mmc *mmc) 272 { 273 struct mmc_cmd cmd; 274 int err; 275 276 udelay(1000); 277 278 cmd.cmdidx = MMC_CMD_GO_IDLE_STATE; 279 cmd.cmdarg = 0; 280 cmd.resp_type = MMC_RSP_NONE; 281 282 err = mmc_send_cmd(mmc, &cmd, NULL); 283 284 if (err) 285 return err; 286 287 udelay(2000); 288 289 return 0; 290 } 291 292 static int sd_send_op_cond(struct mmc *mmc) 293 { 294 int timeout = 1000; 295 int err; 296 struct mmc_cmd cmd; 297 298 while (1) { 299 cmd.cmdidx = MMC_CMD_APP_CMD; 300 cmd.resp_type = MMC_RSP_R1; 301 cmd.cmdarg = 0; 302 303 err = mmc_send_cmd(mmc, &cmd, NULL); 304 305 if (err) 306 return err; 307 308 cmd.cmdidx = SD_CMD_APP_SEND_OP_COND; 309 cmd.resp_type = MMC_RSP_R3; 310 311 /* 312 * Most cards do not answer if some reserved bits 313 * in the ocr are set. However, Some controller 314 * can set bit 7 (reserved for low voltages), but 315 * how to manage low voltages SD card is not yet 316 * specified. 317 */ 318 cmd.cmdarg = mmc_host_is_spi(mmc) ? 0 : 319 (mmc->cfg->voltages & 0xff8000); 320 321 if (mmc->version == SD_VERSION_2) 322 cmd.cmdarg |= OCR_HCS; 323 324 err = mmc_send_cmd(mmc, &cmd, NULL); 325 326 if (err) 327 return err; 328 329 if (cmd.response[0] & OCR_BUSY) 330 break; 331 332 if (timeout-- <= 0) 333 return UNUSABLE_ERR; 334 335 udelay(1000); 336 } 337 338 if (mmc->version != SD_VERSION_2) 339 mmc->version = SD_VERSION_1_0; 340 341 if (mmc_host_is_spi(mmc)) { /* read OCR for spi */ 342 cmd.cmdidx = MMC_CMD_SPI_READ_OCR; 343 cmd.resp_type = MMC_RSP_R3; 344 cmd.cmdarg = 0; 345 346 err = mmc_send_cmd(mmc, &cmd, NULL); 347 348 if (err) 349 return err; 350 } 351 352 mmc->ocr = cmd.response[0]; 353 354 mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS); 355 mmc->rca = 0; 356 357 return 0; 358 } 359 360 static int mmc_send_op_cond_iter(struct mmc *mmc, int use_arg) 361 { 362 struct mmc_cmd cmd; 363 int err; 364 365 cmd.cmdidx = MMC_CMD_SEND_OP_COND; 366 cmd.resp_type = MMC_RSP_R3; 367 cmd.cmdarg = 0; 368 if (use_arg && !mmc_host_is_spi(mmc)) 369 cmd.cmdarg = OCR_HCS | 370 (mmc->cfg->voltages & 371 (mmc->ocr & OCR_VOLTAGE_MASK)) | 372 (mmc->ocr & OCR_ACCESS_MODE); 373 374 err = mmc_send_cmd(mmc, &cmd, NULL); 375 if (err) 376 return err; 377 mmc->ocr = cmd.response[0]; 378 return 0; 379 } 380 381 static int mmc_send_op_cond(struct mmc *mmc) 382 { 383 int err, i; 384 385 /* Some cards seem to need this */ 386 mmc_go_idle(mmc); 387 388 /* Asking to the card its capabilities */ 389 for (i = 0; i < 2; i++) { 390 err = mmc_send_op_cond_iter(mmc, i != 0); 391 if (err) 392 return err; 393 394 /* exit if not busy (flag seems to be inverted) */ 395 if (mmc->ocr & OCR_BUSY) 396 break; 397 } 398 mmc->op_cond_pending = 1; 399 return 0; 400 } 401 402 static int mmc_complete_op_cond(struct mmc *mmc) 403 { 404 struct mmc_cmd cmd; 405 int timeout = 1000; 406 uint start; 407 int err; 408 409 mmc->op_cond_pending = 0; 410 if (!(mmc->ocr & OCR_BUSY)) { 411 start = get_timer(0); 412 while (1) { 413 err = mmc_send_op_cond_iter(mmc, 1); 414 if (err) 415 return err; 416 if (mmc->ocr & OCR_BUSY) 417 break; 418 if (get_timer(start) > timeout) 419 return UNUSABLE_ERR; 420 udelay(100); 421 } 422 } 423 424 if (mmc_host_is_spi(mmc)) { /* read OCR for spi */ 425 cmd.cmdidx = MMC_CMD_SPI_READ_OCR; 426 cmd.resp_type = MMC_RSP_R3; 427 cmd.cmdarg = 0; 428 429 err = mmc_send_cmd(mmc, &cmd, NULL); 430 431 if (err) 432 return err; 433 434 mmc->ocr = cmd.response[0]; 435 } 436 437 mmc->version = MMC_VERSION_UNKNOWN; 438 439 mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS); 440 mmc->rca = 1; 441 442 return 0; 443 } 444 445 446 static int mmc_send_ext_csd(struct mmc *mmc, u8 *ext_csd) 447 { 448 struct mmc_cmd cmd; 449 struct mmc_data data; 450 int err; 451 452 /* Get the Card Status Register */ 453 cmd.cmdidx = MMC_CMD_SEND_EXT_CSD; 454 cmd.resp_type = MMC_RSP_R1; 455 cmd.cmdarg = 0; 456 457 data.dest = (char *)ext_csd; 458 data.blocks = 1; 459 data.blocksize = MMC_MAX_BLOCK_LEN; 460 data.flags = MMC_DATA_READ; 461 462 err = mmc_send_cmd(mmc, &cmd, &data); 463 464 return err; 465 } 466 467 468 static int mmc_switch(struct mmc *mmc, u8 set, u8 index, u8 value) 469 { 470 struct mmc_cmd cmd; 471 int timeout = 1000; 472 int ret; 473 474 cmd.cmdidx = MMC_CMD_SWITCH; 475 cmd.resp_type = MMC_RSP_R1b; 476 cmd.cmdarg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) | 477 (index << 16) | 478 (value << 8); 479 480 ret = mmc_send_cmd(mmc, &cmd, NULL); 481 482 /* Waiting for the ready status */ 483 if (!ret) 484 ret = mmc_send_status(mmc, timeout); 485 486 return ret; 487 488 } 489 490 static int mmc_change_freq(struct mmc *mmc) 491 { 492 ALLOC_CACHE_ALIGN_BUFFER(u8, ext_csd, MMC_MAX_BLOCK_LEN); 493 char cardtype; 494 int err; 495 496 mmc->card_caps = 0; 497 498 if (mmc_host_is_spi(mmc)) 499 return 0; 500 501 /* Only version 4 supports high-speed */ 502 if (mmc->version < MMC_VERSION_4) 503 return 0; 504 505 mmc->card_caps |= MMC_MODE_4BIT | MMC_MODE_8BIT; 506 507 err = mmc_send_ext_csd(mmc, ext_csd); 508 509 if (err) 510 return err; 511 512 cardtype = ext_csd[EXT_CSD_CARD_TYPE] & 0xf; 513 514 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING, 1); 515 516 if (err) 517 return err; 518 519 /* Now check to see that it worked */ 520 err = mmc_send_ext_csd(mmc, ext_csd); 521 522 if (err) 523 return err; 524 525 /* No high-speed support */ 526 if (!ext_csd[EXT_CSD_HS_TIMING]) 527 return 0; 528 529 /* High Speed is set, there are two types: 52MHz and 26MHz */ 530 if (cardtype & EXT_CSD_CARD_TYPE_52) { 531 if (cardtype & EXT_CSD_CARD_TYPE_DDR_1_8V) 532 mmc->card_caps |= MMC_MODE_DDR_52MHz; 533 mmc->card_caps |= MMC_MODE_HS_52MHz | MMC_MODE_HS; 534 } else { 535 mmc->card_caps |= MMC_MODE_HS; 536 } 537 538 return 0; 539 } 540 541 static int mmc_set_capacity(struct mmc *mmc, int part_num) 542 { 543 switch (part_num) { 544 case 0: 545 mmc->capacity = mmc->capacity_user; 546 break; 547 case 1: 548 case 2: 549 mmc->capacity = mmc->capacity_boot; 550 break; 551 case 3: 552 mmc->capacity = mmc->capacity_rpmb; 553 break; 554 case 4: 555 case 5: 556 case 6: 557 case 7: 558 mmc->capacity = mmc->capacity_gp[part_num - 4]; 559 break; 560 default: 561 return -1; 562 } 563 564 mmc_get_blk_desc(mmc)->lba = lldiv(mmc->capacity, mmc->read_bl_len); 565 566 return 0; 567 } 568 569 static int mmc_switch_part(struct mmc *mmc, unsigned int part_num) 570 { 571 int ret; 572 573 ret = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONF, 574 (mmc->part_config & ~PART_ACCESS_MASK) 575 | (part_num & PART_ACCESS_MASK)); 576 577 /* 578 * Set the capacity if the switch succeeded or was intended 579 * to return to representing the raw device. 580 */ 581 if ((ret == 0) || ((ret == -ENODEV) && (part_num == 0))) { 582 ret = mmc_set_capacity(mmc, part_num); 583 mmc_get_blk_desc(mmc)->hwpart = part_num; 584 } 585 586 return ret; 587 } 588 589 #ifdef CONFIG_BLK 590 static int mmc_select_hwpart(struct udevice *bdev, int hwpart) 591 { 592 struct udevice *mmc_dev = dev_get_parent(bdev); 593 struct mmc *mmc = mmc_get_mmc_dev(mmc_dev); 594 struct blk_desc *desc = dev_get_uclass_platdata(bdev); 595 int ret; 596 597 if (desc->hwpart == hwpart) 598 return 0; 599 600 if (mmc->part_config == MMCPART_NOAVAILABLE) 601 return -EMEDIUMTYPE; 602 603 ret = mmc_switch_part(mmc, hwpart); 604 if (ret) 605 return ret; 606 607 return 0; 608 } 609 #else 610 static int mmc_select_hwpartp(struct blk_desc *desc, int hwpart) 611 { 612 struct mmc *mmc = find_mmc_device(desc->devnum); 613 int ret; 614 615 if (!mmc) 616 return -ENODEV; 617 618 if (mmc->block_dev.hwpart == hwpart) 619 return 0; 620 621 if (mmc->part_config == MMCPART_NOAVAILABLE) 622 return -EMEDIUMTYPE; 623 624 ret = mmc_switch_part(mmc, hwpart); 625 if (ret) 626 return ret; 627 628 return 0; 629 } 630 #endif 631 632 int mmc_hwpart_config(struct mmc *mmc, 633 const struct mmc_hwpart_conf *conf, 634 enum mmc_hwpart_conf_mode mode) 635 { 636 u8 part_attrs = 0; 637 u32 enh_size_mult; 638 u32 enh_start_addr; 639 u32 gp_size_mult[4]; 640 u32 max_enh_size_mult; 641 u32 tot_enh_size_mult = 0; 642 u8 wr_rel_set; 643 int i, pidx, err; 644 ALLOC_CACHE_ALIGN_BUFFER(u8, ext_csd, MMC_MAX_BLOCK_LEN); 645 646 if (mode < MMC_HWPART_CONF_CHECK || mode > MMC_HWPART_CONF_COMPLETE) 647 return -EINVAL; 648 649 if (IS_SD(mmc) || (mmc->version < MMC_VERSION_4_41)) { 650 printf("eMMC >= 4.4 required for enhanced user data area\n"); 651 return -EMEDIUMTYPE; 652 } 653 654 if (!(mmc->part_support & PART_SUPPORT)) { 655 printf("Card does not support partitioning\n"); 656 return -EMEDIUMTYPE; 657 } 658 659 if (!mmc->hc_wp_grp_size) { 660 printf("Card does not define HC WP group size\n"); 661 return -EMEDIUMTYPE; 662 } 663 664 /* check partition alignment and total enhanced size */ 665 if (conf->user.enh_size) { 666 if (conf->user.enh_size % mmc->hc_wp_grp_size || 667 conf->user.enh_start % mmc->hc_wp_grp_size) { 668 printf("User data enhanced area not HC WP group " 669 "size aligned\n"); 670 return -EINVAL; 671 } 672 part_attrs |= EXT_CSD_ENH_USR; 673 enh_size_mult = conf->user.enh_size / mmc->hc_wp_grp_size; 674 if (mmc->high_capacity) { 675 enh_start_addr = conf->user.enh_start; 676 } else { 677 enh_start_addr = (conf->user.enh_start << 9); 678 } 679 } else { 680 enh_size_mult = 0; 681 enh_start_addr = 0; 682 } 683 tot_enh_size_mult += enh_size_mult; 684 685 for (pidx = 0; pidx < 4; pidx++) { 686 if (conf->gp_part[pidx].size % mmc->hc_wp_grp_size) { 687 printf("GP%i partition not HC WP group size " 688 "aligned\n", pidx+1); 689 return -EINVAL; 690 } 691 gp_size_mult[pidx] = conf->gp_part[pidx].size / mmc->hc_wp_grp_size; 692 if (conf->gp_part[pidx].size && conf->gp_part[pidx].enhanced) { 693 part_attrs |= EXT_CSD_ENH_GP(pidx); 694 tot_enh_size_mult += gp_size_mult[pidx]; 695 } 696 } 697 698 if (part_attrs && ! (mmc->part_support & ENHNCD_SUPPORT)) { 699 printf("Card does not support enhanced attribute\n"); 700 return -EMEDIUMTYPE; 701 } 702 703 err = mmc_send_ext_csd(mmc, ext_csd); 704 if (err) 705 return err; 706 707 max_enh_size_mult = 708 (ext_csd[EXT_CSD_MAX_ENH_SIZE_MULT+2] << 16) + 709 (ext_csd[EXT_CSD_MAX_ENH_SIZE_MULT+1] << 8) + 710 ext_csd[EXT_CSD_MAX_ENH_SIZE_MULT]; 711 if (tot_enh_size_mult > max_enh_size_mult) { 712 printf("Total enhanced size exceeds maximum (%u > %u)\n", 713 tot_enh_size_mult, max_enh_size_mult); 714 return -EMEDIUMTYPE; 715 } 716 717 /* The default value of EXT_CSD_WR_REL_SET is device 718 * dependent, the values can only be changed if the 719 * EXT_CSD_HS_CTRL_REL bit is set. The values can be 720 * changed only once and before partitioning is completed. */ 721 wr_rel_set = ext_csd[EXT_CSD_WR_REL_SET]; 722 if (conf->user.wr_rel_change) { 723 if (conf->user.wr_rel_set) 724 wr_rel_set |= EXT_CSD_WR_DATA_REL_USR; 725 else 726 wr_rel_set &= ~EXT_CSD_WR_DATA_REL_USR; 727 } 728 for (pidx = 0; pidx < 4; pidx++) { 729 if (conf->gp_part[pidx].wr_rel_change) { 730 if (conf->gp_part[pidx].wr_rel_set) 731 wr_rel_set |= EXT_CSD_WR_DATA_REL_GP(pidx); 732 else 733 wr_rel_set &= ~EXT_CSD_WR_DATA_REL_GP(pidx); 734 } 735 } 736 737 if (wr_rel_set != ext_csd[EXT_CSD_WR_REL_SET] && 738 !(ext_csd[EXT_CSD_WR_REL_PARAM] & EXT_CSD_HS_CTRL_REL)) { 739 puts("Card does not support host controlled partition write " 740 "reliability settings\n"); 741 return -EMEDIUMTYPE; 742 } 743 744 if (ext_csd[EXT_CSD_PARTITION_SETTING] & 745 EXT_CSD_PARTITION_SETTING_COMPLETED) { 746 printf("Card already partitioned\n"); 747 return -EPERM; 748 } 749 750 if (mode == MMC_HWPART_CONF_CHECK) 751 return 0; 752 753 /* Partitioning requires high-capacity size definitions */ 754 if (!(ext_csd[EXT_CSD_ERASE_GROUP_DEF] & 0x01)) { 755 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 756 EXT_CSD_ERASE_GROUP_DEF, 1); 757 758 if (err) 759 return err; 760 761 ext_csd[EXT_CSD_ERASE_GROUP_DEF] = 1; 762 763 /* update erase group size to be high-capacity */ 764 mmc->erase_grp_size = 765 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] * 1024; 766 767 } 768 769 /* all OK, write the configuration */ 770 for (i = 0; i < 4; i++) { 771 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 772 EXT_CSD_ENH_START_ADDR+i, 773 (enh_start_addr >> (i*8)) & 0xFF); 774 if (err) 775 return err; 776 } 777 for (i = 0; i < 3; i++) { 778 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 779 EXT_CSD_ENH_SIZE_MULT+i, 780 (enh_size_mult >> (i*8)) & 0xFF); 781 if (err) 782 return err; 783 } 784 for (pidx = 0; pidx < 4; pidx++) { 785 for (i = 0; i < 3; i++) { 786 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 787 EXT_CSD_GP_SIZE_MULT+pidx*3+i, 788 (gp_size_mult[pidx] >> (i*8)) & 0xFF); 789 if (err) 790 return err; 791 } 792 } 793 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 794 EXT_CSD_PARTITIONS_ATTRIBUTE, part_attrs); 795 if (err) 796 return err; 797 798 if (mode == MMC_HWPART_CONF_SET) 799 return 0; 800 801 /* The WR_REL_SET is a write-once register but shall be 802 * written before setting PART_SETTING_COMPLETED. As it is 803 * write-once we can only write it when completing the 804 * partitioning. */ 805 if (wr_rel_set != ext_csd[EXT_CSD_WR_REL_SET]) { 806 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 807 EXT_CSD_WR_REL_SET, wr_rel_set); 808 if (err) 809 return err; 810 } 811 812 /* Setting PART_SETTING_COMPLETED confirms the partition 813 * configuration but it only becomes effective after power 814 * cycle, so we do not adjust the partition related settings 815 * in the mmc struct. */ 816 817 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 818 EXT_CSD_PARTITION_SETTING, 819 EXT_CSD_PARTITION_SETTING_COMPLETED); 820 if (err) 821 return err; 822 823 return 0; 824 } 825 826 int mmc_getcd(struct mmc *mmc) 827 { 828 int cd; 829 830 cd = board_mmc_getcd(mmc); 831 832 if (cd < 0) { 833 if (mmc->cfg->ops->getcd) 834 cd = mmc->cfg->ops->getcd(mmc); 835 else 836 cd = 1; 837 } 838 839 return cd; 840 } 841 842 static int sd_switch(struct mmc *mmc, int mode, int group, u8 value, u8 *resp) 843 { 844 struct mmc_cmd cmd; 845 struct mmc_data data; 846 847 /* Switch the frequency */ 848 cmd.cmdidx = SD_CMD_SWITCH_FUNC; 849 cmd.resp_type = MMC_RSP_R1; 850 cmd.cmdarg = (mode << 31) | 0xffffff; 851 cmd.cmdarg &= ~(0xf << (group * 4)); 852 cmd.cmdarg |= value << (group * 4); 853 854 data.dest = (char *)resp; 855 data.blocksize = 64; 856 data.blocks = 1; 857 data.flags = MMC_DATA_READ; 858 859 return mmc_send_cmd(mmc, &cmd, &data); 860 } 861 862 863 static int sd_change_freq(struct mmc *mmc) 864 { 865 int err; 866 struct mmc_cmd cmd; 867 ALLOC_CACHE_ALIGN_BUFFER(uint, scr, 2); 868 ALLOC_CACHE_ALIGN_BUFFER(uint, switch_status, 16); 869 struct mmc_data data; 870 int timeout; 871 872 mmc->card_caps = 0; 873 874 if (mmc_host_is_spi(mmc)) 875 return 0; 876 877 /* Read the SCR to find out if this card supports higher speeds */ 878 cmd.cmdidx = MMC_CMD_APP_CMD; 879 cmd.resp_type = MMC_RSP_R1; 880 cmd.cmdarg = mmc->rca << 16; 881 882 err = mmc_send_cmd(mmc, &cmd, NULL); 883 884 if (err) 885 return err; 886 887 cmd.cmdidx = SD_CMD_APP_SEND_SCR; 888 cmd.resp_type = MMC_RSP_R1; 889 cmd.cmdarg = 0; 890 891 timeout = 3; 892 893 retry_scr: 894 data.dest = (char *)scr; 895 data.blocksize = 8; 896 data.blocks = 1; 897 data.flags = MMC_DATA_READ; 898 899 err = mmc_send_cmd(mmc, &cmd, &data); 900 901 if (err) { 902 if (timeout--) 903 goto retry_scr; 904 905 return err; 906 } 907 908 mmc->scr[0] = __be32_to_cpu(scr[0]); 909 mmc->scr[1] = __be32_to_cpu(scr[1]); 910 911 switch ((mmc->scr[0] >> 24) & 0xf) { 912 case 0: 913 mmc->version = SD_VERSION_1_0; 914 break; 915 case 1: 916 mmc->version = SD_VERSION_1_10; 917 break; 918 case 2: 919 mmc->version = SD_VERSION_2; 920 if ((mmc->scr[0] >> 15) & 0x1) 921 mmc->version = SD_VERSION_3; 922 break; 923 default: 924 mmc->version = SD_VERSION_1_0; 925 break; 926 } 927 928 if (mmc->scr[0] & SD_DATA_4BIT) 929 mmc->card_caps |= MMC_MODE_4BIT; 930 931 /* Version 1.0 doesn't support switching */ 932 if (mmc->version == SD_VERSION_1_0) 933 return 0; 934 935 timeout = 4; 936 while (timeout--) { 937 err = sd_switch(mmc, SD_SWITCH_CHECK, 0, 1, 938 (u8 *)switch_status); 939 940 if (err) 941 return err; 942 943 /* The high-speed function is busy. Try again */ 944 if (!(__be32_to_cpu(switch_status[7]) & SD_HIGHSPEED_BUSY)) 945 break; 946 } 947 948 /* If high-speed isn't supported, we return */ 949 if (!(__be32_to_cpu(switch_status[3]) & SD_HIGHSPEED_SUPPORTED)) 950 return 0; 951 952 /* 953 * If the host doesn't support SD_HIGHSPEED, do not switch card to 954 * HIGHSPEED mode even if the card support SD_HIGHSPPED. 955 * This can avoid furthur problem when the card runs in different 956 * mode between the host. 957 */ 958 if (!((mmc->cfg->host_caps & MMC_MODE_HS_52MHz) && 959 (mmc->cfg->host_caps & MMC_MODE_HS))) 960 return 0; 961 962 err = sd_switch(mmc, SD_SWITCH_SWITCH, 0, 1, (u8 *)switch_status); 963 964 if (err) 965 return err; 966 967 if ((__be32_to_cpu(switch_status[4]) & 0x0f000000) == 0x01000000) 968 mmc->card_caps |= MMC_MODE_HS; 969 970 return 0; 971 } 972 973 /* frequency bases */ 974 /* divided by 10 to be nice to platforms without floating point */ 975 static const int fbase[] = { 976 10000, 977 100000, 978 1000000, 979 10000000, 980 }; 981 982 /* Multiplier values for TRAN_SPEED. Multiplied by 10 to be nice 983 * to platforms without floating point. 984 */ 985 static const u8 multipliers[] = { 986 0, /* reserved */ 987 10, 988 12, 989 13, 990 15, 991 20, 992 25, 993 30, 994 35, 995 40, 996 45, 997 50, 998 55, 999 60, 1000 70, 1001 80, 1002 }; 1003 1004 static void mmc_set_ios(struct mmc *mmc) 1005 { 1006 if (mmc->cfg->ops->set_ios) 1007 mmc->cfg->ops->set_ios(mmc); 1008 } 1009 1010 void mmc_set_clock(struct mmc *mmc, uint clock) 1011 { 1012 if (clock > mmc->cfg->f_max) 1013 clock = mmc->cfg->f_max; 1014 1015 if (clock < mmc->cfg->f_min) 1016 clock = mmc->cfg->f_min; 1017 1018 mmc->clock = clock; 1019 1020 mmc_set_ios(mmc); 1021 } 1022 1023 static void mmc_set_bus_width(struct mmc *mmc, uint width) 1024 { 1025 mmc->bus_width = width; 1026 1027 mmc_set_ios(mmc); 1028 } 1029 1030 static int mmc_startup(struct mmc *mmc) 1031 { 1032 int err, i; 1033 uint mult, freq; 1034 u64 cmult, csize, capacity; 1035 struct mmc_cmd cmd; 1036 ALLOC_CACHE_ALIGN_BUFFER(u8, ext_csd, MMC_MAX_BLOCK_LEN); 1037 ALLOC_CACHE_ALIGN_BUFFER(u8, test_csd, MMC_MAX_BLOCK_LEN); 1038 int timeout = 1000; 1039 bool has_parts = false; 1040 bool part_completed; 1041 struct blk_desc *bdesc; 1042 1043 #ifdef CONFIG_MMC_SPI_CRC_ON 1044 if (mmc_host_is_spi(mmc)) { /* enable CRC check for spi */ 1045 cmd.cmdidx = MMC_CMD_SPI_CRC_ON_OFF; 1046 cmd.resp_type = MMC_RSP_R1; 1047 cmd.cmdarg = 1; 1048 err = mmc_send_cmd(mmc, &cmd, NULL); 1049 1050 if (err) 1051 return err; 1052 } 1053 #endif 1054 1055 /* Put the Card in Identify Mode */ 1056 cmd.cmdidx = mmc_host_is_spi(mmc) ? MMC_CMD_SEND_CID : 1057 MMC_CMD_ALL_SEND_CID; /* cmd not supported in spi */ 1058 cmd.resp_type = MMC_RSP_R2; 1059 cmd.cmdarg = 0; 1060 1061 err = mmc_send_cmd(mmc, &cmd, NULL); 1062 1063 if (err) 1064 return err; 1065 1066 memcpy(mmc->cid, cmd.response, 16); 1067 1068 /* 1069 * For MMC cards, set the Relative Address. 1070 * For SD cards, get the Relatvie Address. 1071 * This also puts the cards into Standby State 1072 */ 1073 if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */ 1074 cmd.cmdidx = SD_CMD_SEND_RELATIVE_ADDR; 1075 cmd.cmdarg = mmc->rca << 16; 1076 cmd.resp_type = MMC_RSP_R6; 1077 1078 err = mmc_send_cmd(mmc, &cmd, NULL); 1079 1080 if (err) 1081 return err; 1082 1083 if (IS_SD(mmc)) 1084 mmc->rca = (cmd.response[0] >> 16) & 0xffff; 1085 } 1086 1087 /* Get the Card-Specific Data */ 1088 cmd.cmdidx = MMC_CMD_SEND_CSD; 1089 cmd.resp_type = MMC_RSP_R2; 1090 cmd.cmdarg = mmc->rca << 16; 1091 1092 err = mmc_send_cmd(mmc, &cmd, NULL); 1093 1094 /* Waiting for the ready status */ 1095 mmc_send_status(mmc, timeout); 1096 1097 if (err) 1098 return err; 1099 1100 mmc->csd[0] = cmd.response[0]; 1101 mmc->csd[1] = cmd.response[1]; 1102 mmc->csd[2] = cmd.response[2]; 1103 mmc->csd[3] = cmd.response[3]; 1104 1105 if (mmc->version == MMC_VERSION_UNKNOWN) { 1106 int version = (cmd.response[0] >> 26) & 0xf; 1107 1108 switch (version) { 1109 case 0: 1110 mmc->version = MMC_VERSION_1_2; 1111 break; 1112 case 1: 1113 mmc->version = MMC_VERSION_1_4; 1114 break; 1115 case 2: 1116 mmc->version = MMC_VERSION_2_2; 1117 break; 1118 case 3: 1119 mmc->version = MMC_VERSION_3; 1120 break; 1121 case 4: 1122 mmc->version = MMC_VERSION_4; 1123 break; 1124 default: 1125 mmc->version = MMC_VERSION_1_2; 1126 break; 1127 } 1128 } 1129 1130 /* divide frequency by 10, since the mults are 10x bigger */ 1131 freq = fbase[(cmd.response[0] & 0x7)]; 1132 mult = multipliers[((cmd.response[0] >> 3) & 0xf)]; 1133 1134 mmc->tran_speed = freq * mult; 1135 1136 mmc->dsr_imp = ((cmd.response[1] >> 12) & 0x1); 1137 mmc->read_bl_len = 1 << ((cmd.response[1] >> 16) & 0xf); 1138 1139 if (IS_SD(mmc)) 1140 mmc->write_bl_len = mmc->read_bl_len; 1141 else 1142 mmc->write_bl_len = 1 << ((cmd.response[3] >> 22) & 0xf); 1143 1144 if (mmc->high_capacity) { 1145 csize = (mmc->csd[1] & 0x3f) << 16 1146 | (mmc->csd[2] & 0xffff0000) >> 16; 1147 cmult = 8; 1148 } else { 1149 csize = (mmc->csd[1] & 0x3ff) << 2 1150 | (mmc->csd[2] & 0xc0000000) >> 30; 1151 cmult = (mmc->csd[2] & 0x00038000) >> 15; 1152 } 1153 1154 mmc->capacity_user = (csize + 1) << (cmult + 2); 1155 mmc->capacity_user *= mmc->read_bl_len; 1156 mmc->capacity_boot = 0; 1157 mmc->capacity_rpmb = 0; 1158 for (i = 0; i < 4; i++) 1159 mmc->capacity_gp[i] = 0; 1160 1161 if (mmc->read_bl_len > MMC_MAX_BLOCK_LEN) 1162 mmc->read_bl_len = MMC_MAX_BLOCK_LEN; 1163 1164 if (mmc->write_bl_len > MMC_MAX_BLOCK_LEN) 1165 mmc->write_bl_len = MMC_MAX_BLOCK_LEN; 1166 1167 if ((mmc->dsr_imp) && (0xffffffff != mmc->dsr)) { 1168 cmd.cmdidx = MMC_CMD_SET_DSR; 1169 cmd.cmdarg = (mmc->dsr & 0xffff) << 16; 1170 cmd.resp_type = MMC_RSP_NONE; 1171 if (mmc_send_cmd(mmc, &cmd, NULL)) 1172 printf("MMC: SET_DSR failed\n"); 1173 } 1174 1175 /* Select the card, and put it into Transfer Mode */ 1176 if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */ 1177 cmd.cmdidx = MMC_CMD_SELECT_CARD; 1178 cmd.resp_type = MMC_RSP_R1; 1179 cmd.cmdarg = mmc->rca << 16; 1180 err = mmc_send_cmd(mmc, &cmd, NULL); 1181 1182 if (err) 1183 return err; 1184 } 1185 1186 /* 1187 * For SD, its erase group is always one sector 1188 */ 1189 mmc->erase_grp_size = 1; 1190 mmc->part_config = MMCPART_NOAVAILABLE; 1191 if (!IS_SD(mmc) && (mmc->version >= MMC_VERSION_4)) { 1192 /* check ext_csd version and capacity */ 1193 err = mmc_send_ext_csd(mmc, ext_csd); 1194 if (err) 1195 return err; 1196 if (ext_csd[EXT_CSD_REV] >= 2) { 1197 /* 1198 * According to the JEDEC Standard, the value of 1199 * ext_csd's capacity is valid if the value is more 1200 * than 2GB 1201 */ 1202 capacity = ext_csd[EXT_CSD_SEC_CNT] << 0 1203 | ext_csd[EXT_CSD_SEC_CNT + 1] << 8 1204 | ext_csd[EXT_CSD_SEC_CNT + 2] << 16 1205 | ext_csd[EXT_CSD_SEC_CNT + 3] << 24; 1206 capacity *= MMC_MAX_BLOCK_LEN; 1207 if ((capacity >> 20) > 2 * 1024) 1208 mmc->capacity_user = capacity; 1209 } 1210 1211 switch (ext_csd[EXT_CSD_REV]) { 1212 case 1: 1213 mmc->version = MMC_VERSION_4_1; 1214 break; 1215 case 2: 1216 mmc->version = MMC_VERSION_4_2; 1217 break; 1218 case 3: 1219 mmc->version = MMC_VERSION_4_3; 1220 break; 1221 case 5: 1222 mmc->version = MMC_VERSION_4_41; 1223 break; 1224 case 6: 1225 mmc->version = MMC_VERSION_4_5; 1226 break; 1227 case 7: 1228 mmc->version = MMC_VERSION_5_0; 1229 break; 1230 case 8: 1231 mmc->version = MMC_VERSION_5_1; 1232 break; 1233 } 1234 1235 /* The partition data may be non-zero but it is only 1236 * effective if PARTITION_SETTING_COMPLETED is set in 1237 * EXT_CSD, so ignore any data if this bit is not set, 1238 * except for enabling the high-capacity group size 1239 * definition (see below). */ 1240 part_completed = !!(ext_csd[EXT_CSD_PARTITION_SETTING] & 1241 EXT_CSD_PARTITION_SETTING_COMPLETED); 1242 1243 /* store the partition info of emmc */ 1244 mmc->part_support = ext_csd[EXT_CSD_PARTITIONING_SUPPORT]; 1245 if ((ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & PART_SUPPORT) || 1246 ext_csd[EXT_CSD_BOOT_MULT]) 1247 mmc->part_config = ext_csd[EXT_CSD_PART_CONF]; 1248 if (part_completed && 1249 (ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & ENHNCD_SUPPORT)) 1250 mmc->part_attr = ext_csd[EXT_CSD_PARTITIONS_ATTRIBUTE]; 1251 1252 mmc->capacity_boot = ext_csd[EXT_CSD_BOOT_MULT] << 17; 1253 1254 mmc->capacity_rpmb = ext_csd[EXT_CSD_RPMB_MULT] << 17; 1255 1256 for (i = 0; i < 4; i++) { 1257 int idx = EXT_CSD_GP_SIZE_MULT + i * 3; 1258 uint mult = (ext_csd[idx + 2] << 16) + 1259 (ext_csd[idx + 1] << 8) + ext_csd[idx]; 1260 if (mult) 1261 has_parts = true; 1262 if (!part_completed) 1263 continue; 1264 mmc->capacity_gp[i] = mult; 1265 mmc->capacity_gp[i] *= 1266 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]; 1267 mmc->capacity_gp[i] *= ext_csd[EXT_CSD_HC_WP_GRP_SIZE]; 1268 mmc->capacity_gp[i] <<= 19; 1269 } 1270 1271 if (part_completed) { 1272 mmc->enh_user_size = 1273 (ext_csd[EXT_CSD_ENH_SIZE_MULT+2] << 16) + 1274 (ext_csd[EXT_CSD_ENH_SIZE_MULT+1] << 8) + 1275 ext_csd[EXT_CSD_ENH_SIZE_MULT]; 1276 mmc->enh_user_size *= ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]; 1277 mmc->enh_user_size *= ext_csd[EXT_CSD_HC_WP_GRP_SIZE]; 1278 mmc->enh_user_size <<= 19; 1279 mmc->enh_user_start = 1280 (ext_csd[EXT_CSD_ENH_START_ADDR+3] << 24) + 1281 (ext_csd[EXT_CSD_ENH_START_ADDR+2] << 16) + 1282 (ext_csd[EXT_CSD_ENH_START_ADDR+1] << 8) + 1283 ext_csd[EXT_CSD_ENH_START_ADDR]; 1284 if (mmc->high_capacity) 1285 mmc->enh_user_start <<= 9; 1286 } 1287 1288 /* 1289 * Host needs to enable ERASE_GRP_DEF bit if device is 1290 * partitioned. This bit will be lost every time after a reset 1291 * or power off. This will affect erase size. 1292 */ 1293 if (part_completed) 1294 has_parts = true; 1295 if ((ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & PART_SUPPORT) && 1296 (ext_csd[EXT_CSD_PARTITIONS_ATTRIBUTE] & PART_ENH_ATTRIB)) 1297 has_parts = true; 1298 if (has_parts) { 1299 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 1300 EXT_CSD_ERASE_GROUP_DEF, 1); 1301 1302 if (err) 1303 return err; 1304 else 1305 ext_csd[EXT_CSD_ERASE_GROUP_DEF] = 1; 1306 } 1307 1308 if (ext_csd[EXT_CSD_ERASE_GROUP_DEF] & 0x01) { 1309 /* Read out group size from ext_csd */ 1310 mmc->erase_grp_size = 1311 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] * 1024; 1312 /* 1313 * if high capacity and partition setting completed 1314 * SEC_COUNT is valid even if it is smaller than 2 GiB 1315 * JEDEC Standard JESD84-B45, 6.2.4 1316 */ 1317 if (mmc->high_capacity && part_completed) { 1318 capacity = (ext_csd[EXT_CSD_SEC_CNT]) | 1319 (ext_csd[EXT_CSD_SEC_CNT + 1] << 8) | 1320 (ext_csd[EXT_CSD_SEC_CNT + 2] << 16) | 1321 (ext_csd[EXT_CSD_SEC_CNT + 3] << 24); 1322 capacity *= MMC_MAX_BLOCK_LEN; 1323 mmc->capacity_user = capacity; 1324 } 1325 } else { 1326 /* Calculate the group size from the csd value. */ 1327 int erase_gsz, erase_gmul; 1328 erase_gsz = (mmc->csd[2] & 0x00007c00) >> 10; 1329 erase_gmul = (mmc->csd[2] & 0x000003e0) >> 5; 1330 mmc->erase_grp_size = (erase_gsz + 1) 1331 * (erase_gmul + 1); 1332 } 1333 1334 mmc->hc_wp_grp_size = 1024 1335 * ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] 1336 * ext_csd[EXT_CSD_HC_WP_GRP_SIZE]; 1337 1338 mmc->wr_rel_set = ext_csd[EXT_CSD_WR_REL_SET]; 1339 } 1340 1341 err = mmc_set_capacity(mmc, mmc_get_blk_desc(mmc)->hwpart); 1342 if (err) 1343 return err; 1344 1345 if (IS_SD(mmc)) 1346 err = sd_change_freq(mmc); 1347 else 1348 err = mmc_change_freq(mmc); 1349 1350 if (err) 1351 return err; 1352 1353 /* Restrict card's capabilities by what the host can do */ 1354 mmc->card_caps &= mmc->cfg->host_caps; 1355 1356 if (IS_SD(mmc)) { 1357 if (mmc->card_caps & MMC_MODE_4BIT) { 1358 cmd.cmdidx = MMC_CMD_APP_CMD; 1359 cmd.resp_type = MMC_RSP_R1; 1360 cmd.cmdarg = mmc->rca << 16; 1361 1362 err = mmc_send_cmd(mmc, &cmd, NULL); 1363 if (err) 1364 return err; 1365 1366 cmd.cmdidx = SD_CMD_APP_SET_BUS_WIDTH; 1367 cmd.resp_type = MMC_RSP_R1; 1368 cmd.cmdarg = 2; 1369 err = mmc_send_cmd(mmc, &cmd, NULL); 1370 if (err) 1371 return err; 1372 1373 mmc_set_bus_width(mmc, 4); 1374 } 1375 1376 if (mmc->card_caps & MMC_MODE_HS) 1377 mmc->tran_speed = 50000000; 1378 else 1379 mmc->tran_speed = 25000000; 1380 } else if (mmc->version >= MMC_VERSION_4) { 1381 /* Only version 4 of MMC supports wider bus widths */ 1382 int idx; 1383 1384 /* An array of possible bus widths in order of preference */ 1385 static unsigned ext_csd_bits[] = { 1386 EXT_CSD_DDR_BUS_WIDTH_8, 1387 EXT_CSD_DDR_BUS_WIDTH_4, 1388 EXT_CSD_BUS_WIDTH_8, 1389 EXT_CSD_BUS_WIDTH_4, 1390 EXT_CSD_BUS_WIDTH_1, 1391 }; 1392 1393 /* An array to map CSD bus widths to host cap bits */ 1394 static unsigned ext_to_hostcaps[] = { 1395 [EXT_CSD_DDR_BUS_WIDTH_4] = 1396 MMC_MODE_DDR_52MHz | MMC_MODE_4BIT, 1397 [EXT_CSD_DDR_BUS_WIDTH_8] = 1398 MMC_MODE_DDR_52MHz | MMC_MODE_8BIT, 1399 [EXT_CSD_BUS_WIDTH_4] = MMC_MODE_4BIT, 1400 [EXT_CSD_BUS_WIDTH_8] = MMC_MODE_8BIT, 1401 }; 1402 1403 /* An array to map chosen bus width to an integer */ 1404 static unsigned widths[] = { 1405 8, 4, 8, 4, 1, 1406 }; 1407 1408 for (idx=0; idx < ARRAY_SIZE(ext_csd_bits); idx++) { 1409 unsigned int extw = ext_csd_bits[idx]; 1410 unsigned int caps = ext_to_hostcaps[extw]; 1411 1412 /* 1413 * If the bus width is still not changed, 1414 * don't try to set the default again. 1415 * Otherwise, recover from switch attempts 1416 * by switching to 1-bit bus width. 1417 */ 1418 if (extw == EXT_CSD_BUS_WIDTH_1 && 1419 mmc->bus_width == 1) { 1420 err = 0; 1421 break; 1422 } 1423 1424 /* 1425 * Check to make sure the card and controller support 1426 * these capabilities 1427 */ 1428 if ((mmc->card_caps & caps) != caps) 1429 continue; 1430 1431 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 1432 EXT_CSD_BUS_WIDTH, extw); 1433 1434 if (err) 1435 continue; 1436 1437 mmc->ddr_mode = (caps & MMC_MODE_DDR_52MHz) ? 1 : 0; 1438 mmc_set_bus_width(mmc, widths[idx]); 1439 1440 err = mmc_send_ext_csd(mmc, test_csd); 1441 1442 if (err) 1443 continue; 1444 1445 /* Only compare read only fields */ 1446 if (ext_csd[EXT_CSD_PARTITIONING_SUPPORT] 1447 == test_csd[EXT_CSD_PARTITIONING_SUPPORT] && 1448 ext_csd[EXT_CSD_HC_WP_GRP_SIZE] 1449 == test_csd[EXT_CSD_HC_WP_GRP_SIZE] && 1450 ext_csd[EXT_CSD_REV] 1451 == test_csd[EXT_CSD_REV] && 1452 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] 1453 == test_csd[EXT_CSD_HC_ERASE_GRP_SIZE] && 1454 memcmp(&ext_csd[EXT_CSD_SEC_CNT], 1455 &test_csd[EXT_CSD_SEC_CNT], 4) == 0) 1456 break; 1457 else 1458 err = SWITCH_ERR; 1459 } 1460 1461 if (err) 1462 return err; 1463 1464 if (mmc->card_caps & MMC_MODE_HS) { 1465 if (mmc->card_caps & MMC_MODE_HS_52MHz) 1466 mmc->tran_speed = 52000000; 1467 else 1468 mmc->tran_speed = 26000000; 1469 } 1470 } 1471 1472 mmc_set_clock(mmc, mmc->tran_speed); 1473 1474 /* Fix the block length for DDR mode */ 1475 if (mmc->ddr_mode) { 1476 mmc->read_bl_len = MMC_MAX_BLOCK_LEN; 1477 mmc->write_bl_len = MMC_MAX_BLOCK_LEN; 1478 } 1479 1480 /* fill in device description */ 1481 bdesc = mmc_get_blk_desc(mmc); 1482 bdesc->lun = 0; 1483 bdesc->hwpart = 0; 1484 bdesc->type = 0; 1485 bdesc->blksz = mmc->read_bl_len; 1486 bdesc->log2blksz = LOG2(bdesc->blksz); 1487 bdesc->lba = lldiv(mmc->capacity, mmc->read_bl_len); 1488 #if !defined(CONFIG_SPL_BUILD) || \ 1489 (defined(CONFIG_SPL_LIBCOMMON_SUPPORT) && \ 1490 !defined(CONFIG_USE_TINY_PRINTF)) 1491 sprintf(bdesc->vendor, "Man %06x Snr %04x%04x", 1492 mmc->cid[0] >> 24, (mmc->cid[2] & 0xffff), 1493 (mmc->cid[3] >> 16) & 0xffff); 1494 sprintf(bdesc->product, "%c%c%c%c%c%c", mmc->cid[0] & 0xff, 1495 (mmc->cid[1] >> 24), (mmc->cid[1] >> 16) & 0xff, 1496 (mmc->cid[1] >> 8) & 0xff, mmc->cid[1] & 0xff, 1497 (mmc->cid[2] >> 24) & 0xff); 1498 sprintf(bdesc->revision, "%d.%d", (mmc->cid[2] >> 20) & 0xf, 1499 (mmc->cid[2] >> 16) & 0xf); 1500 #else 1501 bdesc->vendor[0] = 0; 1502 bdesc->product[0] = 0; 1503 bdesc->revision[0] = 0; 1504 #endif 1505 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBDISK_SUPPORT) 1506 part_init(bdesc); 1507 #endif 1508 1509 return 0; 1510 } 1511 1512 static int mmc_send_if_cond(struct mmc *mmc) 1513 { 1514 struct mmc_cmd cmd; 1515 int err; 1516 1517 cmd.cmdidx = SD_CMD_SEND_IF_COND; 1518 /* We set the bit if the host supports voltages between 2.7 and 3.6 V */ 1519 cmd.cmdarg = ((mmc->cfg->voltages & 0xff8000) != 0) << 8 | 0xaa; 1520 cmd.resp_type = MMC_RSP_R7; 1521 1522 err = mmc_send_cmd(mmc, &cmd, NULL); 1523 1524 if (err) 1525 return err; 1526 1527 if ((cmd.response[0] & 0xff) != 0xaa) 1528 return UNUSABLE_ERR; 1529 else 1530 mmc->version = SD_VERSION_2; 1531 1532 return 0; 1533 } 1534 1535 #ifdef CONFIG_BLK 1536 int mmc_bind(struct udevice *dev, struct mmc *mmc, const struct mmc_config *cfg) 1537 { 1538 struct blk_desc *bdesc; 1539 struct udevice *bdev; 1540 int ret; 1541 1542 ret = blk_create_devicef(dev, "mmc_blk", "blk", IF_TYPE_MMC, -1, 512, 1543 0, &bdev); 1544 if (ret) { 1545 debug("Cannot create block device\n"); 1546 return ret; 1547 } 1548 bdesc = dev_get_uclass_platdata(bdev); 1549 mmc->cfg = cfg; 1550 mmc->priv = dev; 1551 1552 /* the following chunk was from mmc_register() */ 1553 1554 /* Setup dsr related values */ 1555 mmc->dsr_imp = 0; 1556 mmc->dsr = 0xffffffff; 1557 /* Setup the universal parts of the block interface just once */ 1558 bdesc->removable = 1; 1559 1560 /* setup initial part type */ 1561 bdesc->part_type = cfg->part_type; 1562 mmc->dev = dev; 1563 1564 return 0; 1565 } 1566 1567 int mmc_unbind(struct udevice *dev) 1568 { 1569 struct udevice *bdev; 1570 1571 device_find_first_child(dev, &bdev); 1572 if (bdev) { 1573 device_remove(bdev); 1574 device_unbind(bdev); 1575 } 1576 1577 return 0; 1578 } 1579 1580 #else 1581 struct mmc *mmc_create(const struct mmc_config *cfg, void *priv) 1582 { 1583 struct blk_desc *bdesc; 1584 struct mmc *mmc; 1585 1586 /* quick validation */ 1587 if (cfg == NULL || cfg->ops == NULL || cfg->ops->send_cmd == NULL || 1588 cfg->f_min == 0 || cfg->f_max == 0 || cfg->b_max == 0) 1589 return NULL; 1590 1591 mmc = calloc(1, sizeof(*mmc)); 1592 if (mmc == NULL) 1593 return NULL; 1594 1595 mmc->cfg = cfg; 1596 mmc->priv = priv; 1597 1598 /* the following chunk was mmc_register() */ 1599 1600 /* Setup dsr related values */ 1601 mmc->dsr_imp = 0; 1602 mmc->dsr = 0xffffffff; 1603 /* Setup the universal parts of the block interface just once */ 1604 bdesc = mmc_get_blk_desc(mmc); 1605 bdesc->if_type = IF_TYPE_MMC; 1606 bdesc->removable = 1; 1607 bdesc->devnum = mmc_get_next_devnum(); 1608 bdesc->block_read = mmc_bread; 1609 bdesc->block_write = mmc_bwrite; 1610 bdesc->block_erase = mmc_berase; 1611 1612 /* setup initial part type */ 1613 bdesc->part_type = mmc->cfg->part_type; 1614 mmc_list_add(mmc); 1615 1616 return mmc; 1617 } 1618 1619 void mmc_destroy(struct mmc *mmc) 1620 { 1621 /* only freeing memory for now */ 1622 free(mmc); 1623 } 1624 #endif 1625 1626 #ifndef CONFIG_BLK 1627 static int mmc_get_dev(int dev, struct blk_desc **descp) 1628 { 1629 struct mmc *mmc = find_mmc_device(dev); 1630 int ret; 1631 1632 if (!mmc) 1633 return -ENODEV; 1634 ret = mmc_init(mmc); 1635 if (ret) 1636 return ret; 1637 1638 *descp = &mmc->block_dev; 1639 1640 return 0; 1641 } 1642 #endif 1643 1644 /* board-specific MMC power initializations. */ 1645 __weak void board_mmc_power_init(void) 1646 { 1647 } 1648 1649 int mmc_start_init(struct mmc *mmc) 1650 { 1651 int err; 1652 1653 /* we pretend there's no card when init is NULL */ 1654 if (mmc_getcd(mmc) == 0 || mmc->cfg->ops->init == NULL) { 1655 mmc->has_init = 0; 1656 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 1657 printf("MMC: no card present\n"); 1658 #endif 1659 return NO_CARD_ERR; 1660 } 1661 1662 if (mmc->has_init) 1663 return 0; 1664 1665 #ifdef CONFIG_FSL_ESDHC_ADAPTER_IDENT 1666 mmc_adapter_card_type_ident(); 1667 #endif 1668 board_mmc_power_init(); 1669 1670 /* made sure it's not NULL earlier */ 1671 err = mmc->cfg->ops->init(mmc); 1672 1673 if (err) 1674 return err; 1675 1676 mmc->ddr_mode = 0; 1677 mmc_set_bus_width(mmc, 1); 1678 mmc_set_clock(mmc, 1); 1679 1680 /* Reset the Card */ 1681 err = mmc_go_idle(mmc); 1682 1683 if (err) 1684 return err; 1685 1686 /* The internal partition reset to user partition(0) at every CMD0*/ 1687 mmc_get_blk_desc(mmc)->hwpart = 0; 1688 1689 /* Test for SD version 2 */ 1690 err = mmc_send_if_cond(mmc); 1691 1692 /* Now try to get the SD card's operating condition */ 1693 err = sd_send_op_cond(mmc); 1694 1695 /* If the command timed out, we check for an MMC card */ 1696 if (err == TIMEOUT) { 1697 err = mmc_send_op_cond(mmc); 1698 1699 if (err) { 1700 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 1701 printf("Card did not respond to voltage select!\n"); 1702 #endif 1703 return UNUSABLE_ERR; 1704 } 1705 } 1706 1707 if (!err) 1708 mmc->init_in_progress = 1; 1709 1710 return err; 1711 } 1712 1713 static int mmc_complete_init(struct mmc *mmc) 1714 { 1715 int err = 0; 1716 1717 mmc->init_in_progress = 0; 1718 if (mmc->op_cond_pending) 1719 err = mmc_complete_op_cond(mmc); 1720 1721 if (!err) 1722 err = mmc_startup(mmc); 1723 if (err) 1724 mmc->has_init = 0; 1725 else 1726 mmc->has_init = 1; 1727 return err; 1728 } 1729 1730 int mmc_init(struct mmc *mmc) 1731 { 1732 int err = 0; 1733 unsigned start; 1734 #ifdef CONFIG_DM_MMC 1735 struct mmc_uclass_priv *upriv = dev_get_uclass_priv(mmc->dev); 1736 1737 upriv->mmc = mmc; 1738 #endif 1739 if (mmc->has_init) 1740 return 0; 1741 1742 start = get_timer(0); 1743 1744 if (!mmc->init_in_progress) 1745 err = mmc_start_init(mmc); 1746 1747 if (!err) 1748 err = mmc_complete_init(mmc); 1749 debug("%s: %d, time %lu\n", __func__, err, get_timer(start)); 1750 return err; 1751 } 1752 1753 int mmc_set_dsr(struct mmc *mmc, u16 val) 1754 { 1755 mmc->dsr = val; 1756 return 0; 1757 } 1758 1759 /* CPU-specific MMC initializations */ 1760 __weak int cpu_mmc_init(bd_t *bis) 1761 { 1762 return -1; 1763 } 1764 1765 /* board-specific MMC initializations. */ 1766 __weak int board_mmc_init(bd_t *bis) 1767 { 1768 return -1; 1769 } 1770 1771 void mmc_set_preinit(struct mmc *mmc, int preinit) 1772 { 1773 mmc->preinit = preinit; 1774 } 1775 1776 #if defined(CONFIG_DM_MMC) && defined(CONFIG_SPL_BUILD) 1777 static int mmc_probe(bd_t *bis) 1778 { 1779 return 0; 1780 } 1781 #elif defined(CONFIG_DM_MMC) 1782 static int mmc_probe(bd_t *bis) 1783 { 1784 int ret, i; 1785 struct uclass *uc; 1786 struct udevice *dev; 1787 1788 ret = uclass_get(UCLASS_MMC, &uc); 1789 if (ret) 1790 return ret; 1791 1792 /* 1793 * Try to add them in sequence order. Really with driver model we 1794 * should allow holes, but the current MMC list does not allow that. 1795 * So if we request 0, 1, 3 we will get 0, 1, 2. 1796 */ 1797 for (i = 0; ; i++) { 1798 ret = uclass_get_device_by_seq(UCLASS_MMC, i, &dev); 1799 if (ret == -ENODEV) 1800 break; 1801 } 1802 uclass_foreach_dev(dev, uc) { 1803 ret = device_probe(dev); 1804 if (ret) 1805 printf("%s - probe failed: %d\n", dev->name, ret); 1806 } 1807 1808 return 0; 1809 } 1810 #else 1811 static int mmc_probe(bd_t *bis) 1812 { 1813 if (board_mmc_init(bis) < 0) 1814 cpu_mmc_init(bis); 1815 1816 return 0; 1817 } 1818 #endif 1819 1820 int mmc_initialize(bd_t *bis) 1821 { 1822 static int initialized = 0; 1823 int ret; 1824 if (initialized) /* Avoid initializing mmc multiple times */ 1825 return 0; 1826 initialized = 1; 1827 1828 #ifndef CONFIG_BLK 1829 mmc_list_init(); 1830 #endif 1831 ret = mmc_probe(bis); 1832 if (ret) 1833 return ret; 1834 1835 #ifndef CONFIG_SPL_BUILD 1836 print_mmc_devices(','); 1837 #endif 1838 1839 mmc_do_preinit(); 1840 return 0; 1841 } 1842 1843 #ifdef CONFIG_SUPPORT_EMMC_BOOT 1844 /* 1845 * This function changes the size of boot partition and the size of rpmb 1846 * partition present on EMMC devices. 1847 * 1848 * Input Parameters: 1849 * struct *mmc: pointer for the mmc device strcuture 1850 * bootsize: size of boot partition 1851 * rpmbsize: size of rpmb partition 1852 * 1853 * Returns 0 on success. 1854 */ 1855 1856 int mmc_boot_partition_size_change(struct mmc *mmc, unsigned long bootsize, 1857 unsigned long rpmbsize) 1858 { 1859 int err; 1860 struct mmc_cmd cmd; 1861 1862 /* Only use this command for raw EMMC moviNAND. Enter backdoor mode */ 1863 cmd.cmdidx = MMC_CMD_RES_MAN; 1864 cmd.resp_type = MMC_RSP_R1b; 1865 cmd.cmdarg = MMC_CMD62_ARG1; 1866 1867 err = mmc_send_cmd(mmc, &cmd, NULL); 1868 if (err) { 1869 debug("mmc_boot_partition_size_change: Error1 = %d\n", err); 1870 return err; 1871 } 1872 1873 /* Boot partition changing mode */ 1874 cmd.cmdidx = MMC_CMD_RES_MAN; 1875 cmd.resp_type = MMC_RSP_R1b; 1876 cmd.cmdarg = MMC_CMD62_ARG2; 1877 1878 err = mmc_send_cmd(mmc, &cmd, NULL); 1879 if (err) { 1880 debug("mmc_boot_partition_size_change: Error2 = %d\n", err); 1881 return err; 1882 } 1883 /* boot partition size is multiple of 128KB */ 1884 bootsize = (bootsize * 1024) / 128; 1885 1886 /* Arg: boot partition size */ 1887 cmd.cmdidx = MMC_CMD_RES_MAN; 1888 cmd.resp_type = MMC_RSP_R1b; 1889 cmd.cmdarg = bootsize; 1890 1891 err = mmc_send_cmd(mmc, &cmd, NULL); 1892 if (err) { 1893 debug("mmc_boot_partition_size_change: Error3 = %d\n", err); 1894 return err; 1895 } 1896 /* RPMB partition size is multiple of 128KB */ 1897 rpmbsize = (rpmbsize * 1024) / 128; 1898 /* Arg: RPMB partition size */ 1899 cmd.cmdidx = MMC_CMD_RES_MAN; 1900 cmd.resp_type = MMC_RSP_R1b; 1901 cmd.cmdarg = rpmbsize; 1902 1903 err = mmc_send_cmd(mmc, &cmd, NULL); 1904 if (err) { 1905 debug("mmc_boot_partition_size_change: Error4 = %d\n", err); 1906 return err; 1907 } 1908 return 0; 1909 } 1910 1911 /* 1912 * Modify EXT_CSD[177] which is BOOT_BUS_WIDTH 1913 * based on the passed in values for BOOT_BUS_WIDTH, RESET_BOOT_BUS_WIDTH 1914 * and BOOT_MODE. 1915 * 1916 * Returns 0 on success. 1917 */ 1918 int mmc_set_boot_bus_width(struct mmc *mmc, u8 width, u8 reset, u8 mode) 1919 { 1920 int err; 1921 1922 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_BOOT_BUS_WIDTH, 1923 EXT_CSD_BOOT_BUS_WIDTH_MODE(mode) | 1924 EXT_CSD_BOOT_BUS_WIDTH_RESET(reset) | 1925 EXT_CSD_BOOT_BUS_WIDTH_WIDTH(width)); 1926 1927 if (err) 1928 return err; 1929 return 0; 1930 } 1931 1932 /* 1933 * Modify EXT_CSD[179] which is PARTITION_CONFIG (formerly BOOT_CONFIG) 1934 * based on the passed in values for BOOT_ACK, BOOT_PARTITION_ENABLE and 1935 * PARTITION_ACCESS. 1936 * 1937 * Returns 0 on success. 1938 */ 1939 int mmc_set_part_conf(struct mmc *mmc, u8 ack, u8 part_num, u8 access) 1940 { 1941 int err; 1942 1943 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONF, 1944 EXT_CSD_BOOT_ACK(ack) | 1945 EXT_CSD_BOOT_PART_NUM(part_num) | 1946 EXT_CSD_PARTITION_ACCESS(access)); 1947 1948 if (err) 1949 return err; 1950 return 0; 1951 } 1952 1953 /* 1954 * Modify EXT_CSD[162] which is RST_n_FUNCTION based on the given value 1955 * for enable. Note that this is a write-once field for non-zero values. 1956 * 1957 * Returns 0 on success. 1958 */ 1959 int mmc_set_rst_n_function(struct mmc *mmc, u8 enable) 1960 { 1961 return mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_RST_N_FUNCTION, 1962 enable); 1963 } 1964 #endif 1965 1966 #ifdef CONFIG_BLK 1967 static const struct blk_ops mmc_blk_ops = { 1968 .read = mmc_bread, 1969 .write = mmc_bwrite, 1970 .select_hwpart = mmc_select_hwpart, 1971 }; 1972 1973 U_BOOT_DRIVER(mmc_blk) = { 1974 .name = "mmc_blk", 1975 .id = UCLASS_BLK, 1976 .ops = &mmc_blk_ops, 1977 }; 1978 #else 1979 U_BOOT_LEGACY_BLK(mmc) = { 1980 .if_typename = "mmc", 1981 .if_type = IF_TYPE_MMC, 1982 .max_devs = -1, 1983 .get_dev = mmc_get_dev, 1984 .select_hwpart = mmc_select_hwpartp, 1985 }; 1986 #endif 1987