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