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