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