drivers/mmc/mmc.c

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