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