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 = 1;
 434
 435         return 0;
 436 }
 437
 438
 439 static int mmc_send_ext_csd(struct mmc *mmc, u8 *ext_csd)
 440 {
 441         struct mmc_cmd cmd;
 442         struct mmc_data data;
 443         int err;
 444
 445         /* Get the Card Status Register */
 446         cmd.cmdidx = MMC_CMD_SEND_EXT_CSD;
 447         cmd.resp_type = MMC_RSP_R1;
 448         cmd.cmdarg = 0;
 449
 450         data.dest = (char *)ext_csd;
 451         data.blocks = 1;
 452         data.blocksize = MMC_MAX_BLOCK_LEN;
 453         data.flags = MMC_DATA_READ;
 454
 455         err = mmc_send_cmd(mmc, &cmd, &data);
 456
 457         return err;
 458 }
 459
 460
 461 static int mmc_switch(struct mmc *mmc, u8 set, u8 index, u8 value)
 462 {
 463         struct mmc_cmd cmd;
 464         int timeout = 1000;
 465         int ret;
 466
 467         cmd.cmdidx = MMC_CMD_SWITCH;
 468         cmd.resp_type = MMC_RSP_R1b;
 469         cmd.cmdarg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) |
 470                                  (index << 16) |
 471                                  (value << 8);
 472
 473         ret = mmc_send_cmd(mmc, &cmd, NULL);
 474
 475         /* Waiting for the ready status */
 476         if (!ret)
 477                 ret = mmc_send_status(mmc, timeout);
 478
 479         return ret;
 480
 481 }
 482
 483 static int mmc_change_freq(struct mmc *mmc)
 484 {
 485         ALLOC_CACHE_ALIGN_BUFFER(u8, ext_csd, MMC_MAX_BLOCK_LEN);
 486         char cardtype;
 487         int err;
 488
 489         mmc->card_caps = 0;
 490
 491         if (mmc_host_is_spi(mmc))
 492                 return 0;
 493
 494         /* Only version 4 supports high-speed */
 495         if (mmc->version < MMC_VERSION_4)
 496                 return 0;
 497
 498         err = mmc_send_ext_csd(mmc, ext_csd);
 499
 500         if (err)
 501                 return err;
 502
 503         cardtype = ext_csd[EXT_CSD_CARD_TYPE] & 0xf;
 504
 505         err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING, 1);
 506
 507         if (err)
 508                 return err;
 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->dsr_imp = ((cmd.response[1] >> 12) & 0x1);
 881         mmc->read_bl_len = 1 << ((cmd.response[1] >> 16) & 0xf);
 882
 883         if (IS_SD(mmc))
 884                 mmc->write_bl_len = mmc->read_bl_len;
 885         else
 886                 mmc->write_bl_len = 1 << ((cmd.response[3] >> 22) & 0xf);
 887
 888         if (mmc->high_capacity) {
 889                 csize = (mmc->csd[1] & 0x3f) << 16
 890                         | (mmc->csd[2] & 0xffff0000) >> 16;
 891                 cmult = 8;
 892         } else {
 893                 csize = (mmc->csd[1] & 0x3ff) << 2
 894                         | (mmc->csd[2] & 0xc0000000) >> 30;
 895                 cmult = (mmc->csd[2] & 0x00038000) >> 15;
 896         }
 897
 898         mmc->capacity_user = (csize + 1) << (cmult + 2);
 899         mmc->capacity_user *= mmc->read_bl_len;
 900         mmc->capacity_boot = 0;
 901         mmc->capacity_rpmb = 0;
 902         for (i = 0; i < 4; i++)
 903                 mmc->capacity_gp[i] = 0;
 904
 905         if (mmc->read_bl_len > MMC_MAX_BLOCK_LEN)
 906                 mmc->read_bl_len = MMC_MAX_BLOCK_LEN;
 907
 908         if (mmc->write_bl_len > MMC_MAX_BLOCK_LEN)
 909                 mmc->write_bl_len = MMC_MAX_BLOCK_LEN;
 910
 911         if ((mmc->dsr_imp) && (0xffffffff != mmc->dsr)) {
 912                 cmd.cmdidx = MMC_CMD_SET_DSR;
 913                 cmd.cmdarg = (mmc->dsr & 0xffff) << 16;
 914                 cmd.resp_type = MMC_RSP_NONE;
 915                 if (mmc_send_cmd(mmc, &cmd, NULL))
 916                         printf("MMC: SET_DSR failed\n");
 917         }
 918
 919         /* Select the card, and put it into Transfer Mode */
 920         if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */
 921                 cmd.cmdidx = MMC_CMD_SELECT_CARD;
 922                 cmd.resp_type = MMC_RSP_R1;
 923                 cmd.cmdarg = mmc->rca << 16;
 924                 err = mmc_send_cmd(mmc, &cmd, NULL);
 925
 926                 if (err)
 927                         return err;
 928         }
 929
 930         /*
 931          * For SD, its erase group is always one sector
 932          */
 933         mmc->erase_grp_size = 1;
 934         mmc->part_config = MMCPART_NOAVAILABLE;
 935         if (!IS_SD(mmc) && (mmc->version >= MMC_VERSION_4)) {
 936                 /* check  ext_csd version and capacity */
 937                 err = mmc_send_ext_csd(mmc, ext_csd);
 938                 if (!err && (ext_csd[EXT_CSD_REV] >= 2)) {
 939                         /*
 940                          * According to the JEDEC Standard, the value of
 941                          * ext_csd's capacity is valid if the value is more
 942                          * than 2GB
 943                          */
 944                         capacity = ext_csd[EXT_CSD_SEC_CNT] << 0
 945                                         | ext_csd[EXT_CSD_SEC_CNT + 1] << 8
 946                                         | ext_csd[EXT_CSD_SEC_CNT + 2] << 16
 947                                         | ext_csd[EXT_CSD_SEC_CNT + 3] << 24;
 948                         capacity *= MMC_MAX_BLOCK_LEN;
 949                         if ((capacity >> 20) > 2 * 1024)
 950                                 mmc->capacity_user = capacity;
 951                 }
 952
 953                 switch (ext_csd[EXT_CSD_REV]) {
 954                 case 1:
 955                         mmc->version = MMC_VERSION_4_1;
 956                         break;
 957                 case 2:
 958                         mmc->version = MMC_VERSION_4_2;
 959                         break;
 960                 case 3:
 961                         mmc->version = MMC_VERSION_4_3;
 962                         break;
 963                 case 5:
 964                         mmc->version = MMC_VERSION_4_41;
 965                         break;
 966                 case 6:
 967                         mmc->version = MMC_VERSION_4_5;
 968                         break;
 969                 }
 970
 971                 /*
 972                  * Host needs to enable ERASE_GRP_DEF bit if device is
 973                  * partitioned. This bit will be lost every time after a reset
 974                  * or power off. This will affect erase size.
 975                  */
 976                 if ((ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & PART_SUPPORT) &&
 977                     (ext_csd[EXT_CSD_PARTITIONS_ATTRIBUTE] & PART_ENH_ATTRIB)) {
 978                         err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
 979                                 EXT_CSD_ERASE_GROUP_DEF, 1);
 980
 981                         if (err)
 982                                 return err;
 983
 984                         /* Read out group size from ext_csd */
 985                         mmc->erase_grp_size =
 986                                 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] *
 987                                         MMC_MAX_BLOCK_LEN * 1024;
 988                 } else {
 989                         /* Calculate the group size from the csd value. */
 990                         int erase_gsz, erase_gmul;
 991                         erase_gsz = (mmc->csd[2] & 0x00007c00) >> 10;
 992                         erase_gmul = (mmc->csd[2] & 0x000003e0) >> 5;
 993                         mmc->erase_grp_size = (erase_gsz + 1)
 994                                 * (erase_gmul + 1);
 995                 }
 996
 997                 /* store the partition info of emmc */
 998                 if ((ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & PART_SUPPORT) ||
 999                     ext_csd[EXT_CSD_BOOT_MULT])
