drivers/mmc/mmc.c

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