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(struct mmc *mmc) {
  44         return -1;
  45 }
  46
  47 int board_mmc_getcd(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         ALLOC_CACHE_ALIGN_BUFFER(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         err = mmc_send_ext_csd(mmc, ext_csd);
 635
 636         if (err)
 637                 return err;
 638
 639         cardtype = ext_csd[EXT_CSD_CARD_TYPE] & 0xf;
 640
 641         err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING, 1);
 642
 643         if (err)
 644                 return err;
 645
 646         /* Now check to see that it worked */
 647         err = mmc_send_ext_csd(mmc, ext_csd);
 648
 649         if (err)
 650                 return err;
 651
 652         /* No high-speed support */
 653         if (!ext_csd[EXT_CSD_HS_TIMING])
 654                 return 0;
 655
 656         /* High Speed is set, there are two types: 52MHz and 26MHz */
 657         if (cardtype & MMC_HS_52MHZ)
 658                 mmc->card_caps |= MMC_MODE_HS_52MHz | MMC_MODE_HS;
 659         else
 660                 mmc->card_caps |= MMC_MODE_HS;
 661
 662         return 0;
 663 }
 664
 665 int mmc_switch_part(int dev_num, unsigned int part_num)
 666 {
 667         struct mmc *mmc = find_mmc_device(dev_num);
 668
 669         if (!mmc)
 670                 return -1;
 671
 672         return mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONF,
 673                           (mmc->part_config & ~PART_ACCESS_MASK)
 674                           | (part_num & PART_ACCESS_MASK));
 675 }
 676
 677 int sd_switch(struct mmc *mmc, int mode, int group, u8 value, u8 *resp)
 678 {
 679         struct mmc_cmd cmd;
 680         struct mmc_data data;
 681
 682         /* Switch the frequency */
 683         cmd.cmdidx = SD_CMD_SWITCH_FUNC;
 684         cmd.resp_type = MMC_RSP_R1;
 685         cmd.cmdarg = (mode << 31) | 0xffffff;
 686         cmd.cmdarg &= ~(0xf << (group * 4));
 687         cmd.cmdarg |= value << (group * 4);
 688         cmd.flags = 0;
 689
 690         data.dest = (char *)resp;
 691         data.blocksize = 64;
 692         data.blocks = 1;
 693         data.flags = MMC_DATA_READ;
 694
 695         return mmc_send_cmd(mmc, &cmd, &data);
 696 }
 697
 698
 699 int sd_change_freq(struct mmc *mmc)
 700 {
 701         int err;
 702         struct mmc_cmd cmd;
 703         ALLOC_CACHE_ALIGN_BUFFER(uint, scr, 2);
 704         ALLOC_CACHE_ALIGN_BUFFER(uint, switch_status, 16);
 705         struct mmc_data data;
 706         int timeout;
 707
 708         mmc->card_caps = 0;
 709
 710         if (mmc_host_is_spi(mmc))
 711                 return 0;
 712
 713         /* Read the SCR to find out if this card supports higher speeds */
 714         cmd.cmdidx = MMC_CMD_APP_CMD;
 715         cmd.resp_type = MMC_RSP_R1;
 716         cmd.cmdarg = mmc->rca << 16;
 717         cmd.flags = 0;
 718
 719         err = mmc_send_cmd(mmc, &cmd, NULL);
 720
 721         if (err)
 722                 return err;
 723
 724         cmd.cmdidx = SD_CMD_APP_SEND_SCR;
 725         cmd.resp_type = MMC_RSP_R1;
 726         cmd.cmdarg = 0;
 727         cmd.flags = 0;
 728
 729         timeout = 3;
 730
 731 retry_scr:
 732         data.dest = (char *)scr;
 733         data.blocksize = 8;
 734         data.blocks = 1;
 735         data.flags = MMC_DATA_READ;
 736
 737         err = mmc_send_cmd(mmc, &cmd, &data);
 738
 739         if (err) {
 740                 if (timeout--)
 741                         goto retry_scr;
 742
 743                 return err;
 744         }
 745
 746         mmc->scr[0] = __be32_to_cpu(scr[0]);
 747         mmc->scr[1] = __be32_to_cpu(scr[1]);
 748
 749         switch ((mmc->scr[0] >> 24) & 0xf) {
 750                 case 0:
 751                         mmc->version = SD_VERSION_1_0;
 752                         break;
 753                 case 1:
 754                         mmc->version = SD_VERSION_1_10;
 755                         break;
 756                 case 2:
 757                         mmc->version = SD_VERSION_2;
 758                         break;
 759                 default:
 760                         mmc->version = SD_VERSION_1_0;
 761                         break;
 762         }
 763
 764         if (mmc->scr[0] & SD_DATA_4BIT)
 765                 mmc->card_caps |= MMC_MODE_4BIT;
 766
 767         /* Version 1.0 doesn't support switching */
 768         if (mmc->version == SD_VERSION_1_0)
 769                 return 0;
 770
 771         timeout = 4;
 772         while (timeout--) {
 773                 err = sd_switch(mmc, SD_SWITCH_CHECK, 0, 1,
 774                                 (u8 *)switch_status);
 775
 776                 if (err)
 777                         return err;
 778
 779                 /* The high-speed function is busy.  Try again */
 780                 if (!(__be32_to_cpu(switch_status[7]) & SD_HIGHSPEED_BUSY))
 781                         break;
 782         }
 783
 784         /* If high-speed isn't supported, we return */
 785         if (!(__be32_to_cpu(switch_status[3]) & SD_HIGHSPEED_SUPPORTED))
 786                 return 0;
 787
 788         /*
 789          * If the host doesn't support SD_HIGHSPEED, do not switch card to
 790          * HIGHSPEED mode even if the card support SD_HIGHSPPED.
 791          * This can avoid furthur problem when the card runs in different
 792          * mode between the host.
 793          */
 794         if (!((mmc->host_caps & MMC_MODE_HS_52MHz) &&
 795                 (mmc->host_caps & MMC_MODE_HS)))
 796                 return 0;
 797
 798         err = sd_switch(mmc, SD_SWITCH_SWITCH, 0, 1, (u8 *)switch_status);
 799
 800         if (err)
 801                 return err;
 802
 803         if ((__be32_to_cpu(switch_status[4]) & 0x0f000000) == 0x01000000)
 804                 mmc->card_caps |= MMC_MODE_HS;
 805
 806         return 0;
 807 }
 808
 809 /* frequency bases */
 810 /* divided by 10 to be nice to platforms without floating point */
 811 static const int fbase[] = {
 812         10000,
 813         100000,
 814         1000000,
 815         10000000,
 816 };
 817
 818 /* Multiplier values for TRAN_SPEED.  Multiplied by 10 to be nice
 819  * to platforms without floating point.
 820  */
 821 static const int multipliers[] = {
 822         0,      /* reserved */
 823         10,
 824         12,
 825         13,
 826         15,
 827         20,
 828         25,
 829         30,
 830         35,
 831         40,
 832         45,
 833         50,
 834         55,
 835         60,
 836         70,
 837         80,
 838 };
 839
 840 void mmc_set_ios(struct mmc *mmc)
 841 {
 842         mmc->set_ios(mmc);
 843 }
 844
 845 void mmc_set_clock(struct mmc *mmc, uint clock)
 846 {
 847         if (clock > mmc->f_max)
 848                 clock = mmc->f_max;
 849
 850         if (clock < mmc->f_min)
 851                 clock = mmc->f_min;
 852
 853         mmc->clock = clock;
 854
 855         mmc_set_ios(mmc);
 856 }
 857
 858 void mmc_set_bus_width(struct mmc *mmc, uint width)
 859 {
 860         mmc->bus_width = width;
 861
 862         mmc_set_ios(mmc);
 863 }
 864
 865 int mmc_startup(struct mmc *mmc)
 866 {
 867         int err, width;
 868         uint mult, freq;
 869         u64 cmult, csize, capacity;
 870         struct mmc_cmd cmd;
 871         ALLOC_CACHE_ALIGN_BUFFER(char, ext_csd, 512);
 872         ALLOC_CACHE_ALIGN_BUFFER(char, test_csd, 512);
 873         int timeout = 1000;
 874
 875 #ifdef CONFIG_MMC_SPI_CRC_ON
 876         if (mmc_host_is_spi(mmc)) { /* enable CRC check for spi */
 877                 cmd.cmdidx = MMC_CMD_SPI_CRC_ON_OFF;
 878                 cmd.resp_type = MMC_RSP_R1;
 879                 cmd.cmdarg = 1;
 880                 cmd.flags = 0;
 881                 err = mmc_send_cmd(mmc, &cmd, NULL);
 882
 883                 if (err)
 884                         return err;
 885         }
 886 #endif
 887
 888         /* Put the Card in Identify Mode */
 889         cmd.cmdidx = mmc_host_is_spi(mmc) ? MMC_CMD_SEND_CID :
 890                 MMC_CMD_ALL_SEND_CID; /* cmd not supported in spi */
 891         cmd.resp_type = MMC_RSP_R2;
 892         cmd.cmdarg = 0;
 893         cmd.flags = 0;
 894
 895         err = mmc_send_cmd(mmc, &cmd, NULL);
 896
 897         if (err)
 898                 return err;
 899
 900         memcpy(mmc->cid, cmd.response, 16);
 901
 902         /*
 903          * For MMC cards, set the Relative Address.
 904          * For SD cards, get the Relatvie Address.
 905          * This also puts the cards into Standby State
 906          */
 907         if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */
 908                 cmd.cmdidx = SD_CMD_SEND_RELATIVE_ADDR;
 909                 cmd.cmdarg = mmc->rca << 16;
 910                 cmd.resp_type = MMC_RSP_R6;
 911                 cmd.flags = 0;
 912
 913                 err = mmc_send_cmd(mmc, &cmd, NULL);
 914
 915                 if (err)
 916                         return err;
 917
 918                 if (IS_SD(mmc))
 919                         mmc->rca = (cmd.response[0] >> 16) & 0xffff;
 920         }
 921
 922         /* Get the Card-Specific Data */
 923         cmd.cmdidx = MMC_CMD_SEND_CSD;
 924         cmd.resp_type = MMC_RSP_R2;
 925         cmd.cmdarg = mmc->rca << 16;
 926         cmd.flags = 0;
 927
 928         err = mmc_send_cmd(mmc, &cmd, NULL);
 929
 930         /* Waiting for the ready status */
 931         mmc_send_status(mmc, timeout);
 932
 933         if (err)
 934                 return err;
 935
 936         mmc->csd[0] = cmd.response[0];
 937         mmc->csd[1] = cmd.response[1];
 938         mmc->csd[2] = cmd.response[2];
 939         mmc->csd[3] = cmd.response[3];
 940
 941         if (mmc->version == MMC_VERSION_UNKNOWN) {
 942                 int version = (cmd.response[0] >> 26) & 0xf;
 943
 944                 switch (version) {
 945                         case 0:
 946                                 mmc->version = MMC_VERSION_1_2;
 947                                 break;
 948                         case 1:
 949                                 mmc->version = MMC_VERSION_1_4;
 950                                 break;
 951                         case 2:
 952                                 mmc->version = MMC_VERSION_2_2;
 953                                 break;
 954                         case 3:
 955                                 mmc->version = MMC_VERSION_3;
 956                                 break;
 957                         case 4:
 958                                 mmc->version = MMC_VERSION_4;
 959                                 break;
 960                         default:
 961                                 mmc->version = MMC_VERSION_1_2;
 962                                 break;
 963                 }
 964         }
 965
 966         /* divide frequency by 10, since the mults are 10x bigger */
 967         freq = fbase[(cmd.response[0] & 0x7)];
 968         mult = multipliers[((cmd.response[0] >> 3) & 0xf)];
 969
 970         mmc->tran_speed = freq * mult;
 971
 972         mmc->read_bl_len = 1 << ((cmd.response[1] >> 16) & 0xf);
 973
 974         if (IS_SD(mmc))
 975                 mmc->write_bl_len = mmc->read_bl_len;
 976         else
 977                 mmc->write_bl_len = 1 << ((cmd.response[3] >> 22) & 0xf);
 978
 979         if (mmc->high_capacity) {
 980                 csize = (mmc->csd[1] & 0x3f) << 16
 981                         | (mmc->csd[2] & 0xffff0000) >> 16;
 982                 cmult = 8;
 983         } else {
 984                 csize = (mmc->csd[1] & 0x3ff) << 2
 985                         | (mmc->csd[2] & 0xc0000000) >> 30;
 986                 cmult = (mmc->csd[2] & 0x00038000) >> 15;
 987         }
 988
 989         mmc->capacity = (csize + 1) << (cmult + 2);
 990         mmc->capacity *= mmc->read_bl_len;
 991
 992         if (mmc->read_bl_len > 512)
 993                 mmc->read_bl_len = 512;
 994
 995         if (mmc->write_bl_len > 512)
 996                 mmc->write_bl_len = 512;
 997
 998         /* Select the card, and put it into Transfer Mode */
 999         if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */
1000                 cmd.cmdidx = MMC_CMD_SELECT_CARD;
1001                 cmd.resp_type = MMC_RSP_R1;
1002                 cmd.cmdarg = mmc->rca << 16;
1003                 cmd.flags = 0;
1004                 err = mmc_send_cmd(mmc, &cmd, NULL);
1005
1006                 if (err)
1007                         return err;
1008         }
1009
1010         /*
1011          * For SD, its erase group is always one sector
1012          */
1013         mmc->erase_grp_size = 1;
1014         mmc->part_config = MMCPART_NOAVAILABLE;
1015         if (!IS_SD(mmc) && (mmc->version >= MMC_VERSION_4)) {
1016                 /* check  ext_csd version and capacity */
1017                 err = mmc_send_ext_csd(mmc, ext_csd);
1018                 if (!err & (ext_csd[EXT_CSD_REV] >= 2)) {
1019                         /*
1020                          * According to the JEDEC Standard, the value of
1021                          * ext_csd's capacity is valid if the value is more
1022                          * than 2GB
1023                          */
1024                         capacity = ext_csd[EXT_CSD_SEC_CNT] << 0
1025                                         | ext_csd[EXT_CSD_SEC_CNT + 1] << 8
1026                                         | ext_csd[EXT_CSD_SEC_CNT + 2] << 16
1027                                         | ext_csd[EXT_CSD_SEC_CNT + 3] << 24;
1028                         capacity *= 512;
1029                         if ((capacity >> 20) > 2 * 1024)
1030                                 mmc->capacity = capacity;
1031                 }
1032
1033                 /*
1034                  * Check whether GROUP_DEF is set, if yes, read out
1035                  * group size from ext_csd directly, or calculate
1036                  * the group size from the csd value.
1037                  */
1038                 if (ext_csd[EXT_CSD_ERASE_GROUP_DEF])
1039                         mmc->erase_grp_size =
1040                               ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] * 512 * 1024;
1041                 else {
1042                         int erase_gsz, erase_gmul;
1043                         erase_gsz = (mmc->csd[2] & 0x00007c00) >> 10;
1044                         erase_gmul = (mmc->csd[2] & 0x000003e0) >> 5;
1045                         mmc->erase_grp_size = (erase_gsz + 1)
1046                                 * (erase_gmul + 1);
1047                 }
1048
1049                 /* store the partition info of emmc */
1050                 if (ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & PART_SUPPORT)
1051                         mmc->part_config = ext_csd[EXT_CSD_PART_CONF];
1052         }
1053
1054         if (IS_SD(mmc))
1055                 err = sd_change_freq(mmc);
1056         else
1057                 err = mmc_change_freq(mmc);
1058
1059         if (err)
1060                 return err;
1061
1062         /* Restrict card's capabilities by what the host can do */
1063         mmc->card_caps &= mmc->host_caps;
1064
1065         if (IS_SD(mmc)) {
1066                 if (mmc->card_caps & MMC_MODE_4BIT) {
1067                         cmd.cmdidx = MMC_CMD_APP_CMD;
1068                         cmd.resp_type = MMC_RSP_R1;
1069                         cmd.cmdarg = mmc->rca << 16;
1070                         cmd.flags = 0;
1071
1072                         err = mmc_send_cmd(mmc, &cmd, NULL);
1073                         if (err)
1074                                 return err;
1075
1076                         cmd.cmdidx = SD_CMD_APP_SET_BUS_WIDTH;
1077                         cmd.resp_type = MMC_RSP_R1;
1078                         cmd.cmdarg = 2;
1079                         cmd.flags = 0;
1080                         err = mmc_send_cmd(mmc, &cmd, NULL);
1081                         if (err)
1082                                 return err;
1083
1084                         mmc_set_bus_width(mmc, 4);
1085                 }
1086
1087                 if (mmc->card_caps & MMC_MODE_HS)
1088                         mmc_set_clock(mmc, 50000000);
1089                 else
1090                         mmc_set_clock(mmc, 25000000);
1091         } else {
1092                 for (width = EXT_CSD_BUS_WIDTH_8; width >= 0; width--) {
1093                         /* Set the card to use 4 bit*/
1094                         err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1095                                         EXT_CSD_BUS_WIDTH, width);
1096
1097                         if (err)
1098                                 continue;
1099
1100                         if (!width) {
1101                                 mmc_set_bus_width(mmc, 1);
1102                                 break;
1103                         } else
1104                                 mmc_set_bus_width(mmc, 4 * width);
1105
1106                         err = mmc_send_ext_csd(mmc, test_csd);
1107                         if (!err && ext_csd[EXT_CSD_PARTITIONING_SUPPORT] \
1108                                     == test_csd[EXT_CSD_PARTITIONING_SUPPORT]
1109                                  && ext_csd[EXT_CSD_ERASE_GROUP_DEF] \
1110                                     == test_csd[EXT_CSD_ERASE_GROUP_DEF] \
1111                                  && ext_csd[EXT_CSD_REV] \
1112                                     == test_csd[EXT_CSD_REV]
1113                                  && ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] \
1114                                     == test_csd[EXT_CSD_HC_ERASE_GRP_SIZE]
1115                                  && memcmp(&ext_csd[EXT_CSD_SEC_CNT], \
1116                                         &test_csd[EXT_CSD_SEC_CNT], 4) == 0) {
1117
1118                                 mmc->card_caps |= width;
1119                                 break;
1120                         }
1121                 }
1122
1123                 if (mmc->card_caps & MMC_MODE_HS) {
1124                         if (mmc->card_caps & MMC_MODE_HS_52MHz)
1125                                 mmc_set_clock(mmc, 52000000);
1126                         else
1127                                 mmc_set_clock(mmc, 26000000);
1128                 } else
1129                         mmc_set_clock(mmc, 20000000);
1130         }
1131
1132         /* fill in device description */
1133         mmc->block_dev.lun = 0;
1134         mmc->block_dev.type = 0;
1135         mmc->block_dev.blksz = mmc->read_bl_len;
1136         mmc->block_dev.lba = lldiv(mmc->capacity, mmc->read_bl_len);
1137         sprintf(mmc->block_dev.vendor, "Man %06x Snr %08x", mmc->cid[0] >> 8,
1138                         (mmc->cid[2] << 8) | (mmc->cid[3] >> 24));
1139         sprintf(mmc->block_dev.product, "%c%c%c%c%c", mmc->cid[0] & 0xff,
1140                         (mmc->cid[1] >> 24), (mmc->cid[1] >> 16) & 0xff,
1141                         (mmc->cid[1] >> 8) & 0xff, mmc->cid[1] & 0xff);
1142         sprintf(mmc->block_dev.revision, "%d.%d", mmc->cid[2] >> 28,
1143                         (mmc->cid[2] >> 24) & 0xf);
1144         init_part(&mmc->block_dev);
1145
1146         return 0;
1147 }
1148
1149 int mmc_send_if_cond(struct mmc *mmc)
1150 {
1151         struct mmc_cmd cmd;
1152         int err;
1153
1154         cmd.cmdidx = SD_CMD_SEND_IF_COND;
1155         /* We set the bit if the host supports voltages between 2.7 and 3.6 V */
1156         cmd.cmdarg = ((mmc->voltages & 0xff8000) != 0) << 8 | 0xaa;
1157         cmd.resp_type = MMC_RSP_R7;
1158         cmd.flags = 0;
1159
1160         err = mmc_send_cmd(mmc, &cmd, NULL);
1161
1162         if (err)
1163                 return err;
1164
1165         if ((cmd.response[0] & 0xff) != 0xaa)
1166                 return UNUSABLE_ERR;
1167         else
1168                 mmc->version = SD_VERSION_2;
1169
1170         return 0;
1171 }
1172
1173 int mmc_register(struct mmc *mmc)
1174 {
1175         /* Setup the universal parts of the block interface just once */
1176         mmc->block_dev.if_type = IF_TYPE_MMC;
1177         mmc->block_dev.dev = cur_dev_num++;
1178         mmc->block_dev.removable = 1;
1179         mmc->block_dev.block_read = mmc_bread;
1180         mmc->block_dev.block_write = mmc_bwrite;
1181         mmc->block_dev.block_erase = mmc_berase;
1182         if (!mmc->b_max)
1183                 mmc->b_max = CONFIG_SYS_MMC_MAX_BLK_COUNT;
1184
1185         INIT_LIST_HEAD (&mmc->link);
1186
1187         list_add_tail (&mmc->link, &mmc_devices);
1188
1189         return 0;
1190 }
1191
1192 #ifdef CONFIG_PARTITIONS
1193 block_dev_desc_t *mmc_get_dev(int dev)
1194 {
1195         struct mmc *mmc = find_mmc_device(dev);
1196
1197         return mmc ? &mmc->block_dev : NULL;
1198 }
1199 #endif
1200
1201 int mmc_init(struct mmc *mmc)
1202 {
1203         int err;
1204
1205         if (mmc->has_init)
1206                 return 0;
1207
1208         err = mmc->init(mmc);
1209
1210         if (err)
1211                 return err;
1212
1213         mmc_set_bus_width(mmc, 1);
1214         mmc_set_clock(mmc, 1);
1215
1216         /* Reset the Card */
1217         err = mmc_go_idle(mmc);
1218
1219         if (err)
1220                 return err;
1221
1222         /* The internal partition reset to user partition(0) at every CMD0*/
1223         mmc->part_num = 0;
1224
1225         /* Test for SD version 2 */
1226         err = mmc_send_if_cond(mmc);
1227
1228         /* Now try to get the SD card's operating condition */
1229         err = sd_send_op_cond(mmc);
1230
1231         /* If the command timed out, we check for an MMC card */
1232         if (err == TIMEOUT) {
1233                 err = mmc_send_op_cond(mmc);
1234
1235                 if (err) {
1236                         printf("Card did not respond to voltage select!\n");
1237                         return UNUSABLE_ERR;
1238                 }
1239         }
1240
1241         err = mmc_startup(mmc);
1242         if (err)
1243                 mmc->has_init = 0;
1244         else
1245                 mmc->has_init = 1;
1246         return err;
1247 }
1248
1249 /*
1250  * CPU and board-specific MMC initializations.  Aliased function
1251  * signals caller to move on
1252  */
1253 static int __def_mmc_init(bd_t *bis)
1254 {
1255         return -1;
1256 }
1257
1258 int cpu_mmc_init(bd_t *bis) __attribute__((weak, alias("__def_mmc_init")));
1259 int board_mmc_init(bd_t *bis) __attribute__((weak, alias("__def_mmc_init")));
1260
1261 void print_mmc_devices(char separator)
1262 {
1263         struct mmc *m;
1264         struct list_head *entry;
1265
1266         list_for_each(entry, &mmc_devices) {
1267                 m = list_entry(entry, struct mmc, link);
1268
1269                 printf("%s: %d", m->name, m->block_dev.dev);
1270
1271                 if (entry->next != &mmc_devices)
1272                         printf("%c ", separator);
1273         }
1274
1275         printf("\n");
1276 }
1277
1278 int get_mmc_num(void)
1279 {
1280         return cur_dev_num;
1281 }
1282
1283 int mmc_initialize(bd_t *bis)
1284 {
1285         INIT_LIST_HEAD (&mmc_devices);
1286         cur_dev_num = 0;
1287
1288         if (board_mmc_init(bis) < 0)
1289                 cpu_mmc_init(bis);
1290
1291         print_mmc_devices(',');
1292
1293         return 0;
1294 }