1000                         mmc->part_config = ext_csd[EXT_CSD_PART_CONF];
1001
1002                 mmc->capacity_boot = ext_csd[EXT_CSD_BOOT_MULT] << 17;
1003
1004                 mmc->capacity_rpmb = ext_csd[EXT_CSD_RPMB_MULT] << 17;
1005
1006                 for (i = 0; i < 4; i++) {
1007                         int idx = EXT_CSD_GP_SIZE_MULT + i * 3;
1008                         mmc->capacity_gp[i] = (ext_csd[idx + 2] << 16) +
1009                                 (ext_csd[idx + 1] << 8) + ext_csd[idx];
1010                         mmc->capacity_gp[i] *=
1011                                 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
1012                         mmc->capacity_gp[i] *= ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
1013                 }
1014         }
1015
1016         err = mmc_set_capacity(mmc, mmc->part_num);
1017         if (err)
1018                 return err;
1019
1020         if (IS_SD(mmc))
1021                 err = sd_change_freq(mmc);
1022         else
1023                 err = mmc_change_freq(mmc);
1024
1025         if (err)
1026                 return err;
1027
1028         /* Restrict card's capabilities by what the host can do */
1029         mmc->card_caps &= mmc->host_caps;
1030
1031         if (IS_SD(mmc)) {
1032                 if (mmc->card_caps & MMC_MODE_4BIT) {
1033                         cmd.cmdidx = MMC_CMD_APP_CMD;
1034                         cmd.resp_type = MMC_RSP_R1;
1035                         cmd.cmdarg = mmc->rca << 16;
1036
1037                         err = mmc_send_cmd(mmc, &cmd, NULL);
1038                         if (err)
1039                                 return err;
1040
1041                         cmd.cmdidx = SD_CMD_APP_SET_BUS_WIDTH;
1042                         cmd.resp_type = MMC_RSP_R1;
1043                         cmd.cmdarg = 2;
1044                         err = mmc_send_cmd(mmc, &cmd, NULL);
1045                         if (err)
1046                                 return err;
1047
1048                         mmc_set_bus_width(mmc, 4);
1049                 }
1050
1051                 if (mmc->card_caps & MMC_MODE_HS)
1052                         mmc->tran_speed = 50000000;
1053                 else
1054                         mmc->tran_speed = 25000000;
1055         } else {
1056                 int idx;
1057
1058                 /* An array of possible bus widths in order of preference */
1059                 static unsigned ext_csd_bits[] = {
1060                         EXT_CSD_BUS_WIDTH_8,
1061                         EXT_CSD_BUS_WIDTH_4,
1062                         EXT_CSD_BUS_WIDTH_1,
1063                 };
1064
1065                 /* An array to map CSD bus widths to host cap bits */
1066                 static unsigned ext_to_hostcaps[] = {
1067                         [EXT_CSD_BUS_WIDTH_4] = MMC_MODE_4BIT,
1068                         [EXT_CSD_BUS_WIDTH_8] = MMC_MODE_8BIT,
1069                 };
1070
1071                 /* An array to map chosen bus width to an integer */
1072                 static unsigned widths[] = {
1073                         8, 4, 1,
1074                 };
1075
1076                 for (idx=0; idx < ARRAY_SIZE(ext_csd_bits); idx++) {
1077                         unsigned int extw = ext_csd_bits[idx];
1078
1079                         /*
1080                          * Check to make sure the controller supports
1081                          * this bus width, if it's more than 1
1082                          */
1083                         if (extw != EXT_CSD_BUS_WIDTH_1 &&
1084                                         !(mmc->host_caps & ext_to_hostcaps[extw]))
1085                                 continue;
1086
1087                         err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1088                                         EXT_CSD_BUS_WIDTH, extw);
1089
1090                         if (err)
1091                                 continue;
1092
1093                         mmc_set_bus_width(mmc, widths[idx]);
1094
1095                         err = mmc_send_ext_csd(mmc, test_csd);
1096                         if (!err && ext_csd[EXT_CSD_PARTITIONING_SUPPORT] \
1097                                     == test_csd[EXT_CSD_PARTITIONING_SUPPORT]
1098                                  && ext_csd[EXT_CSD_ERASE_GROUP_DEF] \
1099                                     == test_csd[EXT_CSD_ERASE_GROUP_DEF] \
1100                                  && ext_csd[EXT_CSD_REV] \
1101                                     == test_csd[EXT_CSD_REV]
1102                                  && ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] \
1103                                     == test_csd[EXT_CSD_HC_ERASE_GRP_SIZE]
1104                                  && memcmp(&ext_csd[EXT_CSD_SEC_CNT], \
1105                                         &test_csd[EXT_CSD_SEC_CNT], 4) == 0) {
1106
1107                                 mmc->card_caps |= ext_to_hostcaps[extw];
1108                                 break;
1109                         }
1110                 }
1111
1112                 if (mmc->card_caps & MMC_MODE_HS) {
1113                         if (mmc->card_caps & MMC_MODE_HS_52MHz)
1114                                 mmc->tran_speed = 52000000;
1115                         else
1116                                 mmc->tran_speed = 26000000;
1117                 }
1118         }
1119
1120         mmc_set_clock(mmc, mmc->tran_speed);
1121
1122         /* fill in device description */
1123         mmc->block_dev.lun = 0;
1124         mmc->block_dev.type = 0;
1125         mmc->block_dev.blksz = mmc->read_bl_len;
1126         mmc->block_dev.log2blksz = LOG2(mmc->block_dev.blksz);
1127         mmc->block_dev.lba = lldiv(mmc->capacity, mmc->read_bl_len);
1128 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
1129         sprintf(mmc->block_dev.vendor, "Man %06x Snr %04x%04x",
1130                 mmc->cid[0] >> 24, (mmc->cid[2] & 0xffff),
1131                 (mmc->cid[3] >> 16) & 0xffff);
1132         sprintf(mmc->block_dev.product, "%c%c%c%c%c%c", mmc->cid[0] & 0xff,
1133                 (mmc->cid[1] >> 24), (mmc->cid[1] >> 16) & 0xff,
1134                 (mmc->cid[1] >> 8) & 0xff, mmc->cid[1] & 0xff,
1135                 (mmc->cid[2] >> 24) & 0xff);
1136         sprintf(mmc->block_dev.revision, "%d.%d", (mmc->cid[2] >> 20) & 0xf,
1137                 (mmc->cid[2] >> 16) & 0xf);
1138 #else
1139         mmc->block_dev.vendor[0] = 0;
1140         mmc->block_dev.product[0] = 0;
1141         mmc->block_dev.revision[0] = 0;
1142 #endif
1143 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBDISK_SUPPORT)
1144         init_part(&mmc->block_dev);
1145 #endif
1146
1147         return 0;
1148 }
1149
1150 static int mmc_send_if_cond(struct mmc *mmc)
1151 {
1152         struct mmc_cmd cmd;
1153         int err;
1154
1155         cmd.cmdidx = SD_CMD_SEND_IF_COND;
1156         /* We set the bit if the host supports voltages between 2.7 and 3.6 V */
1157         cmd.cmdarg = ((mmc->voltages & 0xff8000) != 0) << 8 | 0xaa;
1158         cmd.resp_type = MMC_RSP_R7;
1159
1160         err = mmc_send_cmd(mmc, &cmd, NULL);
1161
1162         if (err)
1163                 return err;
1164
1165         if ((cmd.response[0] & 0xff) != 0xaa)
1166                 return UNUSABLE_ERR;
1167         else
1168                 mmc->version = SD_VERSION_2;
1169
1170         return 0;
1171 }
1172
1173 int mmc_register(struct mmc *mmc)
1174 {
1175         /* Setup dsr related values */
1176         mmc->dsr_imp = 0;
1177         mmc->dsr = 0xffffffff;
1178         /* Setup the universal parts of the block interface just once */
1179         mmc->block_dev.if_type = IF_TYPE_MMC;
1180         mmc->block_dev.dev = cur_dev_num++;
1181         mmc->block_dev.removable = 1;
1182         mmc->block_dev.block_read = mmc_bread;
1183         mmc->block_dev.block_write = mmc_bwrite;
1184         mmc->block_dev.block_erase = mmc_berase;
1185         if (!mmc->b_max)
1186                 mmc->b_max = CONFIG_SYS_MMC_MAX_BLK_COUNT;
1187
1188         INIT_LIST_HEAD (&mmc->link);
1189
1190         list_add_tail (&mmc->link, &mmc_devices);
1191
1192         return 0;
1193 }
1194
1195 #ifdef CONFIG_PARTITIONS
1196 block_dev_desc_t *mmc_get_dev(int dev)
1197 {
1198         struct mmc *mmc = find_mmc_device(dev);
1199         if (!mmc || mmc_init(mmc))
1200                 return NULL;
1201
1202         return &mmc->block_dev;
1203 }
1204 #endif
1205
1206 int mmc_start_init(struct mmc *mmc)
1207 {
1208         int err;
1209
1210         if (mmc_getcd(mmc) == 0) {
1211                 mmc->has_init = 0;
1212 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
1213                 printf("MMC: no card present\n");
1214 #endif
1215                 return NO_CARD_ERR;
1216         }
1217
1218         if (mmc->has_init)
1219                 return 0;
1220
1221         err = mmc->init(mmc);
1222
1223         if (err)
1224                 return err;
1225
1226         mmc_set_bus_width(mmc, 1);
1227         mmc_set_clock(mmc, 1);
1228
1229         /* Reset the Card */
1230         err = mmc_go_idle(mmc);
1231
1232         if (err)
1233                 return err;
1234
1235         /* The internal partition reset to user partition(0) at every CMD0*/
1236         mmc->part_num = 0;
1237
1238         /* Test for SD version 2 */
1239         err = mmc_send_if_cond(mmc);
1240
1241         /* Now try to get the SD card's operating condition */
1242         err = sd_send_op_cond(mmc);
1243
1244         /* If the command timed out, we check for an MMC card */
1245         if (err == TIMEOUT) {
1246                 err = mmc_send_op_cond(mmc);
1247
1248                 if (err && err != IN_PROGRESS) {
1249 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
1250                         printf("Card did not respond to voltage select!\n");
1251 #endif
1252                         return UNUSABLE_ERR;
1253                 }
1254         }
1255
1256         if (err == IN_PROGRESS)
1257                 mmc->init_in_progress = 1;
1258
1259         return err;
1260 }
1261
1262 static int mmc_complete_init(struct mmc *mmc)
1263 {
1264         int err = 0;
1265
1266         if (mmc->op_cond_pending)
1267                 err = mmc_complete_op_cond(mmc);
1268
1269         if (!err)
1270                 err = mmc_startup(mmc);
1271         if (err)
1272                 mmc->has_init = 0;
1273         else
1274                 mmc->has_init = 1;
1275         mmc->init_in_progress = 0;
1276         return err;
1277 }
1278
1279 int mmc_init(struct mmc *mmc)
1280 {
1281         int err = IN_PROGRESS;
1282         unsigned start = get_timer(0);
1283
1284         if (mmc->has_init)
1285                 return 0;
1286         if (!mmc->init_in_progress)
1287                 err = mmc_start_init(mmc);
1288
1289         if (!err || err == IN_PROGRESS)
1290                 err = mmc_complete_init(mmc);
1291         debug("%s: %d, time %lu\n", __func__, err, get_timer(start));
1292         return err;
1293 }
1294
1295 int mmc_set_dsr(struct mmc *mmc, u16 val)
1296 {
1297         mmc->dsr = val;
1298         return 0;
1299 }
1300
1301 /*
1302  * CPU and board-specific MMC initializations.  Aliased function
1303  * signals caller to move on
1304  */
1305 static int __def_mmc_init(bd_t *bis)
1306 {
1307         return -1;
1308 }
1309
1310 int cpu_mmc_init(bd_t *bis) __attribute__((weak, alias("__def_mmc_init")));
1311 int board_mmc_init(bd_t *bis) __attribute__((weak, alias("__def_mmc_init")));
1312
1313 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
1314
1315 void print_mmc_devices(char separator)
1316 {
1317         struct mmc *m;
1318         struct list_head *entry;
1319
1320         list_for_each(entry, &mmc_devices) {
1321                 m = list_entry(entry, struct mmc, link);
1322
1323                 printf("%s: %d", m->name, m->block_dev.dev);
1324
1325                 if (entry->next != &mmc_devices)
1326                         printf("%c ", separator);
1327         }
1328
1329         printf("\n");
1330 }
1331
1332 #else
1333 void print_mmc_devices(char separator) { }
1334 #endif
1335
1336 int get_mmc_num(void)
1337 {
1338         return cur_dev_num;
1339 }
1340
1341 void mmc_set_preinit(struct mmc *mmc, int preinit)
1342 {
1343         mmc->preinit = preinit;
1344 }
1345
1346 static void do_preinit(void)
1347 {
1348         struct mmc *m;
1349         struct list_head *entry;
1350
1351         list_for_each(entry, &mmc_devices) {
1352                 m = list_entry(entry, struct mmc, link);
1353
1354                 if (m->preinit)
1355                         mmc_start_init(m);
1356         }
1357 }
1358
1359
1360 int mmc_initialize(bd_t *bis)
1361 {
1362         INIT_LIST_HEAD (&mmc_devices);
1363         cur_dev_num = 0;
1364
1365         if (board_mmc_init(bis) < 0)
1366                 cpu_mmc_init(bis);
1367
1368 #ifndef CONFIG_SPL_BUILD
1369         print_mmc_devices(',');
1370 #endif
1371
1372         do_preinit();
1373         return 0;
1374 }
1375
1376 #ifdef CONFIG_SUPPORT_EMMC_BOOT
1377 /*
1378  * This function changes the size of boot partition and the size of rpmb
1379  * partition present on EMMC devices.
1380  *
1381  * Input Parameters:
1382  * struct *mmc: pointer for the mmc device strcuture
1383  * bootsize: size of boot partition
1384  * rpmbsize: size of rpmb partition
1385  *
1386  * Returns 0 on success.
1387  */
1388
1389 int mmc_boot_partition_size_change(struct mmc *mmc, unsigned long bootsize,
1390                                 unsigned long rpmbsize)
1391 {
1392         int err;
1393         struct mmc_cmd cmd;
1394
1395         /* Only use this command for raw EMMC moviNAND. Enter backdoor mode */
1396         cmd.cmdidx = MMC_CMD_RES_MAN;
1397         cmd.resp_type = MMC_RSP_R1b;
1398         cmd.cmdarg = MMC_CMD62_ARG1;
1399
1400         err = mmc_send_cmd(mmc, &cmd, NULL);
1401         if (err) {
1402                 debug("mmc_boot_partition_size_change: Error1 = %d\n", err);
1403                 return err;
1404         }
1405
1406         /* Boot partition changing mode */
1407         cmd.cmdidx = MMC_CMD_RES_MAN;
1408         cmd.resp_type = MMC_RSP_R1b;
1409         cmd.cmdarg = MMC_CMD62_ARG2;
1410
1411         err = mmc_send_cmd(mmc, &cmd, NULL);
1412         if (err) {
1413                 debug("mmc_boot_partition_size_change: Error2 = %d\n", err);
1414                 return err;
1415         }
1416         /* boot partition size is multiple of 128KB */
1417         bootsize = (bootsize * 1024) / 128;
1418
1419         /* Arg: boot partition size */
1420         cmd.cmdidx = MMC_CMD_RES_MAN;
1421         cmd.resp_type = MMC_RSP_R1b;
1422         cmd.cmdarg = bootsize;
1423
1424         err = mmc_send_cmd(mmc, &cmd, NULL);
1425         if (err) {
1426                 debug("mmc_boot_partition_size_change: Error3 = %d\n", err);
1427                 return err;
1428         }
1429         /* RPMB partition size is multiple of 128KB */
1430         rpmbsize = (rpmbsize * 1024) / 128;
1431         /* Arg: RPMB partition size */
1432         cmd.cmdidx = MMC_CMD_RES_MAN;
1433         cmd.resp_type = MMC_RSP_R1b;
1434         cmd.cmdarg = rpmbsize;
1435
1436         err = mmc_send_cmd(mmc, &cmd, NULL);
1437         if (err) {
1438                 debug("mmc_boot_partition_size_change: Error4 = %d\n", err);
1439                 return err;
1440         }
1441         return 0;
1442 }
1443
1444 /*
1445  * This function shall form and send the commands to open / close the
1446  * boot partition specified by user.
1447  *
1448  * Input Parameters:
1449  * ack: 0x0 - No boot acknowledge sent (default)
1450  *      0x1 - Boot acknowledge sent during boot operation
1451  * part_num: User selects boot data that will be sent to master
1452  *      0x0 - Device not boot enabled (default)
1453  *      0x1 - Boot partition 1 enabled for boot
1454  *      0x2 - Boot partition 2 enabled for boot
1455  * access: User selects partitions to access
1456  *      0x0 : No access to boot partition (default)
1457  *      0x1 : R/W boot partition 1
1458  *      0x2 : R/W boot partition 2
1459  *      0x3 : R/W Replay Protected Memory Block (RPMB)
1460  *
1461  * Returns 0 on success.
1462  */
1463 int mmc_boot_part_access(struct mmc *mmc, u8 ack, u8 part_num, u8 access)
1464 {
1465         int err;
1466         struct mmc_cmd cmd;
1467
1468         /* Boot ack enable, boot partition enable , boot partition access */
1469         cmd.cmdidx = MMC_CMD_SWITCH;
1470         cmd.resp_type = MMC_RSP_R1b;
1471
1472         cmd.cmdarg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) |
1473                         (EXT_CSD_PART_CONF << 16) |
1474                         ((EXT_CSD_BOOT_ACK(ack) |
1475                         EXT_CSD_BOOT_PART_NUM(part_num) |
1476                         EXT_CSD_PARTITION_ACCESS(access)) << 8);
1477
1478         err = mmc_send_cmd(mmc, &cmd, NULL);
1479         if (err) {
1480                 if (access) {
1481                         debug("mmc boot partition#%d open fail:Error1 = %d\n",
1482                               part_num, err);
1483                 } else {
1484                         debug("mmc boot partition#%d close fail:Error = %d\n",
1485                               part_num, err);
1486                 }
1487                 return err;
1488         }
1489
1490         if (access) {
1491                 /* 4bit transfer mode at booting time. */
1492                 cmd.cmdidx = MMC_CMD_SWITCH;
1493                 cmd.resp_type = MMC_RSP_R1b;
1494
1495                 cmd.cmdarg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) |
1496                                 (EXT_CSD_BOOT_BUS_WIDTH << 16) |
1497                                 ((1 << 0) << 8);
1498
1499                 err = mmc_send_cmd(mmc, &cmd, NULL);
1500                 if (err) {
1501                         debug("mmc boot partition#%d open fail:Error2 = %d\n",
1502                               part_num, err);
1503                         return err;
1504                 }
1505         }
1506         return 0;
1507 }
1508
1509 /*
1510  * Modify EXT_CSD[179] which is PARTITION_CONFIG (formerly BOOT_CONFIG)
1511  * based on the passed in values for BOOT_ACK, BOOT_PARTITION_ENABLE and
1512  * PARTITION_ACCESS.
1513  *
1514  * Returns 0 on success.
1515  */
1516 int mmc_set_part_conf(struct mmc *mmc, u8 ack, u8 part_num, u8 access)
1517 {
1518         int err;
1519
1520         err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONF,
1521                          EXT_CSD_BOOT_ACK(ack) |
1522                          EXT_CSD_BOOT_PART_NUM(part_num) |
1523                          EXT_CSD_PARTITION_ACCESS(access));
1524
1525         if (err)
1526                 return err;
1527         return 0;
1528 }
1529 #endif