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