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 = MMC_MAX_BLOCK_LEN;
 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, MMC_MAX_BLOCK_LEN);
 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                         if ((mmc->scr[0] >> 15) & 0x1)
 788                                 mmc->version = SD_VERSION_3;
 789                         break;
 790                 default:
 791                         mmc->version = SD_VERSION_1_0;
 792                         break;
 793         }
 794
 795         if (mmc->scr[0] & SD_DATA_4BIT)
 796                 mmc->card_caps |= MMC_MODE_4BIT;
 797
 798         /* Version 1.0 doesn't support switching */
 799         if (mmc->version == SD_VERSION_1_0)
 800                 return 0;
 801
 802         timeout = 4;
 803         while (timeout--) {
 804                 err = sd_switch(mmc, SD_SWITCH_CHECK, 0, 1,
 805                                 (u8 *)switch_status);
 806
 807                 if (err)
 808                         return err;
 809
 810                 /* The high-speed function is busy.  Try again */
 811                 if (!(__be32_to_cpu(switch_status[7]) & SD_HIGHSPEED_BUSY))
 812                         break;
 813         }
 814
 815         /* If high-speed isn't supported, we return */
 816         if (!(__be32_to_cpu(switch_status[3]) & SD_HIGHSPEED_SUPPORTED))
 817                 return 0;
 818
 819         /*
 820          * If the host doesn't support SD_HIGHSPEED, do not switch card to
 821          * HIGHSPEED mode even if the card support SD_HIGHSPPED.
 822          * This can avoid furthur problem when the card runs in different
 823          * mode between the host.
 824          */
 825         if (!((mmc->host_caps & MMC_MODE_HS_52MHz) &&
 826                 (mmc->host_caps & MMC_MODE_HS)))
 827                 return 0;
 828
 829         err = sd_switch(mmc, SD_SWITCH_SWITCH, 0, 1, (u8 *)switch_status);
 830
 831         if (err)
 832                 return err;
 833
 834         if ((__be32_to_cpu(switch_status[4]) & 0x0f000000) == 0x01000000)
 835                 mmc->card_caps |= MMC_MODE_HS;
 836
 837         return 0;
 838 }
 839
 840 /* frequency bases */
 841 /* divided by 10 to be nice to platforms without floating point */
 842 static const int fbase[] = {
 843         10000,
 844         100000,
 845         1000000,
 846         10000000,
 847 };
 848
 849 /* Multiplier values for TRAN_SPEED.  Multiplied by 10 to be nice
 850  * to platforms without floating point.
 851  */
 852 static const int multipliers[] = {
 853         0,      /* reserved */
 854         10,
 855         12,
 856         13,
 857         15,
 858         20,
 859         25,
 860         30,
 861         35,
 862         40,
 863         45,
 864         50,
 865         55,
 866         60,
 867         70,
 868         80,
 869 };
 870
 871 static void mmc_set_ios(struct mmc *mmc)
 872 {
 873         mmc->set_ios(mmc);
 874 }
 875
 876 void mmc_set_clock(struct mmc *mmc, uint clock)
 877 {
 878         if (clock > mmc->f_max)
 879                 clock = mmc->f_max;
 880
 881         if (clock < mmc->f_min)
 882                 clock = mmc->f_min;
 883
 884         mmc->clock = clock;
 885
 886         mmc_set_ios(mmc);
 887 }
 888
 889 static void mmc_set_bus_width(struct mmc *mmc, uint width)
 890 {
 891         mmc->bus_width = width;
 892
 893         mmc_set_ios(mmc);
 894 }
 895
 896 static int mmc_startup(struct mmc *mmc)
 897 {
 898         int err;
 899         uint mult, freq;
 900         u64 cmult, csize, capacity;
 901         struct mmc_cmd cmd;
 902         ALLOC_CACHE_ALIGN_BUFFER(u8, ext_csd, MMC_MAX_BLOCK_LEN);
 903         ALLOC_CACHE_ALIGN_BUFFER(u8, test_csd, MMC_MAX_BLOCK_LEN);
 904         int timeout = 1000;
 905
 906 #ifdef CONFIG_MMC_SPI_CRC_ON
 907         if (mmc_host_is_spi(mmc)) { /* enable CRC check for spi */
 908                 cmd.cmdidx = MMC_CMD_SPI_CRC_ON_OFF;
 909                 cmd.resp_type = MMC_RSP_R1;
 910                 cmd.cmdarg = 1;
 911                 err = mmc_send_cmd(mmc, &cmd, NULL);
 912
 913                 if (err)
 914                         return err;
 915         }
 916 #endif
 917
 918         /* Put the Card in Identify Mode */
 919         cmd.cmdidx = mmc_host_is_spi(mmc) ? MMC_CMD_SEND_CID :
 920                 MMC_CMD_ALL_SEND_CID; /* cmd not supported in spi */
 921         cmd.resp_type = MMC_RSP_R2;
 922         cmd.cmdarg = 0;
 923
 924         err = mmc_send_cmd(mmc, &cmd, NULL);
 925
 926         if (err)
 927                 return err;
 928
 929         memcpy(mmc->cid, cmd.response, 16);
 930
 931         /*
 932          * For MMC cards, set the Relative Address.
 933          * For SD cards, get the Relatvie Address.
 934          * This also puts the cards into Standby State
 935          */
 936         if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */
 937                 cmd.cmdidx = SD_CMD_SEND_RELATIVE_ADDR;
 938                 cmd.cmdarg = mmc->rca << 16;
 939                 cmd.resp_type = MMC_RSP_R6;
 940
 941                 err = mmc_send_cmd(mmc, &cmd, NULL);
 942
 943                 if (err)
 944                         return err;
 945
 946                 if (IS_SD(mmc))
 947                         mmc->rca = (cmd.response[0] >> 16) & 0xffff;
 948         }
 949
 950         /* Get the Card-Specific Data */
 951         cmd.cmdidx = MMC_CMD_SEND_CSD;
 952         cmd.resp_type = MMC_RSP_R2;
 953         cmd.cmdarg = mmc->rca << 16;
 954
 955         err = mmc_send_cmd(mmc, &cmd, NULL);
 956
 957         /* Waiting for the ready status */
 958         mmc_send_status(mmc, timeout);
 959
 960         if (err)
 961                 return err;
 962
 963         mmc->csd[0] = cmd.response[0];
 964         mmc->csd[1] = cmd.response[1];
 965         mmc->csd[2] = cmd.response[2];
 966         mmc->csd[3] = cmd.response[3];
 967
 968         if (mmc->version == MMC_VERSION_UNKNOWN) {
 969                 int version = (cmd.response[0] >> 26) & 0xf;
 970
 971                 switch (version) {
 972                         case 0:
 973                                 mmc->version = MMC_VERSION_1_2;
 974                                 break;
 975                         case 1:
 976                                 mmc->version = MMC_VERSION_1_4;
 977                                 break;
 978                         case 2:
 979                                 mmc->version = MMC_VERSION_2_2;
 980                                 break;
 981                         case 3:
 982                                 mmc->version = MMC_VERSION_3;
 983                                 break;
 984                         case 4:
 985                                 mmc->version = MMC_VERSION_4;
 986                                 break;
 987                         default:
 988                                 mmc->version = MMC_VERSION_1_2;
 989                                 break;
 990                 }
 991         }
 992
 993         /* divide frequency by 10, since the mults are 10x bigger */
 994         freq = fbase[(cmd.response[0] & 0x7)];
 995         mult = multipliers[((cmd.response[0] >> 3) & 0xf)];
 996
 997         mmc->tran_speed = freq * mult;
 998
 999         mmc->read_bl_len = 1 << ((cmd.response[1] >> 16) & 0xf);
