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