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                  * Check whether GROUP_DEF is set, if yes, read out
 964                  * group size from ext_csd directly, or calculate
 965                  * the group size from the csd value.
 966                  */
 967                 if (ext_csd[EXT_CSD_ERASE_GROUP_DEF]) {
 968                         mmc->erase_grp_size =
 969                                 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] *
 970                                         MMC_MAX_BLOCK_LEN * 1024;
 971                 } else {
 972                         int erase_gsz, erase_gmul;
 973                         erase_gsz = (mmc->csd[2] & 0x00007c00) >> 10;
 974                         erase_gmul = (mmc->csd[2] & 0x000003e0) >> 5;
 975                         mmc->erase_grp_size = (erase_gsz + 1)
 976                                 * (erase_gmul + 1);
 977                 }
 978
 979                 /* store the partition info of emmc */
 980                 if ((ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & PART_SUPPORT) ||
 981                     ext_csd[EXT_CSD_BOOT_MULT])
 982                         mmc->part_config = ext_csd[EXT_CSD_PART_CONF];
 983
 984                 mmc->capacity_boot = ext_csd[EXT_CSD_BOOT_MULT] << 17;
 985
 986                 mmc->capacity_rpmb = ext_csd[EXT_CSD_RPMB_MULT] << 17;
 987
 988                 for (i = 0; i < 4; i++) {
 989                         int idx = EXT_CSD_GP_SIZE_MULT + i * 3;
 990                         mmc->capacity_gp[i] = (ext_csd[idx + 2] << 16) +
 991                                 (ext_csd[idx + 1] << 8) + ext_csd[idx];
 992                         mmc->capacity_gp[i] *=
 993                                 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
 994                         mmc->capacity_gp[i] *= ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
 995                 }
 996         }
 997
 998         err = mmc_set_capacity(mmc, mmc->part_num);
 999         if (err)
