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