1 /* 2 * Copyright (c) 2018, ARM Limited and Contributors. All rights reserved. 3 * 4 * SPDX-License-Identifier: BSD-3-Clause 5 */ 6 7 /* Define a simple and generic interface to access eMMC and SD-card devices. */ 8 9 #include <arch_helpers.h> 10 #include <assert.h> 11 #include <debug.h> 12 #include <errno.h> 13 #include <mmc.h> 14 #include <stdbool.h> 15 #include <string.h> 16 #include <utils.h> 17 18 #define MMC_DEFAULT_MAX_RETRIES 5 19 #define SEND_OP_COND_MAX_RETRIES 100 20 21 #define MULT_BY_512K_SHIFT 19 22 23 static const struct mmc_ops *ops; 24 static unsigned int mmc_ocr_value; 25 static struct mmc_csd_emmc mmc_csd; 26 static unsigned char mmc_ext_csd[512] __aligned(4); 27 static unsigned int mmc_flags; 28 static struct mmc_device_info *mmc_dev_info; 29 static unsigned int rca; 30 31 static const unsigned char tran_speed_base[16] = { 32 0, 10, 12, 13, 15, 20, 26, 30, 35, 40, 45, 52, 55, 60, 70, 80 33 }; 34 35 static const unsigned char sd_tran_speed_base[16] = { 36 0, 10, 12, 13, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 70, 80 37 }; 38 39 static bool is_cmd23_enabled(void) 40 { 41 return ((mmc_flags & MMC_FLAG_CMD23) != 0U); 42 } 43 44 static int mmc_send_cmd(unsigned int idx, unsigned int arg, 45 unsigned int r_type, unsigned int *r_data) 46 { 47 struct mmc_cmd cmd; 48 int ret; 49 50 zeromem(&cmd, sizeof(struct mmc_cmd)); 51 52 cmd.cmd_idx = idx; 53 cmd.cmd_arg = arg; 54 cmd.resp_type = r_type; 55 56 ret = ops->send_cmd(&cmd); 57 58 if ((ret == 0) && (r_data != NULL)) { 59 int i; 60 61 for (i = 0; i < 4; i++) { 62 *r_data = cmd.resp_data[i]; 63 r_data++; 64 } 65 } 66 67 if (ret != 0) { 68 VERBOSE("Send command %u error: %d\n", idx, ret); 69 } 70 71 return ret; 72 } 73 74 static int mmc_device_state(void) 75 { 76 int retries = MMC_DEFAULT_MAX_RETRIES; 77 unsigned int resp_data[4]; 78 79 do { 80 int ret; 81 82 if (retries == 0) { 83 ERROR("CMD13 failed after %d retries\n", 84 MMC_DEFAULT_MAX_RETRIES); 85 return -EIO; 86 } 87 88 ret = mmc_send_cmd(MMC_CMD(13), rca << RCA_SHIFT_OFFSET, 89 MMC_RESPONSE_R(1), &resp_data[0]); 90 if (ret != 0) { 91 return ret; 92 } 93 94 if ((resp_data[0] & STATUS_SWITCH_ERROR) != 0U) { 95 return -EIO; 96 } 97 98 retries--; 99 } while ((resp_data[0] & STATUS_READY_FOR_DATA) == 0U); 100 101 return MMC_GET_STATE(resp_data[0]); 102 } 103 104 static int mmc_set_ext_csd(unsigned int ext_cmd, unsigned int value) 105 { 106 int ret; 107 108 ret = mmc_send_cmd(MMC_CMD(6), 109 EXTCSD_WRITE_BYTES | EXTCSD_CMD(ext_cmd) | 110 EXTCSD_VALUE(value) | EXTCSD_CMD_SET_NORMAL, 111 0, NULL); 112 if (ret != 0) { 113 return ret; 114 } 115 116 do { 117 ret = mmc_device_state(); 118 if (ret < 0) { 119 return ret; 120 } 121 } while (ret == MMC_STATE_PRG); 122 123 return 0; 124 } 125 126 static int mmc_sd_switch(unsigned int bus_width) 127 { 128 int ret; 129 int retries = MMC_DEFAULT_MAX_RETRIES; 130 unsigned int scr[2] = { 0 }; 131 unsigned int bus_width_arg = 0; 132 133 ret = ops->prepare(0, (uintptr_t)&scr, sizeof(scr)); 134 if (ret != 0) { 135 return ret; 136 } 137 138 /* CMD55: Application Specific Command */ 139 ret = mmc_send_cmd(MMC_CMD(55), rca << RCA_SHIFT_OFFSET, 140 MMC_RESPONSE_R(1), NULL); 141 if (ret != 0) { 142 return ret; 143 } 144 145 /* ACMD51: SEND_SCR */ 146 do { 147 ret = mmc_send_cmd(MMC_ACMD(51), 0, MMC_RESPONSE_R(1), NULL); 148 if ((ret != 0) && (retries == 0)) { 149 ERROR("ACMD51 failed after %d retries (ret=%d)\n", 150 MMC_DEFAULT_MAX_RETRIES, ret); 151 return ret; 152 } 153 154 retries--; 155 } while (ret != 0); 156 157 ret = ops->read(0, (uintptr_t)&scr, sizeof(scr)); 158 if (ret != 0) { 159 return ret; 160 } 161 162 if (((scr[0] & SD_SCR_BUS_WIDTH_4) != 0U) && 163 (bus_width == MMC_BUS_WIDTH_4)) { 164 bus_width_arg = 2; 165 } 166 167 /* CMD55: Application Specific Command */ 168 ret = mmc_send_cmd(MMC_CMD(55), rca << RCA_SHIFT_OFFSET, 169 MMC_RESPONSE_R(1), NULL); 170 if (ret != 0) { 171 return ret; 172 } 173 174 /* ACMD6: SET_BUS_WIDTH */ 175 ret = mmc_send_cmd(MMC_ACMD(6), bus_width_arg, MMC_RESPONSE_R(1), NULL); 176 if (ret != 0) { 177 return ret; 178 } 179 180 do { 181 ret = mmc_device_state(); 182 if (ret < 0) { 183 return ret; 184 } 185 } while (ret == MMC_STATE_PRG); 186 187 return 0; 188 } 189 190 static int mmc_set_ios(unsigned int clk, unsigned int bus_width) 191 { 192 int ret; 193 unsigned int width = bus_width; 194 195 if (mmc_dev_info->mmc_dev_type != MMC_IS_EMMC) { 196 if (width == MMC_BUS_WIDTH_8) { 197 WARN("Wrong bus config for SD-card, force to 4\n"); 198 width = MMC_BUS_WIDTH_4; 199 } 200 ret = mmc_sd_switch(width); 201 if (ret != 0) { 202 return ret; 203 } 204 } else if (mmc_csd.spec_vers == 4U) { 205 ret = mmc_set_ext_csd(CMD_EXTCSD_BUS_WIDTH, 206 (unsigned int)width); 207 if (ret != 0) { 208 return ret; 209 } 210 } else { 211 VERBOSE("Wrong MMC type or spec version\n"); 212 } 213 214 return ops->set_ios(clk, width); 215 } 216 217 static int mmc_fill_device_info(void) 218 { 219 unsigned long long c_size; 220 unsigned int speed_idx; 221 unsigned int nb_blocks; 222 unsigned int freq_unit; 223 int ret; 224 struct mmc_csd_sd_v2 *csd_sd_v2; 225 226 switch (mmc_dev_info->mmc_dev_type) { 227 case MMC_IS_EMMC: 228 mmc_dev_info->block_size = MMC_BLOCK_SIZE; 229 230 ret = ops->prepare(0, (uintptr_t)&mmc_ext_csd, 231 sizeof(mmc_ext_csd)); 232 if (ret != 0) { 233 return ret; 234 } 235 236 /* MMC CMD8: SEND_EXT_CSD */ 237 ret = mmc_send_cmd(MMC_CMD(8), 0, MMC_RESPONSE_R(1), NULL); 238 if (ret != 0) { 239 return ret; 240 } 241 242 ret = ops->read(0, (uintptr_t)&mmc_ext_csd, 243 sizeof(mmc_ext_csd)); 244 if (ret != 0) { 245 return ret; 246 } 247 248 nb_blocks = (mmc_ext_csd[CMD_EXTCSD_SEC_CNT] << 0) | 249 (mmc_ext_csd[CMD_EXTCSD_SEC_CNT + 1] << 8) | 250 (mmc_ext_csd[CMD_EXTCSD_SEC_CNT + 2] << 16) | 251 (mmc_ext_csd[CMD_EXTCSD_SEC_CNT + 3] << 24); 252 253 mmc_dev_info->device_size = (unsigned long long)nb_blocks * 254 mmc_dev_info->block_size; 255 256 break; 257 258 case MMC_IS_SD: 259 /* 260 * Use the same mmc_csd struct, as required fields here 261 * (READ_BL_LEN, C_SIZE, CSIZE_MULT) are common with eMMC. 262 */ 263 mmc_dev_info->block_size = BIT_32(mmc_csd.read_bl_len); 264 265 c_size = ((unsigned long long)mmc_csd.c_size_high << 2U) | 266 (unsigned long long)mmc_csd.c_size_low; 267 assert(c_size != 0xFFFU); 268 269 mmc_dev_info->device_size = (c_size + 1U) * 270 BIT_64(mmc_csd.c_size_mult + 2U) * 271 mmc_dev_info->block_size; 272 273 break; 274 275 case MMC_IS_SD_HC: 276 assert(mmc_csd.csd_structure == 1U); 277 278 mmc_dev_info->block_size = MMC_BLOCK_SIZE; 279 280 /* Need to use mmc_csd_sd_v2 struct */ 281 csd_sd_v2 = (struct mmc_csd_sd_v2 *)&mmc_csd; 282 c_size = ((unsigned long long)csd_sd_v2->c_size_high << 16) | 283 (unsigned long long)csd_sd_v2->c_size_low; 284 285 mmc_dev_info->device_size = (c_size + 1U) << MULT_BY_512K_SHIFT; 286 287 break; 288 289 default: 290 ret = -EINVAL; 291 break; 292 } 293 294 if (ret != 0) { 295 return ret; 296 } 297 298 speed_idx = (mmc_csd.tran_speed & CSD_TRAN_SPEED_MULT_MASK) >> 299 CSD_TRAN_SPEED_MULT_SHIFT; 300 301 assert(speed_idx > 0U); 302 303 if (mmc_dev_info->mmc_dev_type == MMC_IS_EMMC) { 304 mmc_dev_info->max_bus_freq = tran_speed_base[speed_idx]; 305 } else { 306 mmc_dev_info->max_bus_freq = sd_tran_speed_base[speed_idx]; 307 } 308 309 freq_unit = mmc_csd.tran_speed & CSD_TRAN_SPEED_UNIT_MASK; 310 while (freq_unit != 0U) { 311 mmc_dev_info->max_bus_freq *= 10U; 312 --freq_unit; 313 } 314 315 mmc_dev_info->max_bus_freq *= 10000U; 316 317 return 0; 318 } 319 320 static int sd_send_op_cond(void) 321 { 322 int retries = SEND_OP_COND_MAX_RETRIES; 323 unsigned int resp_data[4]; 324 325 do { 326 int ret; 327 328 if (retries == 0) { 329 ERROR("ACMD41 failed after %d retries\n", 330 SEND_OP_COND_MAX_RETRIES); 331 return -EIO; 332 } 333 334 /* CMD55: Application Specific Command */ 335 ret = mmc_send_cmd(MMC_CMD(55), 0, MMC_RESPONSE_R(1), NULL); 336 if (ret != 0) { 337 return ret; 338 } 339 340 /* ACMD41: SD_SEND_OP_COND */ 341 ret = mmc_send_cmd(MMC_ACMD(41), OCR_HCS, MMC_RESPONSE_R(3), 342 &resp_data[0]); 343 if (ret != 0) { 344 return ret; 345 } 346 347 retries--; 348 } while ((resp_data[0] & OCR_POWERUP) == 0U); 349 350 mmc_ocr_value = resp_data[0]; 351 352 if ((mmc_ocr_value & OCR_HCS) != 0U) { 353 mmc_dev_info->mmc_dev_type = MMC_IS_SD_HC; 354 } else { 355 mmc_dev_info->mmc_dev_type = MMC_IS_SD; 356 } 357 358 return 0; 359 } 360 361 static int mmc_send_op_cond(void) 362 { 363 int ret; 364 int retries = SEND_OP_COND_MAX_RETRIES; 365 unsigned int resp_data[4]; 366 367 /* CMD0: reset to IDLE */ 368 ret = mmc_send_cmd(MMC_CMD(0), 0, 0, NULL); 369 if (ret != 0) { 370 return ret; 371 } 372 373 do { 374 if (retries == 0) { 375 ERROR("CMD1 failed after %d retries\n", 376 SEND_OP_COND_MAX_RETRIES); 377 return -EIO; 378 } 379 380 /* CMD1: get OCR register (SEND_OP_COND) */ 381 ret = mmc_send_cmd(MMC_CMD(1), OCR_SECTOR_MODE | 382 OCR_VDD_MIN_2V7 | OCR_VDD_MIN_1V7, 383 MMC_RESPONSE_R(3), &resp_data[0]); 384 if (ret != 0) { 385 return ret; 386 } 387 388 retries--; 389 } while ((resp_data[0] & OCR_POWERUP) == 0U); 390 391 mmc_ocr_value = resp_data[0]; 392 393 return 0; 394 } 395 396 static int mmc_enumerate(unsigned int clk, unsigned int bus_width) 397 { 398 int ret; 399 unsigned int resp_data[4]; 400 401 ops->init(); 402 403 /* CMD0: reset to IDLE */ 404 ret = mmc_send_cmd(MMC_CMD(0), 0, 0, NULL); 405 if (ret != 0) { 406 return ret; 407 } 408 409 /* CMD8: Send Interface Condition Command */ 410 ret = mmc_send_cmd(MMC_CMD(8), VHS_2_7_3_6_V | CMD8_CHECK_PATTERN, 411 MMC_RESPONSE_R(7), &resp_data[0]); 412 413 if ((ret == 0) && ((resp_data[0] & 0xffU) == CMD8_CHECK_PATTERN)) { 414 ret = sd_send_op_cond(); 415 } else { 416 ret = mmc_send_op_cond(); 417 } 418 if (ret != 0) { 419 return ret; 420 } 421 422 /* CMD2: Card Identification */ 423 ret = mmc_send_cmd(MMC_CMD(2), 0, MMC_RESPONSE_R(2), NULL); 424 if (ret != 0) { 425 return ret; 426 } 427 428 /* CMD3: Set Relative Address */ 429 if (mmc_dev_info->mmc_dev_type == MMC_IS_EMMC) { 430 rca = MMC_FIX_RCA; 431 ret = mmc_send_cmd(MMC_CMD(3), rca << RCA_SHIFT_OFFSET, 432 MMC_RESPONSE_R(1), NULL); 433 if (ret != 0) { 434 return ret; 435 } 436 } else { 437 ret = mmc_send_cmd(MMC_CMD(3), 0, 438 MMC_RESPONSE_R(6), &resp_data[0]); 439 if (ret != 0) { 440 return ret; 441 } 442 443 rca = (resp_data[0] & 0xFFFF0000U) >> 16; 444 } 445 446 /* CMD9: CSD Register */ 447 ret = mmc_send_cmd(MMC_CMD(9), rca << RCA_SHIFT_OFFSET, 448 MMC_RESPONSE_R(2), &resp_data[0]); 449 if (ret != 0) { 450 return ret; 451 } 452 453 memcpy(&mmc_csd, &resp_data, sizeof(resp_data)); 454 455 /* CMD7: Select Card */ 456 ret = mmc_send_cmd(MMC_CMD(7), rca << RCA_SHIFT_OFFSET, 457 MMC_RESPONSE_R(1), NULL); 458 if (ret != 0) { 459 return ret; 460 } 461 462 do { 463 ret = mmc_device_state(); 464 if (ret < 0) { 465 return ret; 466 } 467 } while (ret != MMC_STATE_TRAN); 468 469 ret = mmc_fill_device_info(); 470 if (ret != 0) { 471 return ret; 472 } 473 474 return mmc_set_ios(clk, bus_width); 475 } 476 477 size_t mmc_read_blocks(unsigned int lba, uintptr_t buf, size_t size) 478 { 479 int ret; 480 unsigned int cmd_idx, cmd_arg; 481 482 assert((ops != NULL) && 483 (ops->read != NULL) && 484 (size != 0U) && 485 ((size & MMC_BLOCK_MASK) == 0U)); 486 487 ret = ops->prepare(lba, buf, size); 488 if (ret != 0) { 489 return 0; 490 } 491 492 if (is_cmd23_enabled()) { 493 /* Set block count */ 494 ret = mmc_send_cmd(MMC_CMD(23), size / MMC_BLOCK_SIZE, 495 MMC_RESPONSE_R(1), NULL); 496 if (ret != 0) { 497 return 0; 498 } 499 500 cmd_idx = MMC_CMD(18); 501 } else { 502 if (size > MMC_BLOCK_SIZE) { 503 cmd_idx = MMC_CMD(18); 504 } else { 505 cmd_idx = MMC_CMD(17); 506 } 507 } 508 509 if (((mmc_ocr_value & OCR_ACCESS_MODE_MASK) == OCR_BYTE_MODE) && 510 (mmc_dev_info->mmc_dev_type != MMC_IS_SD_HC)) { 511 cmd_arg = lba * MMC_BLOCK_SIZE; 512 } else { 513 cmd_arg = lba; 514 } 515 516 ret = mmc_send_cmd(cmd_idx, cmd_arg, MMC_RESPONSE_R(1), NULL); 517 if (ret != 0) { 518 return 0; 519 } 520 521 ret = ops->read(lba, buf, size); 522 if (ret != 0) { 523 return 0; 524 } 525 526 /* Wait buffer empty */ 527 do { 528 ret = mmc_device_state(); 529 if (ret < 0) { 530 return 0; 531 } 532 } while ((ret != MMC_STATE_TRAN) && (ret != MMC_STATE_DATA)); 533 534 if (!is_cmd23_enabled() && (size > MMC_BLOCK_SIZE)) { 535 ret = mmc_send_cmd(MMC_CMD(12), 0, 0, NULL); 536 if (ret != 0) { 537 return 0; 538 } 539 } 540 541 return size; 542 } 543 544 size_t mmc_write_blocks(unsigned int lba, const uintptr_t buf, size_t size) 545 { 546 int ret; 547 unsigned int cmd_idx, cmd_arg; 548 549 assert((ops != NULL) && 550 (ops->write != NULL) && 551 (size != 0U) && 552 ((buf & MMC_BLOCK_MASK) == 0U) && 553 ((size & MMC_BLOCK_MASK) == 0U)); 554 555 ret = ops->prepare(lba, buf, size); 556 if (ret != 0) { 557 return 0; 558 } 559 560 if (is_cmd23_enabled()) { 561 /* Set block count */ 562 ret = mmc_send_cmd(MMC_CMD(23), size / MMC_BLOCK_SIZE, 563 MMC_RESPONSE_R(1), NULL); 564 if (ret != 0) { 565 return 0; 566 } 567 568 cmd_idx = MMC_CMD(25); 569 } else { 570 if (size > MMC_BLOCK_SIZE) { 571 cmd_idx = MMC_CMD(25); 572 } else { 573 cmd_idx = MMC_CMD(24); 574 } 575 } 576 577 if ((mmc_ocr_value & OCR_ACCESS_MODE_MASK) == OCR_BYTE_MODE) { 578 cmd_arg = lba * MMC_BLOCK_SIZE; 579 } else { 580 cmd_arg = lba; 581 } 582 583 ret = mmc_send_cmd(cmd_idx, cmd_arg, MMC_RESPONSE_R(1), NULL); 584 if (ret != 0) { 585 return 0; 586 } 587 588 ret = ops->write(lba, buf, size); 589 if (ret != 0) { 590 return 0; 591 } 592 593 /* Wait buffer empty */ 594 do { 595 ret = mmc_device_state(); 596 if (ret < 0) { 597 return 0; 598 } 599 } while ((ret != MMC_STATE_TRAN) && (ret != MMC_STATE_RCV)); 600 601 if (!is_cmd23_enabled() && (size > MMC_BLOCK_SIZE)) { 602 ret = mmc_send_cmd(MMC_CMD(12), 0, 0, NULL); 603 if (ret != 0) { 604 return 0; 605 } 606 } 607 608 return size; 609 } 610 611 size_t mmc_erase_blocks(unsigned int lba, size_t size) 612 { 613 int ret; 614 615 assert(ops != NULL); 616 assert((size != 0U) && ((size & MMC_BLOCK_MASK) == 0U)); 617 618 ret = mmc_send_cmd(MMC_CMD(35), lba, MMC_RESPONSE_R(1), NULL); 619 if (ret != 0) { 620 return 0; 621 } 622 623 ret = mmc_send_cmd(MMC_CMD(36), lba + (size / MMC_BLOCK_SIZE) - 1U, 624 MMC_RESPONSE_R(1), NULL); 625 if (ret != 0) { 626 return 0; 627 } 628 629 ret = mmc_send_cmd(MMC_CMD(38), lba, MMC_RESPONSE_R(0x1B), NULL); 630 if (ret != 0) { 631 return 0; 632 } 633 634 do { 635 ret = mmc_device_state(); 636 if (ret < 0) { 637 return 0; 638 } 639 } while (ret != MMC_STATE_TRAN); 640 641 return size; 642 } 643 644 static inline void mmc_rpmb_enable(void) 645 { 646 mmc_set_ext_csd(CMD_EXTCSD_PARTITION_CONFIG, 647 PART_CFG_BOOT_PARTITION1_ENABLE | 648 PART_CFG_PARTITION1_ACCESS); 649 } 650 651 static inline void mmc_rpmb_disable(void) 652 { 653 mmc_set_ext_csd(CMD_EXTCSD_PARTITION_CONFIG, 654 PART_CFG_BOOT_PARTITION1_ENABLE); 655 } 656 657 size_t mmc_rpmb_read_blocks(unsigned int lba, uintptr_t buf, size_t size) 658 { 659 size_t size_read; 660 661 mmc_rpmb_enable(); 662 size_read = mmc_read_blocks(lba, buf, size); 663 mmc_rpmb_disable(); 664 665 return size_read; 666 } 667 668 size_t mmc_rpmb_write_blocks(unsigned int lba, const uintptr_t buf, size_t size) 669 { 670 size_t size_written; 671 672 mmc_rpmb_enable(); 673 size_written = mmc_write_blocks(lba, buf, size); 674 mmc_rpmb_disable(); 675 676 return size_written; 677 } 678 679 size_t mmc_rpmb_erase_blocks(unsigned int lba, size_t size) 680 { 681 size_t size_erased; 682 683 mmc_rpmb_enable(); 684 size_erased = mmc_erase_blocks(lba, size); 685 mmc_rpmb_disable(); 686 687 return size_erased; 688 } 689 690 int mmc_init(const struct mmc_ops *ops_ptr, unsigned int clk, 691 unsigned int width, unsigned int flags, 692 struct mmc_device_info *device_info) 693 { 694 assert((ops_ptr != NULL) && 695 (ops_ptr->init != NULL) && 696 (ops_ptr->send_cmd != NULL) && 697 (ops_ptr->set_ios != NULL) && 698 (ops_ptr->prepare != NULL) && 699 (ops_ptr->read != NULL) && 700 (ops_ptr->write != NULL) && 701 (device_info != NULL) && 702 (clk != 0) && 703 ((width == MMC_BUS_WIDTH_1) || 704 (width == MMC_BUS_WIDTH_4) || 705 (width == MMC_BUS_WIDTH_8) || 706 (width == MMC_BUS_WIDTH_DDR_4) || 707 (width == MMC_BUS_WIDTH_DDR_8))); 708 709 ops = ops_ptr; 710 mmc_flags = flags; 711 mmc_dev_info = device_info; 712 713 return mmc_enumerate(clk, width); 714 } 715