1000                 return err;
1001
1002         if (IS_SD(mmc))
1003                 err = sd_change_freq(mmc);
1004         else
1005                 err = mmc_change_freq(mmc);
1006
1007         if (err)
1008                 return err;
1009
1010         /* Restrict card's capabilities by what the host can do */
1011         mmc->card_caps &= mmc->host_caps;
1012
1013         if (IS_SD(mmc)) {
1014                 if (mmc->card_caps & MMC_MODE_4BIT) {
1015                         cmd.cmdidx = MMC_CMD_APP_CMD;
1016                         cmd.resp_type = MMC_RSP_R1;
1017                         cmd.cmdarg = mmc->rca << 16;
1018
1019                         err = mmc_send_cmd(mmc, &cmd, NULL);
1020                         if (err)
1021                                 return err;
1022
1023                         cmd.cmdidx = SD_CMD_APP_SET_BUS_WIDTH;
1024                         cmd.resp_type = MMC_RSP_R1;
1025                         cmd.cmdarg = 2;
1026                         err = mmc_send_cmd(mmc, &cmd, NULL);
1027                         if (err)
1028                                 return err;
1029
1030                         mmc_set_bus_width(mmc, 4);
1031                 }
1032
1033                 if (mmc->card_caps & MMC_MODE_HS)
1034                         mmc->tran_speed = 50000000;
1035                 else
1036                         mmc->tran_speed = 25000000;
1037         } else {
1038                 int idx;
1039
1040                 /* An array of possible bus widths in order of preference */
1041                 static unsigned ext_csd_bits[] = {
1042                         EXT_CSD_BUS_WIDTH_8,
1043                         EXT_CSD_BUS_WIDTH_4,
1044                         EXT_CSD_BUS_WIDTH_1,
1045                 };
1046
1047                 /* An array to map CSD bus widths to host cap bits */
1048                 static unsigned ext_to_hostcaps[] = {
1049                         [EXT_CSD_BUS_WIDTH_4] = MMC_MODE_4BIT,
1050                         [EXT_CSD_BUS_WIDTH_8] = MMC_MODE_8BIT,
1051                 };
1052
1053                 /* An array to map chosen bus width to an integer */
1054                 static unsigned widths[] = {
1055                         8, 4, 1,
1056                 };
1057
1058                 for (idx=0; idx < ARRAY_SIZE(ext_csd_bits); idx++) {
1059                         unsigned int extw = ext_csd_bits[idx];
1060
1061                         /*
1062                          * Check to make sure the controller supports
1063                          * this bus width, if it's more than 1
1064                          */
1065                         if (extw != EXT_CSD_BUS_WIDTH_1 &&
1066                                         !(mmc->host_caps & ext_to_hostcaps[extw]))
1067                                 continue;
1068
1069                         err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1070                                         EXT_CSD_BUS_WIDTH, extw);
1071
1072                         if (err)
1073                                 continue;
1074
1075                         mmc_set_bus_width(mmc, widths[idx]);
1076
1077                         err = mmc_send_ext_csd(mmc, test_csd);
1078                         if (!err && ext_csd[EXT_CSD_PARTITIONING_SUPPORT] \
1079                                     == test_csd[EXT_CSD_PARTITIONING_SUPPORT]
1080                                  && ext_csd[EXT_CSD_ERASE_GROUP_DEF] \
1081                                     == test_csd[EXT_CSD_ERASE_GROUP_DEF] \
1082                                  && ext_csd[EXT_CSD_REV] \
1083                                     == test_csd[EXT_CSD_REV]
1084                                  && ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] \
1085                                     == test_csd[EXT_CSD_HC_ERASE_GRP_SIZE]
1086                                  && memcmp(&ext_csd[EXT_CSD_SEC_CNT], \
1087                                         &test_csd[EXT_CSD_SEC_CNT], 4) == 0) {
1088
1089                                 mmc->card_caps |= ext_to_hostcaps[extw];
1090                                 break;
1091                         }
1092                 }
1093
1094                 if (mmc->card_caps & MMC_MODE_HS) {
1095                         if (mmc->card_caps & MMC_MODE_HS_52MHz)
1096                                 mmc->tran_speed = 52000000;
1097                         else
1098                                 mmc->tran_speed = 26000000;
1099                 }
1100         }
1101
1102         mmc_set_clock(mmc, mmc->tran_speed);
1103
1104         /* fill in device description */
1105         mmc->block_dev.lun = 0;
1106         mmc->block_dev.type = 0;
1107         mmc->block_dev.blksz = mmc->read_bl_len;
1108         mmc->block_dev.log2blksz = LOG2(mmc->block_dev.blksz);
1109         mmc->block_dev.lba = lldiv(mmc->capacity, mmc->read_bl_len);
1110 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
1111         sprintf(mmc->block_dev.vendor, "Man %06x Snr %04x%04x",
1112                 mmc->cid[0] >> 24, (mmc->cid[2] & 0xffff),
1113                 (mmc->cid[3] >> 16) & 0xffff);
1114         sprintf(mmc->block_dev.product, "%c%c%c%c%c%c", mmc->cid[0] & 0xff,
1115                 (mmc->cid[1] >> 24), (mmc->cid[1] >> 16) & 0xff,
1116                 (mmc->cid[1] >> 8) & 0xff, mmc->cid[1] & 0xff,
1117                 (mmc->cid[2] >> 24) & 0xff);
1118         sprintf(mmc->block_dev.revision, "%d.%d", (mmc->cid[2] >> 20) & 0xf,
1119                 (mmc->cid[2] >> 16) & 0xf);
1120 #else
1121         mmc->block_dev.vendor[0] = 0;
1122         mmc->block_dev.product[0] = 0;
1123         mmc->block_dev.revision[0] = 0;
1124 #endif
1125 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBDISK_SUPPORT)
1126         init_part(&mmc->block_dev);
1127 #endif
1128
1129         return 0;
1130 }
1131
1132 static int mmc_send_if_cond(struct mmc *mmc)
1133 {
1134         struct mmc_cmd cmd;
1135         int err;
1136
1137         cmd.cmdidx = SD_CMD_SEND_IF_COND;
1138         /* We set the bit if the host supports voltages between 2.7 and 3.6 V */
1139         cmd.cmdarg = ((mmc->voltages & 0xff8000) != 0) << 8 | 0xaa;
1140         cmd.resp_type = MMC_RSP_R7;
1141
1142         err = mmc_send_cmd(mmc, &cmd, NULL);
1143
1144         if (err)
1145                 return err;
1146
1147         if ((cmd.response[0] & 0xff) != 0xaa)
1148                 return UNUSABLE_ERR;
1149         else
1150                 mmc->version = SD_VERSION_2;
1151
1152         return 0;
1153 }
1154
1155 int mmc_register(struct mmc *mmc)
1156 {
1157         /* Setup the universal parts of the block interface just once */
1158         mmc->block_dev.if_type = IF_TYPE_MMC;
1159         mmc->block_dev.dev = cur_dev_num++;
1160         mmc->block_dev.removable = 1;
1161         mmc->block_dev.block_read = mmc_bread;
1162         mmc->block_dev.block_write = mmc_bwrite;
1163         mmc->block_dev.block_erase = mmc_berase;
1164         if (!mmc->b_max)
1165                 mmc->b_max = CONFIG_SYS_MMC_MAX_BLK_COUNT;
1166
1167         INIT_LIST_HEAD (&mmc->link);
1168
1169         list_add_tail (&mmc->link, &mmc_devices);
1170
1171         return 0;
1172 }
1173
1174 #ifdef CONFIG_PARTITIONS
1175 block_dev_desc_t *mmc_get_dev(int dev)
1176 {
1177         struct mmc *mmc = find_mmc_device(dev);
1178         if (!mmc || mmc_init(mmc))
1179                 return NULL;
1180
1181         return &mmc->block_dev;
1182 }
1183 #endif
1184
1185 int mmc_start_init(struct mmc *mmc)
1186 {
1187         int err;
1188
1189         if (mmc_getcd(mmc) == 0) {
1190                 mmc->has_init = 0;
1191 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
1192                 printf("MMC: no card present\n");
1193 #endif
1194                 return NO_CARD_ERR;
1195         }
1196
1197         if (mmc->has_init)
1198                 return 0;
1199
1200         err = mmc->init(mmc);
1201
1202         if (err)
1203                 return err;
1204
1205         mmc_set_bus_width(mmc, 1);
1206         mmc_set_clock(mmc, 1);
1207
1208         /* Reset the Card */
1209         err = mmc_go_idle(mmc);
1210
1211         if (err)
1212                 return err;
1213
1214         /* The internal partition reset to user partition(0) at every CMD0*/
1215         mmc->part_num = 0;
1216
1217         /* Test for SD version 2 */
1218         err = mmc_send_if_cond(mmc);
1219
1220         /* Now try to get the SD card's operating condition */
1221         err = sd_send_op_cond(mmc);
1222
1223         /* If the command timed out, we check for an MMC card */
1224         if (err == TIMEOUT) {
1225                 err = mmc_send_op_cond(mmc);
1226
1227                 if (err && err != IN_PROGRESS) {
1228 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
1229                         printf("Card did not respond to voltage select!\n");
1230 #endif
1231                         return UNUSABLE_ERR;
1232                 }
1233         }
1234
1235         if (err == IN_PROGRESS)
1236                 mmc->init_in_progress = 1;
1237
1238         return err;
1239 }
1240
1241 static int mmc_complete_init(struct mmc *mmc)
1242 {
1243         int err = 0;
1244
1245         if (mmc->op_cond_pending)
1246                 err = mmc_complete_op_cond(mmc);
1247
1248         if (!err)
1249                 err = mmc_startup(mmc);
1250         if (err)
1251                 mmc->has_init = 0;
1252         else
1253                 mmc->has_init = 1;
1254         mmc->init_in_progress = 0;
1255         return err;
1256 }
1257
1258 int mmc_init(struct mmc *mmc)
1259 {
1260         int err = IN_PROGRESS;
1261         unsigned start = get_timer(0);
1262
1263         if (mmc->has_init)
1264                 return 0;
1265         if (!mmc->init_in_progress)
1266                 err = mmc_start_init(mmc);
1267
1268         if (!err || err == IN_PROGRESS)
1269                 err = mmc_complete_init(mmc);
1270         debug("%s: %d, time %lu\n", __func__, err, get_timer(start));
1271         return err;
1272 }
1273
1274 /*
1275  * CPU and board-specific MMC initializations.  Aliased function
1276  * signals caller to move on
1277  */
1278 static int __def_mmc_init(bd_t *bis)
1279 {
1280         return -1;
1281 }
1282
1283 int cpu_mmc_init(bd_t *bis) __attribute__((weak, alias("__def_mmc_init")));
1284 int board_mmc_init(bd_t *bis) __attribute__((weak, alias("__def_mmc_init")));
1285
1286 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
1287
1288 void print_mmc_devices(char separator)
1289 {
1290         struct mmc *m;
1291         struct list_head *entry;
1292
1293         list_for_each(entry, &mmc_devices) {
1294                 m = list_entry(entry, struct mmc, link);
1295
1296                 printf("%s: %d", m->name, m->block_dev.dev);
1297
1298                 if (entry->next != &mmc_devices)
1299                         printf("%c ", separator);
1300         }
1301
1302         printf("\n");
1303 }
1304
1305 #else
1306 void print_mmc_devices(char separator) { }
1307 #endif
1308
1309 int get_mmc_num(void)
1310 {
1311         return cur_dev_num;
1312 }
1313
1314 void mmc_set_preinit(struct mmc *mmc, int preinit)
1315 {
1316         mmc->preinit = preinit;
1317 }
1318
1319 static void do_preinit(void)
1320 {
1321         struct mmc *m;
1322         struct list_head *entry;
1323
1324         list_for_each(entry, &mmc_devices) {
1325                 m = list_entry(entry, struct mmc, link);
1326
1327                 if (m->preinit)
1328                         mmc_start_init(m);
1329         }
1330 }
1331
1332
1333 int mmc_initialize(bd_t *bis)
1334 {
1335         INIT_LIST_HEAD (&mmc_devices);
1336         cur_dev_num = 0;
1337
1338         if (board_mmc_init(bis) < 0)
1339                 cpu_mmc_init(bis);
1340
1341 #ifndef CONFIG_SPL_BUILD
1342         print_mmc_devices(',');
1343 #endif
1344
1345         do_preinit();
1346         return 0;
1347 }
1348
1349 #ifdef CONFIG_SUPPORT_EMMC_BOOT
1350 /*
1351  * This function changes the size of boot partition and the size of rpmb
1352  * partition present on EMMC devices.
1353  *
1354  * Input Parameters:
1355  * struct *mmc: pointer for the mmc device strcuture
1356  * bootsize: size of boot partition
1357  * rpmbsize: size of rpmb partition
1358  *
1359  * Returns 0 on success.
1360  */
1361
1362 int mmc_boot_partition_size_change(struct mmc *mmc, unsigned long bootsize,
1363                                 unsigned long rpmbsize)
1364 {
1365         int err;
1366         struct mmc_cmd cmd;
1367
1368         /* Only use this command for raw EMMC moviNAND. Enter backdoor mode */
1369         cmd.cmdidx = MMC_CMD_RES_MAN;
1370         cmd.resp_type = MMC_RSP_R1b;
1371         cmd.cmdarg = MMC_CMD62_ARG1;
1372
1373         err = mmc_send_cmd(mmc, &cmd, NULL);
1374         if (err) {
1375                 debug("mmc_boot_partition_size_change: Error1 = %d\n", err);
1376                 return err;
1377         }
1378
1379         /* Boot partition changing mode */
1380         cmd.cmdidx = MMC_CMD_RES_MAN;
1381         cmd.resp_type = MMC_RSP_R1b;
1382         cmd.cmdarg = MMC_CMD62_ARG2;
1383
1384         err = mmc_send_cmd(mmc, &cmd, NULL);
1385         if (err) {
1386                 debug("mmc_boot_partition_size_change: Error2 = %d\n", err);
1387                 return err;
1388         }
1389         /* boot partition size is multiple of 128KB */
1390         bootsize = (bootsize * 1024) / 128;
1391
1392         /* Arg: boot partition size */
1393         cmd.cmdidx = MMC_CMD_RES_MAN;
1394         cmd.resp_type = MMC_RSP_R1b;
1395         cmd.cmdarg = bootsize;
1396
1397         err = mmc_send_cmd(mmc, &cmd, NULL);
1398         if (err) {
1399                 debug("mmc_boot_partition_size_change: Error3 = %d\n", err);
1400                 return err;
1401         }
1402         /* RPMB partition size is multiple of 128KB */
1403         rpmbsize = (rpmbsize * 1024) / 128;
1404         /* Arg: RPMB partition size */
1405         cmd.cmdidx = MMC_CMD_RES_MAN;
1406         cmd.resp_type = MMC_RSP_R1b;
1407         cmd.cmdarg = rpmbsize;
1408
1409         err = mmc_send_cmd(mmc, &cmd, NULL);
1410         if (err) {
1411                 debug("mmc_boot_partition_size_change: Error4 = %d\n", err);
1412                 return err;
1413         }
1414         return 0;
1415 }
1416
1417 /*
1418  * This function shall form and send the commands to open / close the
1419  * boot partition specified by user.
1420  *
1421  * Input Parameters:
1422  * ack: 0x0 - No boot acknowledge sent (default)
1423  *      0x1 - Boot acknowledge sent during boot operation
1424  * part_num: User selects boot data that will be sent to master
1425  *      0x0 - Device not boot enabled (default)
1426  *      0x1 - Boot partition 1 enabled for boot
1427  *      0x2 - Boot partition 2 enabled for boot
1428  * access: User selects partitions to access
1429  *      0x0 : No access to boot partition (default)
1430  *      0x1 : R/W boot partition 1
1431  *      0x2 : R/W boot partition 2
1432  *      0x3 : R/W Replay Protected Memory Block (RPMB)
1433  *
1434  * Returns 0 on success.
1435  */
1436 int mmc_boot_part_access(struct mmc *mmc, u8 ack, u8 part_num, u8 access)
1437 {
1438         int err;
1439         struct mmc_cmd cmd;
1440
1441         /* Boot ack enable, boot partition enable , boot partition access */
1442         cmd.cmdidx = MMC_CMD_SWITCH;
1443         cmd.resp_type = MMC_RSP_R1b;
1444
1445         cmd.cmdarg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) |
1446                         (EXT_CSD_PART_CONF << 16) |
1447                         ((EXT_CSD_BOOT_ACK(ack) |
1448                         EXT_CSD_BOOT_PART_NUM(part_num) |
1449                         EXT_CSD_PARTITION_ACCESS(access)) << 8);
1450
1451         err = mmc_send_cmd(mmc, &cmd, NULL);
1452         if (err) {
1453                 if (access) {
1454                         debug("mmc boot partition#%d open fail:Error1 = %d\n",
1455                               part_num, err);
1456                 } else {
1457                         debug("mmc boot partition#%d close fail:Error = %d\n",
1458                               part_num, err);
1459                 }
1460                 return err;
1461         }
1462
1463         if (access) {
1464                 /* 4bit transfer mode at booting time. */
1465                 cmd.cmdidx = MMC_CMD_SWITCH;
1466                 cmd.resp_type = MMC_RSP_R1b;
1467
1468                 cmd.cmdarg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) |
1469                                 (EXT_CSD_BOOT_BUS_WIDTH << 16) |
1470                                 ((1 << 0) << 8);
1471
1472                 err = mmc_send_cmd(mmc, &cmd, NULL);
1473                 if (err) {
1474                         debug("mmc boot partition#%d open fail:Error2 = %d\n",
1475                               part_num, err);
1476                         return err;
1477                 }
1478         }
1479         return 0;
1480 }
1481 #endif