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