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 __board_mmc_getcd(u8 *cd, struct mmc *mmc) {
  44         return -1;
  45 }
  46
  47 int board_mmc_getcd(u8 *cd, struct mmc *mmc)__attribute__((weak,
  48         alias("__board_mmc_getcd")));
  49
  50 int mmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data)
  51 {
  52 #ifdef CONFIG_MMC_TRACE
  53         int ret;
  54         int i;
  55         u8 *ptr;
  56
  57         printf("CMD_SEND:%d\n", cmd->cmdidx);
  58         printf("\t\tARG\t\t\t 0x%08X\n", cmd->cmdarg);
  59         printf("\t\tFLAG\t\t\t %d\n", cmd->flags);
  60         ret = mmc->send_cmd(mmc, cmd, data);
  61         switch (cmd->resp_type) {
  62                 case MMC_RSP_NONE:
  63                         printf("\t\tMMC_RSP_NONE\n");
  64                         break;
  65                 case MMC_RSP_R1:
  66                         printf("\t\tMMC_RSP_R1,5,6,7 \t 0x%08X \n",
  67                                 cmd->response[0]);
  68                         break;
  69                 case MMC_RSP_R1b:
  70                         printf("\t\tMMC_RSP_R1b\t\t 0x%08X \n",
  71                                 cmd->response[0]);
  72                         break;
  73                 case MMC_RSP_R2:
  74                         printf("\t\tMMC_RSP_R2\t\t 0x%08X \n",
  75                                 cmd->response[0]);
  76                         printf("\t\t          \t\t 0x%08X \n",
  77                                 cmd->response[1]);
  78                         printf("\t\t          \t\t 0x%08X \n",
  79                                 cmd->response[2]);
  80                         printf("\t\t          \t\t 0x%08X \n",
  81                                 cmd->response[3]);
  82                         printf("\n");
  83                         printf("\t\t\t\t\tDUMPING DATA\n");
  84                         for (i = 0; i < 4; i++) {
  85                                 int j;
  86                                 printf("\t\t\t\t\t%03d - ", i*4);
  87                                 ptr = &cmd->response[i];
  88                                 ptr += 3;
  89                                 for (j = 0; j < 4; j++)
  90                                         printf("%02X ", *ptr--);
  91                                 printf("\n");
  92                         }
  93                         break;
  94                 case MMC_RSP_R3:
  95                         printf("\t\tMMC_RSP_R3,4\t\t 0x%08X \n",
  96                                 cmd->response[0]);
  97                         break;
  98                 default:
  99                         printf("\t\tERROR MMC rsp not supported\n");
 100                         break;
 101         }
 102         return ret;
 103 #else
 104         return mmc->send_cmd(mmc, cmd, data);
 105 #endif
 106 }
 107
 108 int mmc_send_status(struct mmc *mmc, int timeout)
 109 {
 110         struct mmc_cmd cmd;
 111         int err;
 112 #ifdef CONFIG_MMC_TRACE
 113         int status;
 114 #endif
 115
 116         cmd.cmdidx = MMC_CMD_SEND_STATUS;
 117         cmd.resp_type = MMC_RSP_R1;
 118         if (!mmc_host_is_spi(mmc))
 119                 cmd.cmdarg = mmc->rca << 16;
 120         cmd.flags = 0;
 121
 122         do {
 123                 err = mmc_send_cmd(mmc, &cmd, NULL);
 124                 if (err)
 125                         return err;
 126                 else if (cmd.response[0] & MMC_STATUS_RDY_FOR_DATA)
 127                         break;
 128
 129                 udelay(1000);
 130
 131                 if (cmd.response[0] & MMC_STATUS_MASK) {
 132                         printf("Status Error: 0x%08X\n", cmd.response[0]);
 133                         return COMM_ERR;
 134                 }
 135         } while (timeout--);
 136
 137 #ifdef CONFIG_MMC_TRACE
 138         status = (cmd.response[0] & MMC_STATUS_CURR_STATE) >> 9;
 139         printf("CURR STATE:%d\n", status);
 140 #endif
 141         if (!timeout) {
 142                 printf("Timeout waiting card ready\n");
 143                 return TIMEOUT;
 144         }
 145
 146         return 0;
 147 }
 148
 149 int mmc_set_blocklen(struct mmc *mmc, int len)
 150 {
 151         struct mmc_cmd cmd;
 152
 153         cmd.cmdidx = MMC_CMD_SET_BLOCKLEN;
 154         cmd.resp_type = MMC_RSP_R1;
 155         cmd.cmdarg = len;
 156         cmd.flags = 0;
 157
 158         return mmc_send_cmd(mmc, &cmd, NULL);
 159 }
 160
 161 struct mmc *find_mmc_device(int dev_num)
 162 {
 163         struct mmc *m;
 164         struct list_head *entry;
 165
 166         list_for_each(entry, &mmc_devices) {
 167                 m = list_entry(entry, struct mmc, link);
 168
 169                 if (m->block_dev.dev == dev_num)
 170                         return m;
 171         }
 172
 173         printf("MMC Device %d not found\n", dev_num);
 174
 175         return NULL;
 176 }
 177
 178 static ulong mmc_erase_t(struct mmc *mmc, ulong start, lbaint_t blkcnt)
 179 {
 180         struct mmc_cmd cmd;
 181         ulong end;
 182         int err, start_cmd, end_cmd;
 183
 184         if (mmc->high_capacity)
 185                 end = start + blkcnt - 1;
 186         else {
 187                 end = (start + blkcnt - 1) * mmc->write_bl_len;
 188                 start *= mmc->write_bl_len;
 189         }
 190
 191         if (IS_SD(mmc)) {
 192                 start_cmd = SD_CMD_ERASE_WR_BLK_START;
 193                 end_cmd = SD_CMD_ERASE_WR_BLK_END;
 194         } else {
 195                 start_cmd = MMC_CMD_ERASE_GROUP_START;
 196                 end_cmd = MMC_CMD_ERASE_GROUP_END;
 197         }
 198
 199         cmd.cmdidx = start_cmd;
 200         cmd.cmdarg = start;
 201         cmd.resp_type = MMC_RSP_R1;
 202         cmd.flags = 0;
 203
 204         err = mmc_send_cmd(mmc, &cmd, NULL);
 205         if (err)
 206                 goto err_out;
 207
 208         cmd.cmdidx = end_cmd;
 209         cmd.cmdarg = end;
 210
 211         err = mmc_send_cmd(mmc, &cmd, NULL);
 212         if (err)
 213                 goto err_out;
 214
 215         cmd.cmdidx = MMC_CMD_ERASE;
 216         cmd.cmdarg = SECURE_ERASE;
 217         cmd.resp_type = MMC_RSP_R1b;
 218
 219         err = mmc_send_cmd(mmc, &cmd, NULL);
 220         if (err)
 221                 goto err_out;
 222
 223         return 0;
 224
 225 err_out:
 226         puts("mmc erase failed\n");
 227         return err;
 228 }
 229
 230 static unsigned long
 231 mmc_berase(int dev_num, unsigned long start, lbaint_t blkcnt)
 232 {
 233         int err = 0;
 234         struct mmc *mmc = find_mmc_device(dev_num);
 235         lbaint_t blk = 0, blk_r = 0;
 236
 237         if (!mmc)
 238                 return -1;
 239
 240         if ((start % mmc->erase_grp_size) || (blkcnt % mmc->erase_grp_size))
 241                 printf("\n\nCaution! Your devices Erase group is 0x%x\n"
 242                         "The erase range would be change to 0x%lx~0x%lx\n\n",
 243                        mmc->erase_grp_size, start & ~(mmc->erase_grp_size - 1),
 244                        ((start + blkcnt + mmc->erase_grp_size)
 245                        & ~(mmc->erase_grp_size - 1)) - 1);
 246
 247         while (blk < blkcnt) {
 248                 blk_r = ((blkcnt - blk) > mmc->erase_grp_size) ?
 249                         mmc->erase_grp_size : (blkcnt - blk);
 250                 err = mmc_erase_t(mmc, start + blk, blk_r);
 251                 if (err)
 252                         break;
 253
 254                 blk += blk_r;
 255         }
 256
 257         return blk;
 258 }
 259
 260 static ulong
 261 mmc_write_blocks(struct mmc *mmc, ulong start, lbaint_t blkcnt, const void*src)
 262 {
 263         struct mmc_cmd cmd;
 264         struct mmc_data data;
 265         int timeout = 1000;
 266
 267         if ((start + blkcnt) > mmc->block_dev.lba) {
 268                 printf("MMC: block number 0x%lx exceeds max(0x%lx)\n",
 269                         start + blkcnt, mmc->block_dev.lba);
 270                 return 0;
 271         }
 272
 273         if (blkcnt > 1)
 274                 cmd.cmdidx = MMC_CMD_WRITE_MULTIPLE_BLOCK;
 275         else
 276                 cmd.cmdidx = MMC_CMD_WRITE_SINGLE_BLOCK;
 277
 278         if (mmc->high_capacity)
 279                 cmd.cmdarg = start;
 280         else
 281                 cmd.cmdarg = start * mmc->write_bl_len;
 282
 283         cmd.resp_type = MMC_RSP_R1;
 284         cmd.flags = 0;
 285
 286         data.src = src;
 287         data.blocks = blkcnt;
 288         data.blocksize = mmc->write_bl_len;
 289         data.flags = MMC_DATA_WRITE;
 290
 291         if (mmc_send_cmd(mmc, &cmd, &data)) {
 292                 printf("mmc write failed\n");
 293                 return 0;
 294         }
 295
 296         /* SPI multiblock writes terminate using a special
 297          * token, not a STOP_TRANSMISSION request.
 298          */
 299         if (!mmc_host_is_spi(mmc) && blkcnt > 1) {
 300                 cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION;
 301                 cmd.cmdarg = 0;
 302                 cmd.resp_type = MMC_RSP_R1b;
 303                 cmd.flags = 0;
 304                 if (mmc_send_cmd(mmc, &cmd, NULL)) {
 305                         printf("mmc fail to send stop cmd\n");
 306                         return 0;
 307                 }
 308
 309                 /* Waiting for the ready status */
 310                 mmc_send_status(mmc, timeout);
 311         }
 312
 313         return blkcnt;
 314 }
 315
 316 static ulong
 317 mmc_bwrite(int dev_num, ulong start, lbaint_t blkcnt, const void*src)
 318 {
 319         lbaint_t cur, blocks_todo = blkcnt;
 320
 321         struct mmc *mmc = find_mmc_device(dev_num);
 322         if (!mmc)
 323                 return 0;
 324
 325         if (mmc_set_blocklen(mmc, mmc->write_bl_len))
 326                 return 0;
 327
 328         do {
 329                 cur = (blocks_todo > mmc->b_max) ?  mmc->b_max : blocks_todo;
 330                 if(mmc_write_blocks(mmc, start, cur, src) != cur)
 331                         return 0;
 332                 blocks_todo -= cur;
 333                 start += cur;
 334                 src += cur * mmc->write_bl_len;
 335         } while (blocks_todo > 0);
 336
 337         return blkcnt;
 338 }
 339
 340 int mmc_read_blocks(struct mmc *mmc, void *dst, ulong start, lbaint_t blkcnt)
 341 {
 342         struct mmc_cmd cmd;
 343         struct mmc_data data;
 344         int timeout = 1000;
 345
 346         if (blkcnt > 1)
 347                 cmd.cmdidx = MMC_CMD_READ_MULTIPLE_BLOCK;
 348         else
 349                 cmd.cmdidx = MMC_CMD_READ_SINGLE_BLOCK;
 350
 351         if (mmc->high_capacity)
 352                 cmd.cmdarg = start;
 353         else
 354                 cmd.cmdarg = start * mmc->read_bl_len;
 355
 356         cmd.resp_type = MMC_RSP_R1;
 357         cmd.flags = 0;
 358
 359         data.dest = dst;
 360         data.blocks = blkcnt;
 361         data.blocksize = mmc->read_bl_len;
 362         data.flags = MMC_DATA_READ;
 363
 364         if (mmc_send_cmd(mmc, &cmd, &data))
 365                 return 0;
 366
 367         if (blkcnt > 1) {
 368                 cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION;
 369                 cmd.cmdarg = 0;
 370                 cmd.resp_type = MMC_RSP_R1b;
 371                 cmd.flags = 0;
 372                 if (mmc_send_cmd(mmc, &cmd, NULL)) {
 373                         printf("mmc fail to send stop cmd\n");
 374                         return 0;
 375                 }
 376
 377                 /* Waiting for the ready status */
 378                 mmc_send_status(mmc, timeout);
 379         }
 380
 381         return blkcnt;
 382 }
 383
 384 static ulong mmc_bread(int dev_num, ulong start, lbaint_t blkcnt, void *dst)
 385 {
 386         lbaint_t cur, blocks_todo = blkcnt;
 387
 388         if (blkcnt == 0)
 389                 return 0;
 390
 391         struct mmc *mmc = find_mmc_device(dev_num);
 392         if (!mmc)
 393                 return 0;
 394
 395         if ((start + blkcnt) > mmc->block_dev.lba) {
 396                 printf("MMC: block number 0x%lx exceeds max(0x%lx)\n",
 397                         start + blkcnt, mmc->block_dev.lba);
 398                 return 0;
 399         }
 400
 401         if (mmc_set_blocklen(mmc, mmc->read_bl_len))
 402                 return 0;
 403
 404         do {
 405                 cur = (blocks_todo > mmc->b_max) ?  mmc->b_max : blocks_todo;
 406                 if(mmc_read_blocks(mmc, dst, start, cur) != cur)
 407                         return 0;
 408                 blocks_todo -= cur;
 409                 start += cur;
 410                 dst += cur * mmc->read_bl_len;
 411         } while (blocks_todo > 0);
 412
 413         return blkcnt;
 414 }
 415
 416 int mmc_go_idle(struct mmc* mmc)
 417 {
 418         struct mmc_cmd cmd;
 419         int err;
 420
 421         udelay(1000);
 422
 423         cmd.cmdidx = MMC_CMD_GO_IDLE_STATE;
 424         cmd.cmdarg = 0;
 425         cmd.resp_type = MMC_RSP_NONE;
 426         cmd.flags = 0;
 427
 428         err = mmc_send_cmd(mmc, &cmd, NULL);
 429
 430         if (err)
 431                 return err;
 432
 433         udelay(2000);
 434
 435         return 0;
 436 }
 437
 438 int
 439 sd_send_op_cond(struct mmc *mmc)
 440 {
 441         int timeout = 1000;
 442         int err;
 443         struct mmc_cmd cmd;
 444
 445         do {
 446                 cmd.cmdidx = MMC_CMD_APP_CMD;
 447                 cmd.resp_type = MMC_RSP_R1;
 448                 cmd.cmdarg = 0;
 449                 cmd.flags = 0;
 450
 451                 err = mmc_send_cmd(mmc, &cmd, NULL);
 452
 453                 if (err)
 454                         return err;
 455
 456                 cmd.cmdidx = SD_CMD_APP_SEND_OP_COND;
 457                 cmd.resp_type = MMC_RSP_R3;
 458
 459                 /*
 460                  * Most cards do not answer if some reserved bits
 461                  * in the ocr are set. However, Some controller
 462                  * can set bit 7 (reserved for low voltages), but
 463                  * how to manage low voltages SD card is not yet
 464                  * specified.
 465                  */
 466                 cmd.cmdarg = mmc_host_is_spi(mmc) ? 0 :
 467                         (mmc->voltages & 0xff8000);
 468
 469                 if (mmc->version == SD_VERSION_2)
 470                         cmd.cmdarg |= OCR_HCS;
 471
 472                 err = mmc_send_cmd(mmc, &cmd, NULL);
 473
 474                 if (err)
 475                         return err;
 476
 477                 udelay(1000);
 478         } while ((!(cmd.response[0] & OCR_BUSY)) && timeout--);
 479
 480         if (timeout <= 0)
 481                 return UNUSABLE_ERR;
 482
 483         if (mmc->version != SD_VERSION_2)
 484                 mmc->version = SD_VERSION_1_0;
 485
 486         if (mmc_host_is_spi(mmc)) { /* read OCR for spi */
 487                 cmd.cmdidx = MMC_CMD_SPI_READ_OCR;
 488                 cmd.resp_type = MMC_RSP_R3;
 489                 cmd.cmdarg = 0;
 490                 cmd.flags = 0;
 491
 492                 err = mmc_send_cmd(mmc, &cmd, NULL);
 493
 494                 if (err)
 495                         return err;
 496         }
 497
 498         mmc->ocr = cmd.response[0];
 499
 500         mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS);
 501         mmc->rca = 0;
 502
 503         return 0;
 504 }
 505
 506 int mmc_send_op_cond(struct mmc *mmc)
 507 {
 508         int timeout = 10000;
 509         struct mmc_cmd cmd;
 510         int err;
 511
 512         /* Some cards seem to need this */
 513         mmc_go_idle(mmc);
 514
 515         /* Asking to the card its capabilities */
 516         cmd.cmdidx = MMC_CMD_SEND_OP_COND;
 517         cmd.resp_type = MMC_RSP_R3;
 518         cmd.cmdarg = 0;
 519         cmd.flags = 0;
 520
 521         err = mmc_send_cmd(mmc, &cmd, NULL);
 522
 523         if (err)
 524                 return err;
 525
 526         udelay(1000);
 527
 528         do {
 529                 cmd.cmdidx = MMC_CMD_SEND_OP_COND;
 530                 cmd.resp_type = MMC_RSP_R3;
 531                 cmd.cmdarg = (mmc_host_is_spi(mmc) ? 0 :
 532                                 (mmc->voltages &
 533                                 (cmd.response[0] & OCR_VOLTAGE_MASK)) |
 534                                 (cmd.response[0] & OCR_ACCESS_MODE));
 535
 536                 if (mmc->host_caps & MMC_MODE_HC)
 537                         cmd.cmdarg |= OCR_HCS;
 538
 539                 cmd.flags = 0;
 540
 541                 err = mmc_send_cmd(mmc, &cmd, NULL);
 542
 543                 if (err)
 544                         return err;
 545
 546                 udelay(1000);
 547         } while (!(cmd.response[0] & OCR_BUSY) && timeout--);
 548
 549         if (timeout <= 0)
 550                 return UNUSABLE_ERR;
 551
 552         if (mmc_host_is_spi(mmc)) { /* read OCR for spi */
 553                 cmd.cmdidx = MMC_CMD_SPI_READ_OCR;
 554                 cmd.resp_type = MMC_RSP_R3;
 555                 cmd.cmdarg = 0;
 556                 cmd.flags = 0;
 557
 558                 err = mmc_send_cmd(mmc, &cmd, NULL);
 559
 560                 if (err)
 561                         return err;
 562         }
 563
 564         mmc->version = MMC_VERSION_UNKNOWN;
 565         mmc->ocr = cmd.response[0];
 566
 567         mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS);
 568         mmc->rca = 0;
 569
 570         return 0;
 571 }
 572
 573
 574 int mmc_send_ext_csd(struct mmc *mmc, char *ext_csd)
 575 {
 576         struct mmc_cmd cmd;
 577         struct mmc_data data;
 578         int err;
 579
 580         /* Get the Card Status Register */
 581         cmd.cmdidx = MMC_CMD_SEND_EXT_CSD;
 582         cmd.resp_type = MMC_RSP_R1;
 583         cmd.cmdarg = 0;
 584         cmd.flags = 0;
 585
 586         data.dest = ext_csd;
 587         data.blocks = 1;
 588         data.blocksize = 512;
 589         data.flags = MMC_DATA_READ;
 590
 591         err = mmc_send_cmd(mmc, &cmd, &data);
 592
 593         return err;
 594 }
 595
 596
 597 int mmc_switch(struct mmc *mmc, u8 set, u8 index, u8 value)
 598 {
 599         struct mmc_cmd cmd;
 600         int timeout = 1000;
 601         int ret;
 602
 603         cmd.cmdidx = MMC_CMD_SWITCH;
 604         cmd.resp_type = MMC_RSP_R1b;
 605         cmd.cmdarg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) |
 606                                  (index << 16) |
 607                                  (value << 8);
 608         cmd.flags = 0;
 609
 610         ret = mmc_send_cmd(mmc, &cmd, NULL);
 611
 612         /* Waiting for the ready status */
 613         mmc_send_status(mmc, timeout);
 614
 615         return ret;
 616
 617 }
 618
 619 int mmc_change_freq(struct mmc *mmc)
 620 {
 621         char ext_csd[512];
 622         char cardtype;
 623         int err;
 624
 625         mmc->card_caps = 0;
 626
 627         if (mmc_host_is_spi(mmc))
 628                 return 0;
 629
 630         /* Only version 4 supports high-speed */
 631         if (mmc->version < MMC_VERSION_4)
 632                 return 0;
 633
 634         mmc->card_caps |= MMC_MODE_4BIT;
 635
 636         err = mmc_send_ext_csd(mmc, ext_csd);
 637
 638         if (err)
 639                 return err;
 640
 641         cardtype = ext_csd[196] & 0xf;
 642
 643         err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING, 1);
 644
 645         if (err)
 646                 return err;
 647
 648         /* Now check to see that it worked */
 649         err = mmc_send_ext_csd(mmc, ext_csd);
 650
 651         if (err)
 652                 return err;
 653
 654         /* No high-speed support */
 655         if (!ext_csd[185])
 656                 return 0;
 657
 658         /* High Speed is set, there are two types: 52MHz and 26MHz */
 659         if (cardtype & MMC_HS_52MHZ)
 660                 mmc->card_caps |= MMC_MODE_HS_52MHz | MMC_MODE_HS;
 661         else
 662                 mmc->card_caps |= MMC_MODE_HS;
 663
 664         return 0;
 665 }
 666
 667 int mmc_switch_part(int dev_num, unsigned int part_num)
 668 {
 669         struct mmc *mmc = find_mmc_device(dev_num);
 670
 671         if (!mmc)
 672                 return -1;
 673
 674         return mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONF,
 675                           (mmc->part_config & ~PART_ACCESS_MASK)
 676                           | (part_num & PART_ACCESS_MASK));
 677 }
 678
 679 int sd_switch(struct mmc *mmc, int mode, int group, u8 value, u8 *resp)
 680 {
 681         struct mmc_cmd cmd;
 682         struct mmc_data data;
 683
 684         /* Switch the frequency */
 685         cmd.cmdidx = SD_CMD_SWITCH_FUNC;
 686         cmd.resp_type = MMC_RSP_R1;
 687         cmd.cmdarg = (mode << 31) | 0xffffff;
 688         cmd.cmdarg &= ~(0xf << (group * 4));
 689         cmd.cmdarg |= value << (group * 4);
 690         cmd.flags = 0;
 691
 692         data.dest = (char *)resp;
 693         data.blocksize = 64;
 694         data.blocks = 1;
 695         data.flags = MMC_DATA_READ;
 696
 697         return mmc_send_cmd(mmc, &cmd, &data);
 698 }
 699
 700
 701 int sd_change_freq(struct mmc *mmc)
 702 {
 703         int err;
 704         struct mmc_cmd cmd;
 705         ALLOC_CACHE_ALIGN_BUFFER(uint, scr, 2);
 706         ALLOC_CACHE_ALIGN_BUFFER(uint, switch_status, 16);
 707         struct mmc_data data;
 708         int timeout;
 709
 710         mmc->card_caps = 0;
 711
 712         if (mmc_host_is_spi(mmc))
 713                 return 0;
 714
 715         /* Read the SCR to find out if this card supports higher speeds */
 716         cmd.cmdidx = MMC_CMD_APP_CMD;
 717         cmd.resp_type = MMC_RSP_R1;
 718         cmd.cmdarg = mmc->rca << 16;
 719         cmd.flags = 0;
 720
 721         err = mmc_send_cmd(mmc, &cmd, NULL);
 722
 723         if (err)
 724                 return err;
 725
 726         cmd.cmdidx = SD_CMD_APP_SEND_SCR;
 727         cmd.resp_type = MMC_RSP_R1;
 728         cmd.cmdarg = 0;
 729         cmd.flags = 0;
 730
 731         timeout = 3;
 732
 733 retry_scr:
 734         data.dest = (char *)scr;
 735         data.blocksize = 8;
 736         data.blocks = 1;
 737         data.flags = MMC_DATA_READ;
 738
 739         err = mmc_send_cmd(mmc, &cmd, &data);
 740
 741         if (err) {
 742                 if (timeout--)
 743                         goto retry_scr;
 744
 745                 return err;
 746         }
 747
 748         mmc->scr[0] = __be32_to_cpu(scr[0]);
 749         mmc->scr[1] = __be32_to_cpu(scr[1]);
 750
 751         switch ((mmc->scr[0] >> 24) & 0xf) {
 752                 case 0:
 753                         mmc->version = SD_VERSION_1_0;
 754                         break;
 755                 case 1:
 756                         mmc->version = SD_VERSION_1_10;
 757                         break;
 758                 case 2:
 759                         mmc->version = SD_VERSION_2;
 760                         break;
 761                 default:
 762                         mmc->version = SD_VERSION_1_0;
 763                         break;
 764         }
 765
 766         if (mmc->scr[0] & SD_DATA_4BIT)
 767                 mmc->card_caps |= MMC_MODE_4BIT;
 768
 769         /* Version 1.0 doesn't support switching */
 770         if (mmc->version == SD_VERSION_1_0)
 771                 return 0;
 772
 773         timeout = 4;
 774         while (timeout--) {
 775                 err = sd_switch(mmc, SD_SWITCH_CHECK, 0, 1,
 776                                 (u8 *)switch_status);
 777
 778                 if (err)
 779                         return err;
 780
 781                 /* The high-speed function is busy.  Try again */
 782                 if (!(__be32_to_cpu(switch_status[7]) & SD_HIGHSPEED_BUSY))
 783                         break;
 784         }
 785
 786         /* If high-speed isn't supported, we return */
 787         if (!(__be32_to_cpu(switch_status[3]) & SD_HIGHSPEED_SUPPORTED))
 788                 return 0;
 789
 790         err = sd_switch(mmc, SD_SWITCH_SWITCH, 0, 1, (u8 *)switch_status);
 791
 792         if (err)
 793                 return err;
 794
 795         if ((__be32_to_cpu(switch_status[4]) & 0x0f000000) == 0x01000000)
 796                 mmc->card_caps |= MMC_MODE_HS;
 797
 798         return 0;
 799 }
 800
 801 /* frequency bases */
 802 /* divided by 10 to be nice to platforms without floating point */
 803 static const int fbase[] = {
 804         10000,
 805         100000,
 806         1000000,
 807         10000000,
 808 };
 809
 810 /* Multiplier values for TRAN_SPEED.  Multiplied by 10 to be nice
 811  * to platforms without floating point.
 812  */
 813 static const int multipliers[] = {
 814         0,      /* reserved */
 815         10,
 816         12,
 817         13,
 818         15,
 819         20,
 820         25,
 821         30,
 822         35,
 823         40,
 824         45,
 825         50,
 826         55,
 827         60,
 828         70,
 829         80,
 830 };
 831
 832 void mmc_set_ios(struct mmc *mmc)
 833 {
 834         mmc->set_ios(mmc);
 835 }
 836
 837 void mmc_set_clock(struct mmc *mmc, uint clock)
 838 {
 839         if (clock > mmc->f_max)
 840                 clock = mmc->f_max;
 841
 842         if (clock < mmc->f_min)
 843                 clock = mmc->f_min;
 844
 845         mmc->clock = clock;
 846
 847         mmc_set_ios(mmc);
 848 }
 849
 850 void mmc_set_bus_width(struct mmc *mmc, uint width)
 851 {
 852         mmc->bus_width = width;
 853
 854         mmc_set_ios(mmc);
 855 }
 856
 857 int mmc_startup(struct mmc *mmc)
 858 {
 859         int err;
 860         uint mult, freq;
 861         u64 cmult, csize, capacity;
 862         struct mmc_cmd cmd;
 863         char ext_csd[512];
 864         int timeout = 1000;
 865
 866 #ifdef CONFIG_MMC_SPI_CRC_ON
 867         if (mmc_host_is_spi(mmc)) { /* enable CRC check for spi */
 868                 cmd.cmdidx = MMC_CMD_SPI_CRC_ON_OFF;
 869                 cmd.resp_type = MMC_RSP_R1;
 870                 cmd.cmdarg = 1;
 871                 cmd.flags = 0;
 872                 err = mmc_send_cmd(mmc, &cmd, NULL);
 873
 874                 if (err)
 875                         return err;
 876         }
 877 #endif
 878
 879         /* Put the Card in Identify Mode */
 880         cmd.cmdidx = mmc_host_is_spi(mmc) ? MMC_CMD_SEND_CID :
 881                 MMC_CMD_ALL_SEND_CID; /* cmd not supported in spi */
 882         cmd.resp_type = MMC_RSP_R2;
 883         cmd.cmdarg = 0;
 884         cmd.flags = 0;
 885
 886         err = mmc_send_cmd(mmc, &cmd, NULL);
 887
 888         if (err)
 889                 return err;
 890
 891         memcpy(mmc->cid, cmd.response, 16);
 892
 893         /*
 894          * For MMC cards, set the Relative Address.
 895          * For SD cards, get the Relatvie Address.
 896          * This also puts the cards into Standby State
 897          */
 898         if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */
 899                 cmd.cmdidx = SD_CMD_SEND_RELATIVE_ADDR;
 900                 cmd.cmdarg = mmc->rca << 16;
 901                 cmd.resp_type = MMC_RSP_R6;
 902                 cmd.flags = 0;
 903
 904                 err = mmc_send_cmd(mmc, &cmd, NULL);
 905
 906                 if (err)
 907                         return err;
 908
 909                 if (IS_SD(mmc))
 910                         mmc->rca = (cmd.response[0] >> 16) & 0xffff;
 911         }
 912
 913         /* Get the Card-Specific Data */
 914         cmd.cmdidx = MMC_CMD_SEND_CSD;
 915         cmd.resp_type = MMC_RSP_R2;
 916         cmd.cmdarg = mmc->rca << 16;
 917         cmd.flags = 0;
 918
 919         err = mmc_send_cmd(mmc, &cmd, NULL);
 920
 921         /* Waiting for the ready status */
 922         mmc_send_status(mmc, timeout);
 923
 924         if (err)
 925                 return err;
 926
 927         mmc->csd[0] = cmd.response[0];
 928         mmc->csd[1] = cmd.response[1];
 929         mmc->csd[2] = cmd.response[2];
 930         mmc->csd[3] = cmd.response[3];
 931
 932         if (mmc->version == MMC_VERSION_UNKNOWN) {
 933                 int version = (cmd.response[0] >> 26) & 0xf;
 934
 935                 switch (version) {
 936                         case 0:
 937                                 mmc->version = MMC_VERSION_1_2;
 938                                 break;
 939                         case 1:
 940                                 mmc->version = MMC_VERSION_1_4;
 941                                 break;
 942                         case 2:
 943                                 mmc->version = MMC_VERSION_2_2;
 944                                 break;
 945                         case 3:
 946                                 mmc->version = MMC_VERSION_3;
 947                                 break;
 948                         case 4:
 949                                 mmc->version = MMC_VERSION_4;
 950                                 break;
 951                         default:
 952                                 mmc->version = MMC_VERSION_1_2;
 953                                 break;
 954                 }
 955         }
 956
 957         /* divide frequency by 10, since the mults are 10x bigger */
 958         freq = fbase[(cmd.response[0] & 0x7)];
 959         mult = multipliers[((cmd.response[0] >> 3) & 0xf)];
 960
 961         mmc->tran_speed = freq * mult;
 962
 963         mmc->read_bl_len = 1 << ((cmd.response[1] >> 16) & 0xf);
 964
 965         if (IS_SD(mmc))
 966                 mmc->write_bl_len = mmc->read_bl_len;
 967         else
 968                 mmc->write_bl_len = 1 << ((cmd.response[3] >> 22) & 0xf);
 969
 970         if (mmc->high_capacity) {
 971                 csize = (mmc->csd[1] & 0x3f) << 16
 972                         | (mmc->csd[2] & 0xffff0000) >> 16;
 973                 cmult = 8;
 974         } else {
 975                 csize = (mmc->csd[1] & 0x3ff) << 2
 976                         | (mmc->csd[2] & 0xc0000000) >> 30;
 977                 cmult = (mmc->csd[2] & 0x00038000) >> 15;
 978         }
 979
 980         mmc->capacity = (csize + 1) << (cmult + 2);
 981         mmc->capacity *= mmc->read_bl_len;
 982
 983         if (mmc->read_bl_len > 512)
 984                 mmc->read_bl_len = 512;
 985
 986         if (mmc->write_bl_len > 512)
 987                 mmc->write_bl_len = 512;
 988
 989         /* Select the card, and put it into Transfer Mode */
 990         if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */
 991                 cmd.cmdidx = MMC_CMD_SELECT_CARD;
 992                 cmd.resp_type = MMC_RSP_R1b;
 993                 cmd.cmdarg = mmc->rca << 16;
 994                 cmd.flags = 0;
 995                 err = mmc_send_cmd(mmc, &cmd, NULL);
 996
 997                 if (err)
 998                         return err;
 999         }
