drivers/mmc/mmc.c

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