drivers/mmc/mmc.c

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