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