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