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