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         if (!(cmd.response[0] & OCR_BUSY))
 328                 return UNUSABLE_ERR;
 329
 330         if (mmc->version != SD_VERSION_2)
 331                 mmc->version = SD_VERSION_1_0;
 332
 333         if (mmc_host_is_spi(mmc)) { /* read OCR for spi */
 334                 cmd.cmdidx = MMC_CMD_SPI_READ_OCR;
 335                 cmd.resp_type = MMC_RSP_R3;
 336                 cmd.cmdarg = 0;
 337
 338                 err = mmc_send_cmd(mmc, &cmd, NULL);
 339
 340                 if (err)
 341                         return err;
 342         }
 343
 344         mmc->ocr = cmd.response[0];
 345
 346         mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS);
 347         mmc->rca = 0;
 348
 349         return 0;
 350 }
 351
 352 /* We pass in the cmd since otherwise the init seems to fail */
 353 static int mmc_send_op_cond_iter(struct mmc *mmc, struct mmc_cmd *cmd,
 354                 int use_arg)
 355 {
 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->op_cond_response & OCR_VOLTAGE_MASK)) |
 365                         (mmc->op_cond_response & 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->op_cond_response = cmd->response[0];
 374         return 0;
 375 }
 376
 377 static int mmc_send_op_cond(struct mmc *mmc)
 378 {
 379         struct mmc_cmd cmd;
 380         int err, i;
 381
 382         /* Some cards seem to need this */
 383         mmc_go_idle(mmc);
 384
 385         /* Asking to the card its capabilities */
 386         mmc->op_cond_pending = 1;
 387         for (i = 0; i < 2; i++) {
 388                 err = mmc_send_op_cond_iter(mmc, &cmd, i != 0);
 389                 if (err)
 390                         return err;
 391
 392                 /* exit if not busy (flag seems to be inverted) */
 393                 if (mmc->op_cond_response & OCR_BUSY)
 394                         return 0;
 395         }
 396         return IN_PROGRESS;
 397 }
 398
 399 static int mmc_complete_op_cond(struct mmc *mmc)
 400 {
 401         struct mmc_cmd cmd;
 402         int timeout = 1000;
 403         uint start;
 404         int err;
 405
 406         mmc->op_cond_pending = 0;
 407         start = get_timer(0);
 408         do {
 409                 err = mmc_send_op_cond_iter(mmc, &cmd, 1);
 410                 if (err)
 411                         return err;
 412                 if (get_timer(start) > timeout)
 413                         break;
 414                 udelay(100);
 415         } while (!(mmc->op_cond_response & OCR_BUSY));
 416         if (!(mmc->op_cond_response & OCR_BUSY)) {
 417                 debug("%s: timeout\n", __func__);
 418                 return UNUSABLE_ERR;
 419         }
 420
 421         if (mmc_host_is_spi(mmc)) { /* read OCR for spi */
 422                 cmd.cmdidx = MMC_CMD_SPI_READ_OCR;
 423                 cmd.resp_type = MMC_RSP_R3;
 424                 cmd.cmdarg = 0;
 425
 426                 err = mmc_send_cmd(mmc, &cmd, NULL);
 427
 428                 if (err)
 429                         return err;
 430         }
 431
 432         mmc->version = MMC_VERSION_UNKNOWN;
 433         mmc->ocr = cmd.response[0];
 434
 435         mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS);
 436         mmc->rca = 1;
 437
 438         return 0;
 439 }
 440
 441
 442 static int mmc_send_ext_csd(struct mmc *mmc, u8 *ext_csd)
 443 {
 444         struct mmc_cmd cmd;
 445         struct mmc_data data;
 446         int err;
 447
 448         /* Get the Card Status Register */
 449         cmd.cmdidx = MMC_CMD_SEND_EXT_CSD;
 450         cmd.resp_type = MMC_RSP_R1;
 451         cmd.cmdarg = 0;
 452
 453         data.dest = (char *)ext_csd;
 454         data.blocks = 1;
 455         data.blocksize = MMC_MAX_BLOCK_LEN;
 456         data.flags = MMC_DATA_READ;
 457
 458         err = mmc_send_cmd(mmc, &cmd, &data);
 459
 460         return err;
 461 }
 462
 463
 464 static int mmc_switch(struct mmc *mmc, u8 set, u8 index, u8 value)
 465 {
 466         struct mmc_cmd cmd;
 467         int timeout = 1000;
 468         int ret;
 469
 470         cmd.cmdidx = MMC_CMD_SWITCH;
 471         cmd.resp_type = MMC_RSP_R1b;
 472         cmd.cmdarg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) |
 473                                  (index << 16) |
 474                                  (value << 8);
 475
 476         ret = mmc_send_cmd(mmc, &cmd, NULL);
 477
 478         /* Waiting for the ready status */
 479         if (!ret)
 480                 ret = mmc_send_status(mmc, timeout);
 481
 482         return ret;
 483
 484 }
 485
 486 static int mmc_change_freq(struct mmc *mmc)
 487 {
 488         ALLOC_CACHE_ALIGN_BUFFER(u8, ext_csd, MMC_MAX_BLOCK_LEN);
 489         char cardtype;
 490         int err;
 491
 492         mmc->card_caps = MMC_MODE_4BIT | MMC_MODE_8BIT;
 493
 494         if (mmc_host_is_spi(mmc))
 495                 return 0;
 496
 497         /* Only version 4 supports high-speed */
 498         if (mmc->version < MMC_VERSION_4)
 499                 return 0;
 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_getcd(struct mmc *mmc)
 612 {
 613         int cd;
 614
 615         cd = board_mmc_getcd(mmc);
 616
 617         if (cd < 0) {
 618                 if (mmc->cfg->ops->getcd)
 619                         cd = mmc->cfg->ops->getcd(mmc);
 620                 else
 621                         cd = 1;
 622         }
 623
 624         return cd;
 625 }
 626
 627 static int sd_switch(struct mmc *mmc, int mode, int group, u8 value, u8 *resp)
 628 {
 629         struct mmc_cmd cmd;
 630         struct mmc_data data;
 631
 632         /* Switch the frequency */
 633         cmd.cmdidx = SD_CMD_SWITCH_FUNC;
 634         cmd.resp_type = MMC_RSP_R1;
 635         cmd.cmdarg = (mode << 31) | 0xffffff;
 636         cmd.cmdarg &= ~(0xf << (group * 4));
 637         cmd.cmdarg |= value << (group * 4);
 638
 639         data.dest = (char *)resp;
 640         data.blocksize = 64;
 641         data.blocks = 1;
 642         data.flags = MMC_DATA_READ;
 643
 644         return mmc_send_cmd(mmc, &cmd, &data);
 645 }
 646
 647
 648 static int sd_change_freq(struct mmc *mmc)
 649 {
 650         int err;
 651         struct mmc_cmd cmd;
 652         ALLOC_CACHE_ALIGN_BUFFER(uint, scr, 2);
 653         ALLOC_CACHE_ALIGN_BUFFER(uint, switch_status, 16);
 654         struct mmc_data data;
 655         int timeout;
 656
 657         mmc->card_caps = 0;
 658
 659         if (mmc_host_is_spi(mmc))
 660                 return 0;
 661
 662         /* Read the SCR to find out if this card supports higher speeds */
 663         cmd.cmdidx = MMC_CMD_APP_CMD;
 664         cmd.resp_type = MMC_RSP_R1;
 665         cmd.cmdarg = mmc->rca << 16;
 666
 667         err = mmc_send_cmd(mmc, &cmd, NULL);
 668
 669         if (err)
 670                 return err;
 671
 672         cmd.cmdidx = SD_CMD_APP_SEND_SCR;
 673         cmd.resp_type = MMC_RSP_R1;
 674         cmd.cmdarg = 0;
 675
 676         timeout = 3;
 677
 678 retry_scr:
 679         data.dest = (char *)scr;
 680         data.blocksize = 8;
 681         data.blocks = 1;
 682         data.flags = MMC_DATA_READ;
 683
 684         err = mmc_send_cmd(mmc, &cmd, &data);
 685
 686         if (err) {
 687                 if (timeout--)
 688                         goto retry_scr;
 689
 690                 return err;
 691         }
 692
 693         mmc->scr[0] = __be32_to_cpu(scr[0]);
 694         mmc->scr[1] = __be32_to_cpu(scr[1]);
 695
 696         switch ((mmc->scr[0] >> 24) & 0xf) {
 697                 case 0:
 698                         mmc->version = SD_VERSION_1_0;
 699                         break;
 700                 case 1:
 701                         mmc->version = SD_VERSION_1_10;
 702                         break;
 703                 case 2:
 704                         mmc->version = SD_VERSION_2;
 705                         if ((mmc->scr[0] >> 15) & 0x1)
 706                                 mmc->version = SD_VERSION_3;
 707                         break;
 708                 default:
 709                         mmc->version = SD_VERSION_1_0;
 710                         break;
 711         }
 712
 713         if (mmc->scr[0] & SD_DATA_4BIT)
 714                 mmc->card_caps |= MMC_MODE_4BIT;
 715
 716         /* Version 1.0 doesn't support switching */
 717         if (mmc->version == SD_VERSION_1_0)
 718                 return 0;
 719
 720         timeout = 4;
 721         while (timeout--) {
 722                 err = sd_switch(mmc, SD_SWITCH_CHECK, 0, 1,
 723                                 (u8 *)switch_status);
 724
 725                 if (err)
 726                         return err;
 727
 728                 /* The high-speed function is busy.  Try again */
 729                 if (!(__be32_to_cpu(switch_status[7]) & SD_HIGHSPEED_BUSY))
 730                         break;
 731         }
 732
 733         /* If high-speed isn't supported, we return */
 734         if (!(__be32_to_cpu(switch_status[3]) & SD_HIGHSPEED_SUPPORTED))
 735                 return 0;
 736
 737         /*
 738          * If the host doesn't support SD_HIGHSPEED, do not switch card to
 739          * HIGHSPEED mode even if the card support SD_HIGHSPPED.
 740          * This can avoid furthur problem when the card runs in different
 741          * mode between the host.
 742          */
 743         if (!((mmc->cfg->host_caps & MMC_MODE_HS_52MHz) &&
 744                 (mmc->cfg->host_caps & MMC_MODE_HS)))
 745                 return 0;
 746
 747         err = sd_switch(mmc, SD_SWITCH_SWITCH, 0, 1, (u8 *)switch_status);
 748
 749         if (err)
 750                 return err;
 751
 752         if ((__be32_to_cpu(switch_status[4]) & 0x0f000000) == 0x01000000)
 753                 mmc->card_caps |= MMC_MODE_HS;
 754
 755         return 0;
 756 }
 757
 758 /* frequency bases */
 759 /* divided by 10 to be nice to platforms without floating point */
 760 static const int fbase[] = {
 761         10000,
 762         100000,
 763         1000000,
 764         10000000,
 765 };
 766
 767 /* Multiplier values for TRAN_SPEED.  Multiplied by 10 to be nice
 768  * to platforms without floating point.
 769  */
 770 static const int multipliers[] = {
 771         0,      /* reserved */
 772         10,
 773         12,
 774         13,
 775         15,
 776         20,
 777         25,
 778         30,
 779         35,
 780         40,
 781         45,
 782         50,
 783         55,
 784         60,
 785         70,
 786         80,
 787 };
 788
 789 static void mmc_set_ios(struct mmc *mmc)
 790 {
 791         if (mmc->cfg->ops->set_ios)
 792                 mmc->cfg->ops->set_ios(mmc);
 793 }
 794
 795 void mmc_set_clock(struct mmc *mmc, uint clock)
 796 {
 797         if (clock > mmc->cfg->f_max)
 798                 clock = mmc->cfg->f_max;
 799
 800         if (clock < mmc->cfg->f_min)
 801                 clock = mmc->cfg->f_min;
 802
 803         mmc->clock = clock;
 804
 805         mmc_set_ios(mmc);
 806 }
 807
 808 static void mmc_set_bus_width(struct mmc *mmc, uint width)
 809 {
 810         mmc->bus_width = width;
 811
 812         mmc_set_ios(mmc);
 813 }
 814
 815 static int mmc_startup(struct mmc *mmc)
 816 {
 817         int err, i;
 818         uint mult, freq;
 819         u64 cmult, csize, capacity;
 820         struct mmc_cmd cmd;
 821         ALLOC_CACHE_ALIGN_BUFFER(u8, ext_csd, MMC_MAX_BLOCK_LEN);
 822         ALLOC_CACHE_ALIGN_BUFFER(u8, test_csd, MMC_MAX_BLOCK_LEN);
 823         int timeout = 1000;
 824
 825 #ifdef CONFIG_MMC_SPI_CRC_ON
 826         if (mmc_host_is_spi(mmc)) { /* enable CRC check for spi */
 827                 cmd.cmdidx = MMC_CMD_SPI_CRC_ON_OFF;
 828                 cmd.resp_type = MMC_RSP_R1;
 829                 cmd.cmdarg = 1;
 830                 err = mmc_send_cmd(mmc, &cmd, NULL);
 831
 832                 if (err)
 833                         return err;
 834         }
 835 #endif
 836
 837         /* Put the Card in Identify Mode */
 838         cmd.cmdidx = mmc_host_is_spi(mmc) ? MMC_CMD_SEND_CID :
 839                 MMC_CMD_ALL_SEND_CID; /* cmd not supported in spi */
 840         cmd.resp_type = MMC_RSP_R2;
 841         cmd.cmdarg = 0;
 842
 843         err = mmc_send_cmd(mmc, &cmd, NULL);
 844
 845         if (err)
 846                 return err;
 847
 848         memcpy(mmc->cid, cmd.response, 16);
 849
 850         /*
 851          * For MMC cards, set the Relative Address.
 852          * For SD cards, get the Relatvie Address.
 853          * This also puts the cards into Standby State
 854          */
 855         if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */
 856                 cmd.cmdidx = SD_CMD_SEND_RELATIVE_ADDR;
 857                 cmd.cmdarg = mmc->rca << 16;
 858                 cmd.resp_type = MMC_RSP_R6;
 859
 860                 err = mmc_send_cmd(mmc, &cmd, NULL);
 861
 862                 if (err)
 863                         return err;
 864
 865                 if (IS_SD(mmc))
 866                         mmc->rca = (cmd.response[0] >> 16) & 0xffff;
 867         }
 868
 869         /* Get the Card-Specific Data */
 870         cmd.cmdidx = MMC_CMD_SEND_CSD;
 871         cmd.resp_type = MMC_RSP_R2;
 872         cmd.cmdarg = mmc->rca << 16;
 873
 874         err = mmc_send_cmd(mmc, &cmd, NULL);
 875
 876         /* Waiting for the ready status */
 877         mmc_send_status(mmc, timeout);
 878
 879         if (err)
 880                 return err;
 881
 882         mmc->csd[0] = cmd.response[0];
 883         mmc->csd[1] = cmd.response[1];
 884         mmc->csd[2] = cmd.response[2];
 885         mmc->csd[3] = cmd.response[3];
 886
 887         if (mmc->version == MMC_VERSION_UNKNOWN) {
 888                 int version = (cmd.response[0] >> 26) & 0xf;
 889
 890                 switch (version) {
 891                         case 0:
 892                                 mmc->version = MMC_VERSION_1_2;
 893                                 break;
 894                         case 1:
 895                                 mmc->version = MMC_VERSION_1_4;
 896                                 break;
 897                         case 2:
 898                                 mmc->version = MMC_VERSION_2_2;
 899                                 break;
 900                         case 3:
 901                                 mmc->version = MMC_VERSION_3;
 902                                 break;
 903                         case 4:
 904                                 mmc->version = MMC_VERSION_4;
 905                                 break;
 906                         default:
 907                                 mmc->version = MMC_VERSION_1_2;
 908                                 break;
 909                 }
 910         }
 911
 912         /* divide frequency by 10, since the mults are 10x bigger */
 913         freq = fbase[(cmd.response[0] & 0x7)];
 914         mult = multipliers[((cmd.response[0] >> 3) & 0xf)];
 915
 916         mmc->tran_speed = freq * mult;
 917
 918         mmc->dsr_imp = ((cmd.response[1] >> 12) & 0x1);
 919         mmc->read_bl_len = 1 << ((cmd.response[1] >> 16) & 0xf);
 920
 921         if (IS_SD(mmc))
 922                 mmc->write_bl_len = mmc->read_bl_len;
 923         else
 924                 mmc->write_bl_len = 1 << ((cmd.response[3] >> 22) & 0xf);
 925
 926         if (mmc->high_capacity) {
 927                 csize = (mmc->csd[1] & 0x3f) << 16
 928                         | (mmc->csd[2] & 0xffff0000) >> 16;
 929                 cmult = 8;
 930         } else {
 931                 csize = (mmc->csd[1] & 0x3ff) << 2
 932                         | (mmc->csd[2] & 0xc0000000) >> 30;
 933                 cmult = (mmc->csd[2] & 0x00038000) >> 15;
 934         }
 935
 936         mmc->capacity_user = (csize + 1) << (cmult + 2);
 937         mmc->capacity_user *= mmc->read_bl_len;
 938         mmc->capacity_boot = 0;
 939         mmc->capacity_rpmb = 0;
 940         for (i = 0; i < 4; i++)
 941                 mmc->capacity_gp[i] = 0;
 942
 943         if (mmc->read_bl_len > MMC_MAX_BLOCK_LEN)
 944                 mmc->read_bl_len = MMC_MAX_BLOCK_LEN;
 945
 946         if (mmc->write_bl_len > MMC_MAX_BLOCK_LEN)
 947                 mmc->write_bl_len = MMC_MAX_BLOCK_LEN;
 948
 949         if ((mmc->dsr_imp) && (0xffffffff != mmc->dsr)) {
 950                 cmd.cmdidx = MMC_CMD_SET_DSR;
 951                 cmd.cmdarg = (mmc->dsr & 0xffff) << 16;
 952                 cmd.resp_type = MMC_RSP_NONE;
 953                 if (mmc_send_cmd(mmc, &cmd, NULL))
 954                         printf("MMC: SET_DSR failed\n");
 955         }
 956
 957         /* Select the card, and put it into Transfer Mode */
 958         if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */
 959                 cmd.cmdidx = MMC_CMD_SELECT_CARD;
 960                 cmd.resp_type = MMC_RSP_R1;
 961                 cmd.cmdarg = mmc->rca << 16;
 962                 err = mmc_send_cmd(mmc, &cmd, NULL);
 963
 964                 if (err)
 965                         return err;
 966         }
 967
 968         /*
 969          * For SD, its erase group is always one sector
 970          */
 971         mmc->erase_grp_size = 1;
 972         mmc->part_config = MMCPART_NOAVAILABLE;
 973         if (!IS_SD(mmc) && (mmc->version >= MMC_VERSION_4)) {
 974                 /* check  ext_csd version and capacity */
 975                 err = mmc_send_ext_csd(mmc, ext_csd);
 976                 if (!err && (ext_csd[EXT_CSD_REV] >= 2)) {
 977                         /*
 978                          * According to the JEDEC Standard, the value of
 979                          * ext_csd's capacity is valid if the value is more
 980                          * than 2GB
 981                          */
 982                         capacity = ext_csd[EXT_CSD_SEC_CNT] << 0
 983                                         | ext_csd[EXT_CSD_SEC_CNT + 1] << 8
 984                                         | ext_csd[EXT_CSD_SEC_CNT + 2] << 16
 985                                         | ext_csd[EXT_CSD_SEC_CNT + 3] << 24;
 986                         capacity *= MMC_MAX_BLOCK_LEN;
 987                         if ((capacity >> 20) > 2 * 1024)
 988                                 mmc->capacity_user = capacity;
 989                 }
 990
 991                 switch (ext_csd[EXT_CSD_REV]) {
 992                 case 1:
 993                         mmc->version = MMC_VERSION_4_1;
 994                         break;
 995                 case 2:
 996                         mmc->version = MMC_VERSION_4_2;
 997                         break;
 998                 case 3:
 999                         mmc->version = MMC_VERSION_4_3;
1000                         break;
1001                 case 5:
1002                         mmc->version = MMC_VERSION_4_41;
1003                         break;
1004                 case 6:
1005                         mmc->version = MMC_VERSION_4_5;
1006                         break;
1007                 case 7:
1008                         mmc->version = MMC_VERSION_5_0;
1009                         break;
1010                 }
1011
1012                 /*
1013                  * Host needs to enable ERASE_GRP_DEF bit if device is
1014                  * partitioned. This bit will be lost every time after a reset
1015                  * or power off. This will affect erase size.
1016                  */
1017                 if ((ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & PART_SUPPORT) &&
1018                     (ext_csd[EXT_CSD_PARTITIONS_ATTRIBUTE] & PART_ENH_ATTRIB)) {
1019                         err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1020                                 EXT_CSD_ERASE_GROUP_DEF, 1);
1021
1022                         if (err)
1023                                 return err;
1024                         else
1025                                 ext_csd[EXT_CSD_ERASE_GROUP_DEF] = 1;
1026
1027                         /* Read out group size from ext_csd */
1028                         mmc->erase_grp_size =
1029                                 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] *
1030                                         MMC_MAX_BLOCK_LEN * 1024;
1031                         /*
1032                          * if high capacity and partition setting completed
1033                          * SEC_COUNT is valid even if it is smaller than 2 GiB
1034                          * JEDEC Standard JESD84-B45, 6.2.4
1035                          */
1036                         if (mmc->high_capacity &&
1037                             (ext_csd[EXT_CSD_PARTITION_SETTING] &
1038                              EXT_CSD_PARTITION_SETTING_COMPLETED)) {
1039                                 capacity = (ext_csd[EXT_CSD_SEC_CNT]) |
1040                                         (ext_csd[EXT_CSD_SEC_CNT + 1] << 8) |
1041                                         (ext_csd[EXT_CSD_SEC_CNT + 2] << 16) |
1042                                         (ext_csd[EXT_CSD_SEC_CNT + 3] << 24);
1043                                 capacity *= MMC_MAX_BLOCK_LEN;
1044                                 mmc->capacity_user = capacity;
1045                         }
1046                 } else {
1047                         /* Calculate the group size from the csd value. */
1048                         int erase_gsz, erase_gmul;
1049                         erase_gsz = (mmc->csd[2] & 0x00007c00) >> 10;
1050                         erase_gmul = (mmc->csd[2] & 0x000003e0) >> 5;
1051                         mmc->erase_grp_size = (erase_gsz + 1)
1052                                 * (erase_gmul + 1);
1053                 }
1054
1055                 /* store the partition info of emmc */
1056                 if ((ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & PART_SUPPORT) ||
1057                     ext_csd[EXT_CSD_BOOT_MULT])
1058                         mmc->part_config = ext_csd[EXT_CSD_PART_CONF];
1059
1060                 mmc->capacity_boot = ext_csd[EXT_CSD_BOOT_MULT] << 17;
1061
1062                 mmc->capacity_rpmb = ext_csd[EXT_CSD_RPMB_MULT] << 17;
1063
1064                 for (i = 0; i < 4; i++) {
1065                         int idx = EXT_CSD_GP_SIZE_MULT + i * 3;
1066                         mmc->capacity_gp[i] = (ext_csd[idx + 2] << 16) +
1067                                 (ext_csd[idx + 1] << 8) + ext_csd[idx];
1068                         mmc->capacity_gp[i] *=
1069                                 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
1070                         mmc->capacity_gp[i] *= ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
1071                 }
1072         }
1073
1074         err = mmc_set_capacity(mmc, mmc->part_num);
1075         if (err)
1076                 return err;
1077
1078         if (IS_SD(mmc))
1079                 err = sd_change_freq(mmc);
1080         else
1081                 err = mmc_change_freq(mmc);
1082
1083         if (err)
1084                 return err;
1085
1086         /* Restrict card's capabilities by what the host can do */
1087         mmc->card_caps &= mmc->cfg->host_caps;
1088
1089         if (IS_SD(mmc)) {
1090                 if (mmc->card_caps & MMC_MODE_4BIT) {
1091                         cmd.cmdidx = MMC_CMD_APP_CMD;
1092                         cmd.resp_type = MMC_RSP_R1;
1093                         cmd.cmdarg = mmc->rca << 16;
1094
1095                         err = mmc_send_cmd(mmc, &cmd, NULL);
1096                         if (err)
1097                                 return err;
1098
1099                         cmd.cmdidx = SD_CMD_APP_SET_BUS_WIDTH;
1100                         cmd.resp_type = MMC_RSP_R1;
1101                         cmd.cmdarg = 2;
1102                         err = mmc_send_cmd(mmc, &cmd, NULL);
1103                         if (err)
1104                                 return err;
1105
1106                         mmc_set_bus_width(mmc, 4);
1107                 }
1108
1109                 if (mmc->card_caps & MMC_MODE_HS)
1110                         mmc->tran_speed = 50000000;
1111                 else
1112                         mmc->tran_speed = 25000000;
1113         } else {
1114                 int idx;
1115
1116                 /* An array of possible bus widths in order of preference */
1117                 static unsigned ext_csd_bits[] = {
1118                         EXT_CSD_DDR_BUS_WIDTH_8,
1119                         EXT_CSD_DDR_BUS_WIDTH_4,
1120                         EXT_CSD_BUS_WIDTH_8,
1121                         EXT_CSD_BUS_WIDTH_4,
1122                         EXT_CSD_BUS_WIDTH_1,
1123                 };
1124
1125                 /* An array to map CSD bus widths to host cap bits */
1126                 static unsigned ext_to_hostcaps[] = {
1127                         [EXT_CSD_DDR_BUS_WIDTH_4] =
1128                                 MMC_MODE_DDR_52MHz | MMC_MODE_4BIT,
1129                         [EXT_CSD_DDR_BUS_WIDTH_8] =
1130                                 MMC_MODE_DDR_52MHz | MMC_MODE_8BIT,
1131                         [EXT_CSD_BUS_WIDTH_4] = MMC_MODE_4BIT,
1132                         [EXT_CSD_BUS_WIDTH_8] = MMC_MODE_8BIT,
1133                 };
1134
1135                 /* An array to map chosen bus width to an integer */
1136                 static unsigned widths[] = {
1137                         8, 4, 8, 4, 1,
1138                 };
1139
1140                 for (idx=0; idx < ARRAY_SIZE(ext_csd_bits); idx++) {
1141                         unsigned int extw = ext_csd_bits[idx];
1142                         unsigned int caps = ext_to_hostcaps[extw];
1143
1144                         /*
1145                          * Check to make sure the card and controller support
1146                          * these capabilities
1147                          */
1148                         if ((mmc->card_caps & caps) != caps)
1149                                 continue;
1150
1151                         err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1152                                         EXT_CSD_BUS_WIDTH, extw);
1153
1154                         if (err)
1155                                 continue;
1156
1157                         mmc->ddr_mode = (caps & MMC_MODE_DDR_52MHz) ? 1 : 0;
1158                         mmc_set_bus_width(mmc, widths[idx]);
1159
1160                         err = mmc_send_ext_csd(mmc, test_csd);
1161
1162                         if (err)
1163                                 continue;
1164
1165                         /* Only compare read only fields */
1166                         if (ext_csd[EXT_CSD_PARTITIONING_SUPPORT]
1167                                 == test_csd[EXT_CSD_PARTITIONING_SUPPORT] &&
1168                             ext_csd[EXT_CSD_HC_WP_GRP_SIZE]
1169                                 == test_csd[EXT_CSD_HC_WP_GRP_SIZE] &&
1170                             ext_csd[EXT_CSD_REV]
1171                                 == test_csd[EXT_CSD_REV] &&
1172                             ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]
1173                                 == test_csd[EXT_CSD_HC_ERASE_GRP_SIZE] &&
1174                             memcmp(&ext_csd[EXT_CSD_SEC_CNT],
1175                                    &test_csd[EXT_CSD_SEC_CNT], 4) == 0)
1176                                 break;
1177                         else
1178                                 err = SWITCH_ERR;
1179                 }
1180
1181                 if (err)
1182                         return err;
1183
1184                 if (mmc->card_caps & MMC_MODE_HS) {
1185                         if (mmc->card_caps & MMC_MODE_HS_52MHz)
1186                                 mmc->tran_speed = 52000000;
1187                         else
1188                                 mmc->tran_speed = 26000000;
1189                 }
1190         }
1191
1192         mmc_set_clock(mmc, mmc->tran_speed);
1193
1194         /* Fix the block length for DDR mode */
1195         if (mmc->ddr_mode) {
1196                 mmc->read_bl_len = MMC_MAX_BLOCK_LEN;
1197                 mmc->write_bl_len = MMC_MAX_BLOCK_LEN;
1198         }
1199
1200         /* fill in device description */
1201         mmc->block_dev.lun = 0;
1202         mmc->block_dev.type = 0;
1203         mmc->block_dev.blksz = mmc->read_bl_len;
1204         mmc->block_dev.log2blksz = LOG2(mmc->block_dev.blksz);
1205         mmc->block_dev.lba = lldiv(mmc->capacity, mmc->read_bl_len);
1206 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
1207         sprintf(mmc->block_dev.vendor, "Man %06x Snr %04x%04x",
1208                 mmc->cid[0] >> 24, (mmc->cid[2] & 0xffff),
1209                 (mmc->cid[3] >> 16) & 0xffff);
1210         sprintf(mmc->block_dev.product, "%c%c%c%c%c%c", mmc->cid[0] & 0xff,
1211                 (mmc->cid[1] >> 24), (mmc->cid[1] >> 16) & 0xff,
1212                 (mmc->cid[1] >> 8) & 0xff, mmc->cid[1] & 0xff,
1213                 (mmc->cid[2] >> 24) & 0xff);
1214         sprintf(mmc->block_dev.revision, "%d.%d", (mmc->cid[2] >> 20) & 0xf,
1215                 (mmc->cid[2] >> 16) & 0xf);
1216 #else
1217         mmc->block_dev.vendor[0] = 0;
1218         mmc->block_dev.product[0] = 0;
1219         mmc->block_dev.revision[0] = 0;
1220 #endif
1221 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBDISK_SUPPORT)
1222         init_part(&mmc->block_dev);
1223 #endif
1224
1225         return 0;
1226 }
1227
1228 static int mmc_send_if_cond(struct mmc *mmc)
1229 {
1230         struct mmc_cmd cmd;
1231         int err;
1232
1233         cmd.cmdidx = SD_CMD_SEND_IF_COND;
1234         /* We set the bit if the host supports voltages between 2.7 and 3.6 V */
1235         cmd.cmdarg = ((mmc->cfg->voltages & 0xff8000) != 0) << 8 | 0xaa;
1236         cmd.resp_type = MMC_RSP_R7;
1237
1238         err = mmc_send_cmd(mmc, &cmd, NULL);
1239
1240         if (err)
1241                 return err;
1242
1243         if ((cmd.response[0] & 0xff) != 0xaa)
1244                 return UNUSABLE_ERR;
1245         else
1246                 mmc->version = SD_VERSION_2;
1247
1248         return 0;
1249 }
1250
1251 /* not used any more */
1252 int __deprecated mmc_register(struct mmc *mmc)
1253 {
1254 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
1255         printf("%s is deprecated! use mmc_create() instead.\n", __func__);
1256 #endif
1257         return -1;
1258 }
1259
1260 struct mmc *mmc_create(const struct mmc_config *cfg, void *priv)
1261 {
1262         struct mmc *mmc;
1263
1264         /* quick validation */
1265         if (cfg == NULL || cfg->ops == NULL || cfg->ops->send_cmd == NULL ||
1266                         cfg->f_min == 0 || cfg->f_max == 0 || cfg->b_max == 0)
1267                 return NULL;
1268
1269         mmc = calloc(1, sizeof(*mmc));
1270         if (mmc == NULL)
1271                 return NULL;
1272
1273         mmc->cfg = cfg;
1274         mmc->priv = priv;
1275
1276         /* the following chunk was mmc_register() */
1277
1278         /* Setup dsr related values */
1279         mmc->dsr_imp = 0;
1280         mmc->dsr = 0xffffffff;
1281         /* Setup the universal parts of the block interface just once */
1282         mmc->block_dev.if_type = IF_TYPE_MMC;
1283         mmc->block_dev.dev = cur_dev_num++;
1284         mmc->block_dev.removable = 1;
1285         mmc->block_dev.block_read = mmc_bread;
1286         mmc->block_dev.block_write = mmc_bwrite;
1287         mmc->block_dev.block_erase = mmc_berase;
1288
1289         /* setup initial part type */
1290         mmc->block_dev.part_type = mmc->cfg->part_type;
1291
1292         INIT_LIST_HEAD(&mmc->link);
1293
1294         list_add_tail(&mmc->link, &mmc_devices);
1295
1296         return mmc;
1297 }
1298
1299 void mmc_destroy(struct mmc *mmc)
1300 {
1301         /* only freeing memory for now */
1302         free(mmc);
1303 }
1304
1305 #ifdef CONFIG_PARTITIONS
1306 block_dev_desc_t *mmc_get_dev(int dev)
1307 {
1308         struct mmc *mmc = find_mmc_device(dev);
1309         if (!mmc || mmc_init(mmc))
1310                 return NULL;
1311
1312         return &mmc->block_dev;
1313 }
1314 #endif
1315
1316 /* board-specific MMC power initializations. */
1317 __weak void board_mmc_power_init(void)
1318 {
1319 }
1320
1321 int mmc_start_init(struct mmc *mmc)
1322 {
1323         int err;
1324
1325         /* we pretend there's no card when init is NULL */
1326         if (mmc_getcd(mmc) == 0 || mmc->cfg->ops->init == NULL) {
1327                 mmc->has_init = 0;
1328 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
1329                 printf("MMC: no card present\n");
1330 #endif
1331                 return NO_CARD_ERR;
1332         }
1333
1334         if (mmc->has_init)
1335                 return 0;
1336
1337         board_mmc_power_init();
1338
1339         /* made sure it's not NULL earlier */
1340         err = mmc->cfg->ops->init(mmc);
1341
1342         if (err)
1343                 return err;
1344
1345         mmc->ddr_mode = 0;
1346         mmc_set_bus_width(mmc, 1);
1347         mmc_set_clock(mmc, 1);
1348
1349         /* Reset the Card */
1350         err = mmc_go_idle(mmc);
1351
1352         if (err)
1353                 return err;
1354
1355         /* The internal partition reset to user partition(0) at every CMD0*/
1356         mmc->part_num = 0;
1357
1358         /* Test for SD version 2 */
1359         err = mmc_send_if_cond(mmc);
1360
1361         /* Now try to get the SD card's operating condition */
1362         err = sd_send_op_cond(mmc);
1363
1364         /* If the command timed out, we check for an MMC card */
1365         if (err == TIMEOUT) {
1366                 err = mmc_send_op_cond(mmc);
1367
1368                 if (err && err != IN_PROGRESS) {
1369 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
1370                         printf("Card did not respond to voltage select!\n");
1371 #endif
1372                         return UNUSABLE_ERR;
1373                 }
1374         }
1375
1376         if (err == IN_PROGRESS)
1377                 mmc->init_in_progress = 1;
1378
1379         return err;
1380 }
1381
1382 static int mmc_complete_init(struct mmc *mmc)
1383 {
1384         int err = 0;
1385
1386         if (mmc->op_cond_pending)
1387                 err = mmc_complete_op_cond(mmc);
1388
1389         if (!err)
1390                 err = mmc_startup(mmc);
1391         if (err)
1392                 mmc->has_init = 0;
1393         else
1394                 mmc->has_init = 1;
1395         mmc->init_in_progress = 0;
1396         return err;
1397 }
1398
1399 int mmc_init(struct mmc *mmc)
1400 {
1401         int err = IN_PROGRESS;
1402         unsigned start;
1403
1404         if (mmc->has_init)
1405                 return 0;
1406
1407         start = get_timer(0);
1408
1409         if (!mmc->init_in_progress)
1410                 err = mmc_start_init(mmc);
1411
1412         if (!err || err == IN_PROGRESS)
1413                 err = mmc_complete_init(mmc);
1414         debug("%s: %d, time %lu\n", __func__, err, get_timer(start));
1415         return err;
1416 }
1417
1418 int mmc_set_dsr(struct mmc *mmc, u16 val)
1419 {
1420         mmc->dsr = val;
1421         return 0;
1422 }
1423
1424 /* CPU-specific MMC initializations */
1425 __weak int cpu_mmc_init(bd_t *bis)
1426 {
1427         return -1;
1428 }
1429
1430 /* board-specific MMC initializations. */
1431 __weak int board_mmc_init(bd_t *bis)
1432 {
1433         return -1;
1434 }
1435
1436 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
1437
1438 void print_mmc_devices(char separator)
1439 {
1440         struct mmc *m;
1441         struct list_head *entry;
1442
1443         list_for_each(entry, &mmc_devices) {
1444                 m = list_entry(entry, struct mmc, link);
1445
1446                 printf("%s: %d", m->cfg->name, m->block_dev.dev);
1447
1448                 if (entry->next != &mmc_devices) {
1449                         printf("%c", separator);
1450                         if (separator != '\n')
1451                                 puts (" ");
1452                 }
1453         }
1454
1455         printf("\n");
1456 }
1457
1458 #else
1459 void print_mmc_devices(char separator) { }
1460 #endif
1461
1462 int get_mmc_num(void)
1463 {
1464         return cur_dev_num;
1465 }
1466
1467 void mmc_set_preinit(struct mmc *mmc, int preinit)
1468 {
1469         mmc->preinit = preinit;
1470 }
1471
1472 static void do_preinit(void)
1473 {
1474         struct mmc *m;
1475         struct list_head *entry;
1476
1477         list_for_each(entry, &mmc_devices) {
1478                 m = list_entry(entry, struct mmc, link);
1479
1480                 if (m->preinit)
1481                         mmc_start_init(m);
1482         }
1483 }
1484
1485
1486 int mmc_initialize(bd_t *bis)
1487 {
1488         INIT_LIST_HEAD (&mmc_devices);
1489         cur_dev_num = 0;
1490
1491         if (board_mmc_init(bis) < 0)
1492                 cpu_mmc_init(bis);
1493
1494 #ifndef CONFIG_SPL_BUILD
1495         print_mmc_devices(',');
1496 #endif
1497
1498         do_preinit();
1499         return 0;
1500 }
1501
1502 #ifdef CONFIG_SUPPORT_EMMC_BOOT
1503 /*
1504  * This function changes the size of boot partition and the size of rpmb
1505  * partition present on EMMC devices.
1506  *
1507  * Input Parameters:
1508  * struct *mmc: pointer for the mmc device strcuture
1509  * bootsize: size of boot partition
1510  * rpmbsize: size of rpmb partition
1511  *
1512  * Returns 0 on success.
1513  */
1514
1515 int mmc_boot_partition_size_change(struct mmc *mmc, unsigned long bootsize,
1516                                 unsigned long rpmbsize)
1517 {
1518         int err;
1519         struct mmc_cmd cmd;
1520
1521         /* Only use this command for raw EMMC moviNAND. Enter backdoor mode */
1522         cmd.cmdidx = MMC_CMD_RES_MAN;
1523         cmd.resp_type = MMC_RSP_R1b;
1524         cmd.cmdarg = MMC_CMD62_ARG1;
1525
1526         err = mmc_send_cmd(mmc, &cmd, NULL);
1527         if (err) {
1528                 debug("mmc_boot_partition_size_change: Error1 = %d\n", err);
1529                 return err;
1530         }
1531
1532         /* Boot partition changing mode */
1533         cmd.cmdidx = MMC_CMD_RES_MAN;
1534         cmd.resp_type = MMC_RSP_R1b;
1535         cmd.cmdarg = MMC_CMD62_ARG2;
1536
1537         err = mmc_send_cmd(mmc, &cmd, NULL);
1538         if (err) {
1539                 debug("mmc_boot_partition_size_change: Error2 = %d\n", err);
1540                 return err;
1541         }
1542         /* boot partition size is multiple of 128KB */
1543         bootsize = (bootsize * 1024) / 128;
1544
1545         /* Arg: boot partition size */
1546         cmd.cmdidx = MMC_CMD_RES_MAN;
1547         cmd.resp_type = MMC_RSP_R1b;
1548         cmd.cmdarg = bootsize;
1549
1550         err = mmc_send_cmd(mmc, &cmd, NULL);
1551         if (err) {
1552                 debug("mmc_boot_partition_size_change: Error3 = %d\n", err);
1553                 return err;
1554         }
1555         /* RPMB partition size is multiple of 128KB */
1556         rpmbsize = (rpmbsize * 1024) / 128;
1557         /* Arg: RPMB partition size */
1558         cmd.cmdidx = MMC_CMD_RES_MAN;
1559         cmd.resp_type = MMC_RSP_R1b;
1560         cmd.cmdarg = rpmbsize;
1561
1562         err = mmc_send_cmd(mmc, &cmd, NULL);
1563         if (err) {
1564                 debug("mmc_boot_partition_size_change: Error4 = %d\n", err);
1565                 return err;
1566         }
1567         return 0;
1568 }
1569
1570 /*
1571  * Modify EXT_CSD[177] which is BOOT_BUS_WIDTH
1572  * based on the passed in values for BOOT_BUS_WIDTH, RESET_BOOT_BUS_WIDTH
1573  * and BOOT_MODE.
1574  *
1575  * Returns 0 on success.
1576  */
1577 int mmc_set_boot_bus_width(struct mmc *mmc, u8 width, u8 reset, u8 mode)
1578 {
1579         int err;
1580
1581         err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_BOOT_BUS_WIDTH,
1582                          EXT_CSD_BOOT_BUS_WIDTH_MODE(mode) |
1583                          EXT_CSD_BOOT_BUS_WIDTH_RESET(reset) |
1584                          EXT_CSD_BOOT_BUS_WIDTH_WIDTH(width));
1585
1586         if (err)
1587                 return err;
1588         return 0;
1589 }
1590
1591 /*
1592  * Modify EXT_CSD[179] which is PARTITION_CONFIG (formerly BOOT_CONFIG)
1593  * based on the passed in values for BOOT_ACK, BOOT_PARTITION_ENABLE and
1594  * PARTITION_ACCESS.
1595  *
1596  * Returns 0 on success.
1597  */
1598 int mmc_set_part_conf(struct mmc *mmc, u8 ack, u8 part_num, u8 access)
1599 {
1600         int err;
1601
1602         err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONF,
1603                          EXT_CSD_BOOT_ACK(ack) |
1604                          EXT_CSD_BOOT_PART_NUM(part_num) |
1605                          EXT_CSD_PARTITION_ACCESS(access));
1606
1607         if (err)
1608                 return err;
1609         return 0;
1610 }
1611
1612 /*
1613  * Modify EXT_CSD[162] which is RST_n_FUNCTION based on the given value
1614  * for enable.  Note that this is a write-once field for non-zero values.
1615  *
1616  * Returns 0 on success.
1617  */
1618 int mmc_set_rst_n_function(struct mmc *mmc, u8 enable)
1619 {
1620         return mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_RST_N_FUNCTION,
1621                           enable);
1622 }
1623 #endif