1000
1001         if (IS_SD(mmc))
1002                 mmc->write_bl_len = mmc->read_bl_len;
1003         else
1004                 mmc->write_bl_len = 1 << ((cmd.response[3] >> 22) & 0xf);
1005
1006         if (mmc->high_capacity) {
1007                 csize = (mmc->csd[1] & 0x3f) << 16
1008                         | (mmc->csd[2] & 0xffff0000) >> 16;
1009                 cmult = 8;
1010         } else {
1011                 csize = (mmc->csd[1] & 0x3ff) << 2
1012                         | (mmc->csd[2] & 0xc0000000) >> 30;
1013                 cmult = (mmc->csd[2] & 0x00038000) >> 15;
1014         }
1015
1016         mmc->capacity = (csize + 1) << (cmult + 2);
1017         mmc->capacity *= mmc->read_bl_len;
1018
1019         if (mmc->read_bl_len > MMC_MAX_BLOCK_LEN)
1020                 mmc->read_bl_len = MMC_MAX_BLOCK_LEN;
1021
1022         if (mmc->write_bl_len > MMC_MAX_BLOCK_LEN)
1023                 mmc->write_bl_len = MMC_MAX_BLOCK_LEN;
1024
1025         /* Select the card, and put it into Transfer Mode */
1026         if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */
1027                 cmd.cmdidx = MMC_CMD_SELECT_CARD;
1028                 cmd.resp_type = MMC_RSP_R1;
1029                 cmd.cmdarg = mmc->rca << 16;
1030                 err = mmc_send_cmd(mmc, &cmd, NULL);
1031
1032                 if (err)
1033                         return err;
1034         }
1035
1036         /*
1037          * For SD, its erase group is always one sector
1038          */
1039         mmc->erase_grp_size = 1;
1040         mmc->part_config = MMCPART_NOAVAILABLE;
1041         if (!IS_SD(mmc) && (mmc->version >= MMC_VERSION_4)) {
1042                 /* check  ext_csd version and capacity */
1043                 err = mmc_send_ext_csd(mmc, ext_csd);
1044                 if (!err && (ext_csd[EXT_CSD_REV] >= 2)) {
1045                         /*
1046                          * According to the JEDEC Standard, the value of
1047                          * ext_csd's capacity is valid if the value is more
1048                          * than 2GB
1049                          */
1050                         capacity = ext_csd[EXT_CSD_SEC_CNT] << 0
1051                                         | ext_csd[EXT_CSD_SEC_CNT + 1] << 8
1052                                         | ext_csd[EXT_CSD_SEC_CNT + 2] << 16
1053                                         | ext_csd[EXT_CSD_SEC_CNT + 3] << 24;
1054                         capacity *= MMC_MAX_BLOCK_LEN;
1055                         if ((capacity >> 20) > 2 * 1024)
1056                                 mmc->capacity = capacity;
1057                 }
1058
1059                 switch (ext_csd[EXT_CSD_REV]) {
1060                 case 1:
1061                         mmc->version = MMC_VERSION_4_1;
1062                         break;
1063                 case 2:
1064                         mmc->version = MMC_VERSION_4_2;
1065                         break;
1066                 case 3:
1067                         mmc->version = MMC_VERSION_4_3;
1068                         break;
1069                 case 5:
1070                         mmc->version = MMC_VERSION_4_41;
1071                         break;
1072                 case 6:
1073                         mmc->version = MMC_VERSION_4_5;
1074                         break;
1075                 }
1076
1077                 /*
1078                  * Check whether GROUP_DEF is set, if yes, read out
1079                  * group size from ext_csd directly, or calculate
1080                  * the group size from the csd value.
1081                  */
1082                 if (ext_csd[EXT_CSD_ERASE_GROUP_DEF]) {
1083                         mmc->erase_grp_size =
1084                                 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] *
1085                                         MMC_MAX_BLOCK_LEN * 1024;
1086                 } else {
1087                         int erase_gsz, erase_gmul;
1088                         erase_gsz = (mmc->csd[2] & 0x00007c00) >> 10;
1089                         erase_gmul = (mmc->csd[2] & 0x000003e0) >> 5;
1090                         mmc->erase_grp_size = (erase_gsz + 1)
1091                                 * (erase_gmul + 1);
1092                 }
1093
1094                 /* store the partition info of emmc */
1095                 if ((ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & PART_SUPPORT) ||
1096                     ext_csd[EXT_CSD_BOOT_MULT])
1097                         mmc->part_config = ext_csd[EXT_CSD_PART_CONF];
1098         }
1099
1100         if (IS_SD(mmc))
1101                 err = sd_change_freq(mmc);
1102         else
1103                 err = mmc_change_freq(mmc);
1104
1105         if (err)
1106                 return err;
1107
1108         /* Restrict card's capabilities by what the host can do */
1109         mmc->card_caps &= mmc->host_caps;
1110
1111         if (IS_SD(mmc)) {
1112                 if (mmc->card_caps & MMC_MODE_4BIT) {
1113                         cmd.cmdidx = MMC_CMD_APP_CMD;
1114                         cmd.resp_type = MMC_RSP_R1;
1115                         cmd.cmdarg = mmc->rca << 16;
1116
1117                         err = mmc_send_cmd(mmc, &cmd, NULL);
1118                         if (err)
1119                                 return err;
1120
1121                         cmd.cmdidx = SD_CMD_APP_SET_BUS_WIDTH;
1122                         cmd.resp_type = MMC_RSP_R1;
1123                         cmd.cmdarg = 2;
1124                         err = mmc_send_cmd(mmc, &cmd, NULL);
1125                         if (err)
1126                                 return err;
1127
1128                         mmc_set_bus_width(mmc, 4);
1129                 }
1130
1131                 if (mmc->card_caps & MMC_MODE_HS)
1132                         mmc->tran_speed = 50000000;
1133                 else
1134                         mmc->tran_speed = 25000000;
1135         } else {
1136                 int idx;
1137
1138                 /* An array of possible bus widths in order of preference */
1139                 static unsigned ext_csd_bits[] = {
1140                         EXT_CSD_BUS_WIDTH_8,
1141                         EXT_CSD_BUS_WIDTH_4,
1142                         EXT_CSD_BUS_WIDTH_1,
1143                 };
1144
1145                 /* An array to map CSD bus widths to host cap bits */
1146                 static unsigned ext_to_hostcaps[] = {
1147                         [EXT_CSD_BUS_WIDTH_4] = MMC_MODE_4BIT,
1148                         [EXT_CSD_BUS_WIDTH_8] = MMC_MODE_8BIT,
1149                 };
1150
1151                 /* An array to map chosen bus width to an integer */
1152                 static unsigned widths[] = {
1153                         8, 4, 1,
1154                 };
1155
1156                 for (idx=0; idx < ARRAY_SIZE(ext_csd_bits); idx++) {
1157                         unsigned int extw = ext_csd_bits[idx];
1158
1159                         /*
1160                          * Check to make sure the controller supports
1161                          * this bus width, if it's more than 1
1162                          */
1163                         if (extw != EXT_CSD_BUS_WIDTH_1 &&
1164                                         !(mmc->host_caps & ext_to_hostcaps[extw]))
1165                                 continue;
1166
1167                         err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1168                                         EXT_CSD_BUS_WIDTH, extw);
1169
1170                         if (err)
1171                                 continue;
1172
1173                         mmc_set_bus_width(mmc, widths[idx]);
1174
1175                         err = mmc_send_ext_csd(mmc, test_csd);
1176                         if (!err && ext_csd[EXT_CSD_PARTITIONING_SUPPORT] \
1177                                     == test_csd[EXT_CSD_PARTITIONING_SUPPORT]
1178                                  && ext_csd[EXT_CSD_ERASE_GROUP_DEF] \
1179                                     == test_csd[EXT_CSD_ERASE_GROUP_DEF] \
1180                                  && ext_csd[EXT_CSD_REV] \
1181                                     == test_csd[EXT_CSD_REV]
1182                                  && ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] \
1183                                     == test_csd[EXT_CSD_HC_ERASE_GRP_SIZE]
1184                                  && memcmp(&ext_csd[EXT_CSD_SEC_CNT], \
1185                                         &test_csd[EXT_CSD_SEC_CNT], 4) == 0) {
1186
1187                                 mmc->card_caps |= ext_to_hostcaps[extw];
1188                                 break;
1189                         }
1190                 }
1191
1192                 if (mmc->card_caps & MMC_MODE_HS) {
1193                         if (mmc->card_caps & MMC_MODE_HS_52MHz)
1194                                 mmc->tran_speed = 52000000;
1195                         else
1196                                 mmc->tran_speed = 26000000;
1197                 }
1198         }
1199
1200         mmc_set_clock(mmc, mmc->tran_speed);
1201
1202         /* fill in device description */
1203         mmc->block_dev.lun = 0;
1204         mmc->block_dev.type = 0;
1205         mmc->block_dev.blksz = mmc->read_bl_len;
1206         mmc->block_dev.lba = lldiv(mmc->capacity, mmc->read_bl_len);
1207         sprintf(mmc->block_dev.vendor, "Man %06x Snr %04x%04x",
1208                 mmc->cid[0] >> 24, (mmc->cid[2] & 0xffff),
1209                 (mmc->cid[3] >> 16) & 0xffff);
1210         sprintf(mmc->block_dev.product, "%c%c%c%c%c%c", mmc->cid[0] & 0xff,
1211                 (mmc->cid[1] >> 24), (mmc->cid[1] >> 16) & 0xff,
1212                 (mmc->cid[1] >> 8) & 0xff, mmc->cid[1] & 0xff,
1213                 (mmc->cid[2] >> 24) & 0xff);
1214         sprintf(mmc->block_dev.revision, "%d.%d", (mmc->cid[2] >> 20) & 0xf,
1215                 (mmc->cid[2] >> 16) & 0xf);
1216 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBDISK_SUPPORT)
1217         init_part(&mmc->block_dev);
1218 #endif
1219
1220         return 0;
1221 }
1222
1223 static int mmc_send_if_cond(struct mmc *mmc)
1224 {
1225         struct mmc_cmd cmd;
1226         int err;
1227
1228         cmd.cmdidx = SD_CMD_SEND_IF_COND;
1229         /* We set the bit if the host supports voltages between 2.7 and 3.6 V */
1230         cmd.cmdarg = ((mmc->voltages & 0xff8000) != 0) << 8 | 0xaa;
1231         cmd.resp_type = MMC_RSP_R7;
1232
1233         err = mmc_send_cmd(mmc, &cmd, NULL);
1234
1235         if (err)
1236                 return err;
1237
1238         if ((cmd.response[0] & 0xff) != 0xaa)
1239                 return UNUSABLE_ERR;
1240         else
1241                 mmc->version = SD_VERSION_2;
1242
1243         return 0;
1244 }
1245
1246 int mmc_register(struct mmc *mmc)
1247 {
1248         /* Setup the universal parts of the block interface just once */
1249         mmc->block_dev.if_type = IF_TYPE_MMC;
1250         mmc->block_dev.dev = cur_dev_num++;
1251         mmc->block_dev.removable = 1;
1252         mmc->block_dev.block_read = mmc_bread;
1253         mmc->block_dev.block_write = mmc_bwrite;
1254         mmc->block_dev.block_erase = mmc_berase;
1255         if (!mmc->b_max)
1256                 mmc->b_max = CONFIG_SYS_MMC_MAX_BLK_COUNT;
1257
1258         INIT_LIST_HEAD (&mmc->link);
1259
1260         list_add_tail (&mmc->link, &mmc_devices);
1261
1262         return 0;
1263 }
1264
1265 #ifdef CONFIG_PARTITIONS
1266 block_dev_desc_t *mmc_get_dev(int dev)
1267 {
1268         struct mmc *mmc = find_mmc_device(dev);
1269         if (!mmc || mmc_init(mmc))
1270                 return NULL;
1271
1272         return &mmc->block_dev;
1273 }
1274 #endif
1275
1276 int mmc_init(struct mmc *mmc)
1277 {
1278         int err;
1279
1280         if (mmc_getcd(mmc) == 0) {
1281                 mmc->has_init = 0;
1282                 printf("MMC: no card present\n");
1283                 return NO_CARD_ERR;
1284         }
1285
1286         if (mmc->has_init)
1287                 return 0;
1288
1289         err = mmc->init(mmc);
1290
1291         if (err)
1292                 return err;
1293
1294         mmc_set_bus_width(mmc, 1);
1295         mmc_set_clock(mmc, 1);
1296
1297         /* Reset the Card */
1298         err = mmc_go_idle(mmc);
1299
1300         if (err)
1301                 return err;
1302
1303         /* The internal partition reset to user partition(0) at every CMD0*/
1304         mmc->part_num = 0;
1305
1306         /* Test for SD version 2 */
1307         err = mmc_send_if_cond(mmc);
1308
1309         /* Now try to get the SD card's operating condition */
1310         err = sd_send_op_cond(mmc);
1311
1312         /* If the command timed out, we check for an MMC card */
1313         if (err == TIMEOUT) {
1314                 err = mmc_send_op_cond(mmc);
1315
1316                 if (err) {
1317                         printf("Card did not respond to voltage select!\n");
1318                         return UNUSABLE_ERR;
1319                 }
1320         }
1321
1322         err = mmc_startup(mmc);
1323         if (err)
1324                 mmc->has_init = 0;
1325         else
1326                 mmc->has_init = 1;
1327         return err;
1328 }
1329
1330 /*
1331  * CPU and board-specific MMC initializations.  Aliased function
1332  * signals caller to move on
1333  */
1334 static int __def_mmc_init(bd_t *bis)
1335 {
1336         return -1;
1337 }
1338
1339 int cpu_mmc_init(bd_t *bis) __attribute__((weak, alias("__def_mmc_init")));
1340 int board_mmc_init(bd_t *bis) __attribute__((weak, alias("__def_mmc_init")));
1341
1342 void print_mmc_devices(char separator)
1343 {
1344         struct mmc *m;
1345         struct list_head *entry;
1346
1347         list_for_each(entry, &mmc_devices) {
1348                 m = list_entry(entry, struct mmc, link);
1349
1350                 printf("%s: %d", m->name, m->block_dev.dev);
1351
1352                 if (entry->next != &mmc_devices)
1353                         printf("%c ", separator);
1354         }
1355
1356         printf("\n");
1357 }
1358
1359 int get_mmc_num(void)
1360 {
1361         return cur_dev_num;
1362 }
1363
1364 int mmc_initialize(bd_t *bis)
1365 {
1366         INIT_LIST_HEAD (&mmc_devices);
1367         cur_dev_num = 0;
1368
1369         if (board_mmc_init(bis) < 0)
1370                 cpu_mmc_init(bis);
1371
1372         print_mmc_devices(',');
1373
1374         return 0;
1375 }