1000
1001         /*
1002          * For SD, its erase group is always one sector
1003          */
1004         mmc->erase_grp_size = 1;
1005         mmc->part_config = MMCPART_NOAVAILABLE;
1006         if (!IS_SD(mmc) && (mmc->version >= MMC_VERSION_4)) {
1007                 /* check  ext_csd version and capacity */
1008                 err = mmc_send_ext_csd(mmc, ext_csd);
1009                 if (!err & (ext_csd[192] >= 2)) {
1010                         /*
1011                          * According to the JEDEC Standard, the value of
1012                          * ext_csd's capacity is valid if the value is more
1013                          * than 2GB
1014                          */
1015                         capacity = ext_csd[212] << 0 | ext_csd[213] << 8 |
1016                                    ext_csd[214] << 16 | ext_csd[215] << 24;
1017                         capacity *= 512;
1018                         if ((capacity >> 20) > 2 * 1024)
1019                                 mmc->capacity = capacity;
1020                 }
1021
1022                 /*
1023                  * Check whether GROUP_DEF is set, if yes, read out
1024                  * group size from ext_csd directly, or calculate
1025                  * the group size from the csd value.
1026                  */
1027                 if (ext_csd[175])
1028                         mmc->erase_grp_size = ext_csd[224] * 512 * 1024;
1029                 else {
1030                         int erase_gsz, erase_gmul;
1031                         erase_gsz = (mmc->csd[2] & 0x00007c00) >> 10;
1032                         erase_gmul = (mmc->csd[2] & 0x000003e0) >> 5;
1033                         mmc->erase_grp_size = (erase_gsz + 1)
1034                                 * (erase_gmul + 1);
1035                 }
1036
1037                 /* store the partition info of emmc */
1038                 if (ext_csd[160] & PART_SUPPORT)
1039                         mmc->part_config = ext_csd[179];
1040         }
1041
1042         if (IS_SD(mmc))
1043                 err = sd_change_freq(mmc);
1044         else
1045                 err = mmc_change_freq(mmc);
1046
1047         if (err)
1048                 return err;
1049
1050         /* Restrict card's capabilities by what the host can do */
1051         mmc->card_caps &= mmc->host_caps;
1052
1053         if (IS_SD(mmc)) {
1054                 if (mmc->card_caps & MMC_MODE_4BIT) {
1055                         cmd.cmdidx = MMC_CMD_APP_CMD;
1056                         cmd.resp_type = MMC_RSP_R1;
1057                         cmd.cmdarg = mmc->rca << 16;
1058                         cmd.flags = 0;
1059
1060                         err = mmc_send_cmd(mmc, &cmd, NULL);
1061                         if (err)
1062                                 return err;
1063
1064                         cmd.cmdidx = SD_CMD_APP_SET_BUS_WIDTH;
1065                         cmd.resp_type = MMC_RSP_R1;
1066                         cmd.cmdarg = 2;
1067                         cmd.flags = 0;
1068                         err = mmc_send_cmd(mmc, &cmd, NULL);
1069                         if (err)
1070                                 return err;
1071
1072                         mmc_set_bus_width(mmc, 4);
1073                 }
1074
1075                 if (mmc->card_caps & MMC_MODE_HS)
1076                         mmc_set_clock(mmc, 50000000);
1077                 else
1078                         mmc_set_clock(mmc, 25000000);
1079         } else {
1080                 if (mmc->card_caps & MMC_MODE_4BIT) {
1081                         /* Set the card to use 4 bit*/
1082                         err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1083                                         EXT_CSD_BUS_WIDTH,
1084                                         EXT_CSD_BUS_WIDTH_4);
1085
1086                         if (err)
1087                                 return err;
1088
1089                         mmc_set_bus_width(mmc, 4);
1090                 } else if (mmc->card_caps & MMC_MODE_8BIT) {
1091                         /* Set the card to use 8 bit*/
1092                         err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1093                                         EXT_CSD_BUS_WIDTH,
1094                                         EXT_CSD_BUS_WIDTH_8);
1095
1096                         if (err)
1097                                 return err;
1098
1099                         mmc_set_bus_width(mmc, 8);
1100                 }
1101
1102                 if (mmc->card_caps & MMC_MODE_HS) {
1103                         if (mmc->card_caps & MMC_MODE_HS_52MHz)
1104                                 mmc_set_clock(mmc, 52000000);
1105                         else
1106                                 mmc_set_clock(mmc, 26000000);
1107                 } else
1108                         mmc_set_clock(mmc, 20000000);
1109         }
1110
1111         /* fill in device description */
1112         mmc->block_dev.lun = 0;
1113         mmc->block_dev.type = 0;
1114         mmc->block_dev.blksz = mmc->read_bl_len;
1115         mmc->block_dev.lba = lldiv(mmc->capacity, mmc->read_bl_len);
1116         sprintf(mmc->block_dev.vendor, "Man %06x Snr %08x", mmc->cid[0] >> 8,
1117                         (mmc->cid[2] << 8) | (mmc->cid[3] >> 24));
1118         sprintf(mmc->block_dev.product, "%c%c%c%c%c", mmc->cid[0] & 0xff,
1119                         (mmc->cid[1] >> 24), (mmc->cid[1] >> 16) & 0xff,
1120                         (mmc->cid[1] >> 8) & 0xff, mmc->cid[1] & 0xff);
1121         sprintf(mmc->block_dev.revision, "%d.%d", mmc->cid[2] >> 28,
1122                         (mmc->cid[2] >> 24) & 0xf);
1123         init_part(&mmc->block_dev);
1124
1125         return 0;
1126 }
1127
1128 int mmc_send_if_cond(struct mmc *mmc)
1129 {
1130         struct mmc_cmd cmd;
1131         int err;
1132
1133         cmd.cmdidx = SD_CMD_SEND_IF_COND;
1134         /* We set the bit if the host supports voltages between 2.7 and 3.6 V */
1135         cmd.cmdarg = ((mmc->voltages & 0xff8000) != 0) << 8 | 0xaa;
1136         cmd.resp_type = MMC_RSP_R7;
1137         cmd.flags = 0;
1138
1139         err = mmc_send_cmd(mmc, &cmd, NULL);
1140
1141         if (err)
1142                 return err;
1143
1144         if ((cmd.response[0] & 0xff) != 0xaa)
1145                 return UNUSABLE_ERR;
1146         else
1147                 mmc->version = SD_VERSION_2;
1148
1149         return 0;
1150 }
1151
1152 int mmc_register(struct mmc *mmc)
1153 {
1154         /* Setup the universal parts of the block interface just once */
1155         mmc->block_dev.if_type = IF_TYPE_MMC;
1156         mmc->block_dev.dev = cur_dev_num++;
1157         mmc->block_dev.removable = 1;
1158         mmc->block_dev.block_read = mmc_bread;
1159         mmc->block_dev.block_write = mmc_bwrite;
1160         mmc->block_dev.block_erase = mmc_berase;
1161         if (!mmc->b_max)
1162                 mmc->b_max = CONFIG_SYS_MMC_MAX_BLK_COUNT;
1163
1164         INIT_LIST_HEAD (&mmc->link);
1165
1166         list_add_tail (&mmc->link, &mmc_devices);
1167
1168         return 0;
1169 }
1170
1171 #ifdef CONFIG_PARTITIONS
1172 block_dev_desc_t *mmc_get_dev(int dev)
1173 {
1174         struct mmc *mmc = find_mmc_device(dev);
1175
1176         return mmc ? &mmc->block_dev : NULL;
1177 }
1178 #endif
1179
1180 int mmc_init(struct mmc *mmc)
1181 {
1182         int err;
1183
1184         if (mmc->has_init)
1185                 return 0;
1186
1187         err = mmc->init(mmc);
1188
1189         if (err)
1190                 return err;
1191
1192         mmc_set_bus_width(mmc, 1);
1193         mmc_set_clock(mmc, 1);
1194
1195         /* Reset the Card */
1196         err = mmc_go_idle(mmc);
1197
1198         if (err)
1199                 return err;
1200
1201         /* The internal partition reset to user partition(0) at every CMD0*/
1202         mmc->part_num = 0;
1203
1204         /* Test for SD version 2 */
1205         err = mmc_send_if_cond(mmc);
1206
1207         /* Now try to get the SD card's operating condition */
1208         err = sd_send_op_cond(mmc);
1209
1210         /* If the command timed out, we check for an MMC card */
1211         if (err == TIMEOUT) {
1212                 err = mmc_send_op_cond(mmc);
1213
1214                 if (err) {
1215                         printf("Card did not respond to voltage select!\n");
1216                         return UNUSABLE_ERR;
1217                 }
1218         }
1219
1220         err = mmc_startup(mmc);
1221         if (err)
1222                 mmc->has_init = 0;
1223         else
1224                 mmc->has_init = 1;
1225         return err;
1226 }
1227
1228 /*
1229  * CPU and board-specific MMC initializations.  Aliased function
1230  * signals caller to move on
1231  */
1232 static int __def_mmc_init(bd_t *bis)
1233 {
1234         return -1;
1235 }
1236
1237 int cpu_mmc_init(bd_t *bis) __attribute__((weak, alias("__def_mmc_init")));
1238 int board_mmc_init(bd_t *bis) __attribute__((weak, alias("__def_mmc_init")));
1239
1240 void print_mmc_devices(char separator)
1241 {
1242         struct mmc *m;
1243         struct list_head *entry;
1244
1245         list_for_each(entry, &mmc_devices) {
1246                 m = list_entry(entry, struct mmc, link);
1247
1248                 printf("%s: %d", m->name, m->block_dev.dev);
1249
1250                 if (entry->next != &mmc_devices)
1251                         printf("%c ", separator);
1252         }
1253
1254         printf("\n");
1255 }
1256
1257 int get_mmc_num(void)
1258 {
1259         return cur_dev_num;
1260 }
1261
1262 int mmc_initialize(bd_t *bis)
1263 {
1264         INIT_LIST_HEAD (&mmc_devices);
1265         cur_dev_num = 0;
1266
1267         if (board_mmc_init(bis) < 0)
1268                 cpu_mmc_init(bis);
1269
1270         print_mmc_devices(',');
1271
1272         return 0;
1273 }