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