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 <mmc.h>
  34 #include <div64.h>
  35
  36 static struct list_head mmc_devices;
  37 static int cur_dev_num = -1;
  38
  39 int mmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data)
  40 {
  41         return mmc->send_cmd(mmc, cmd, data);
  42 }
  43
  44 int mmc_set_blocklen(struct mmc *mmc, int len)
  45 {
  46         struct mmc_cmd cmd;
  47
  48         cmd.cmdidx = MMC_CMD_SET_BLOCKLEN;
  49         cmd.resp_type = MMC_RSP_R1;
  50         cmd.cmdarg = len;
  51         cmd.flags = 0;
  52
  53         return mmc_send_cmd(mmc, &cmd, NULL);
  54 }
  55
  56 struct mmc *find_mmc_device(int dev_num)
  57 {
  58         struct mmc *m;
  59         struct list_head *entry;
  60
  61         list_for_each(entry, &mmc_devices) {
  62                 m = list_entry(entry, struct mmc, link);
  63
  64                 if (m->block_dev.dev == dev_num)
  65                         return m;
  66         }
  67
  68         printf("MMC Device %d not found\n", dev_num);
  69
  70         return NULL;
  71 }
  72
  73 static ulong
  74 mmc_bwrite(int dev_num, ulong start, lbaint_t blkcnt, const void*src)
  75 {
  76         struct mmc_cmd cmd;
  77         struct mmc_data data;
  78         int err;
  79         int stoperr = 0;
  80         struct mmc *mmc = find_mmc_device(dev_num);
  81         int blklen;
  82
  83         if (!mmc)
  84                 return -1;
  85
  86         blklen = mmc->write_bl_len;
  87
  88         err = mmc_set_blocklen(mmc, mmc->write_bl_len);
  89
  90         if (err) {
  91                 printf("set write bl len failed\n\r");
  92                 return err;
  93         }
  94
  95         if (blkcnt > 1)
  96                 cmd.cmdidx = MMC_CMD_WRITE_MULTIPLE_BLOCK;
  97         else
  98                 cmd.cmdidx = MMC_CMD_WRITE_SINGLE_BLOCK;
  99
 100         if (mmc->high_capacity)
 101                 cmd.cmdarg = start;
 102         else
 103                 cmd.cmdarg = start * blklen;
 104
 105         cmd.resp_type = MMC_RSP_R1;
 106         cmd.flags = 0;
 107
 108         data.src = src;
 109         data.blocks = blkcnt;
 110         data.blocksize = blklen;
 111         data.flags = MMC_DATA_WRITE;
 112
 113         err = mmc_send_cmd(mmc, &cmd, &data);
 114
 115         if (err) {
 116                 printf("mmc write failed\n\r");
 117                 return err;
 118         }
 119
 120         if (blkcnt > 1) {
 121                 cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION;
 122                 cmd.cmdarg = 0;
 123                 cmd.resp_type = MMC_RSP_R1b;
 124                 cmd.flags = 0;
 125                 stoperr = mmc_send_cmd(mmc, &cmd, NULL);
 126         }
 127
 128         return blkcnt;
 129 }
 130
 131 int mmc_read_block(struct mmc *mmc, void *dst, uint blocknum)
 132 {
 133         struct mmc_cmd cmd;
 134         struct mmc_data data;
 135
 136         cmd.cmdidx = MMC_CMD_READ_SINGLE_BLOCK;
 137
 138         if (mmc->high_capacity)
 139                 cmd.cmdarg = blocknum;
 140         else
 141                 cmd.cmdarg = blocknum * mmc->read_bl_len;
 142
 143         cmd.resp_type = MMC_RSP_R1;
 144         cmd.flags = 0;
 145
 146         data.dest = dst;
 147         data.blocks = 1;
 148         data.blocksize = mmc->read_bl_len;
 149         data.flags = MMC_DATA_READ;
 150
 151         return mmc_send_cmd(mmc, &cmd, &data);
 152 }
 153
 154 int mmc_read(struct mmc *mmc, u64 src, uchar *dst, int size)
 155 {
 156         char *buffer;
 157         int i;
 158         int blklen = mmc->read_bl_len;
 159         int startblock = lldiv(src, mmc->read_bl_len);
 160         int endblock = lldiv(src + size - 1, mmc->read_bl_len);
 161         int err = 0;
 162
 163         /* Make a buffer big enough to hold all the blocks we might read */
 164         buffer = malloc(blklen);
 165
 166         if (!buffer) {
 167                 printf("Could not allocate buffer for MMC read!\n");
 168                 return -1;
 169         }
 170
 171         /* We always do full block reads from the card */
 172         err = mmc_set_blocklen(mmc, mmc->read_bl_len);
 173
 174         if (err)
 175                 return err;
 176
 177         for (i = startblock; i <= endblock; i++) {
 178                 int segment_size;
 179                 int offset;
 180
 181                 err = mmc_read_block(mmc, buffer, i);
 182
 183                 if (err)
 184                         goto free_buffer;
 185
 186                 /*
 187                  * The first block may not be aligned, so we
 188                  * copy from the desired point in the block
 189                  */
 190                 offset = (src & (blklen - 1));
 191                 segment_size = MIN(blklen - offset, size);
 192
 193                 memcpy(dst, buffer + offset, segment_size);
 194
 195                 dst += segment_size;
 196                 src += segment_size;
 197                 size -= segment_size;
 198         }
 199
 200 free_buffer:
 201         free(buffer);
 202
 203         return err;
 204 }
 205
 206 static ulong mmc_bread(int dev_num, ulong start, lbaint_t blkcnt, void *dst)
 207 {
 208         int err;
 209         int i;
 210         struct mmc *mmc = find_mmc_device(dev_num);
 211
 212         if (!mmc)
 213                 return 0;
 214
 215         /* We always do full block reads from the card */
 216         err = mmc_set_blocklen(mmc, mmc->read_bl_len);
 217
 218         if (err) {
 219                 return 0;
 220         }
 221
 222         for (i = start; i < start + blkcnt; i++, dst += mmc->read_bl_len) {
 223                 err = mmc_read_block(mmc, dst, i);
 224
 225                 if (err) {
 226                         printf("block read failed: %d\n", err);
 227                         return i - start;
 228                 }
 229         }
 230
 231         return blkcnt;
 232 }
 233
 234 int mmc_go_idle(struct mmc* mmc)
 235 {
 236         struct mmc_cmd cmd;
 237         int err;
 238
 239         udelay(1000);
 240
 241         cmd.cmdidx = MMC_CMD_GO_IDLE_STATE;
 242         cmd.cmdarg = 0;
 243         cmd.resp_type = MMC_RSP_NONE;
 244         cmd.flags = 0;
 245
 246         err = mmc_send_cmd(mmc, &cmd, NULL);
 247
 248         if (err)
 249                 return err;
 250
 251         udelay(2000);
 252
 253         return 0;
 254 }
 255
 256 int
 257 sd_send_op_cond(struct mmc *mmc)
 258 {
 259         int timeout = 1000;
 260         int err;
 261         struct mmc_cmd cmd;
 262
 263         do {
 264                 cmd.cmdidx = MMC_CMD_APP_CMD;
 265                 cmd.resp_type = MMC_RSP_R1;
 266                 cmd.cmdarg = 0;
 267                 cmd.flags = 0;
 268
 269                 err = mmc_send_cmd(mmc, &cmd, NULL);
 270
 271                 if (err)
 272                         return err;
 273
 274                 cmd.cmdidx = SD_CMD_APP_SEND_OP_COND;
 275                 cmd.resp_type = MMC_RSP_R3;
 276                 cmd.cmdarg = mmc->voltages;
 277
 278                 if (mmc->version == SD_VERSION_2)
 279                         cmd.cmdarg |= OCR_HCS;
 280
 281                 err = mmc_send_cmd(mmc, &cmd, NULL);
 282
 283                 if (err)
 284                         return err;
 285
 286                 udelay(1000);
 287         } while ((!(cmd.response[0] & OCR_BUSY)) && timeout--);
 288
 289         if (timeout <= 0)
 290                 return UNUSABLE_ERR;
 291
 292         if (mmc->version != SD_VERSION_2)
 293                 mmc->version = SD_VERSION_1_0;
 294
 295         mmc->ocr = cmd.response[0];
 296
 297         mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS);
 298         mmc->rca = 0;
 299
 300         return 0;
 301 }
 302
 303 int mmc_send_op_cond(struct mmc *mmc)
 304 {
 305         int timeout = 1000;
 306         struct mmc_cmd cmd;
 307         int err;
 308
 309         /* Some cards seem to need this */
 310         mmc_go_idle(mmc);
 311
 312         do {
 313                 cmd.cmdidx = MMC_CMD_SEND_OP_COND;
 314                 cmd.resp_type = MMC_RSP_R3;
 315                 cmd.cmdarg = OCR_HCS | mmc->voltages;
 316                 cmd.flags = 0;
 317
 318                 err = mmc_send_cmd(mmc, &cmd, NULL);
 319
 320                 if (err)
 321                         return err;
 322
 323                 udelay(1000);
 324         } while (!(cmd.response[0] & OCR_BUSY) && timeout--);
 325
 326         if (timeout <= 0)
 327                 return UNUSABLE_ERR;
 328
 329         mmc->version = MMC_VERSION_UNKNOWN;
 330         mmc->ocr = cmd.response[0];
 331
 332         mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS);
 333         mmc->rca = 0;
 334
 335         return 0;
 336 }
 337
 338
 339 int mmc_send_ext_csd(struct mmc *mmc, char *ext_csd)
 340 {
 341         struct mmc_cmd cmd;
 342         struct mmc_data data;
 343         int err;
 344
 345         /* Get the Card Status Register */
 346         cmd.cmdidx = MMC_CMD_SEND_EXT_CSD;
 347         cmd.resp_type = MMC_RSP_R1;
 348         cmd.cmdarg = 0;
 349         cmd.flags = 0;
 350
 351         data.dest = ext_csd;
 352         data.blocks = 1;
 353         data.blocksize = 512;
 354         data.flags = MMC_DATA_READ;
 355
 356         err = mmc_send_cmd(mmc, &cmd, &data);
 357
 358         return err;
 359 }
 360
 361
 362 int mmc_switch(struct mmc *mmc, u8 set, u8 index, u8 value)
 363 {
 364         struct mmc_cmd cmd;
 365
 366         cmd.cmdidx = MMC_CMD_SWITCH;
 367         cmd.resp_type = MMC_RSP_R1b;
 368         cmd.cmdarg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) |
 369                 (index << 16) |
 370                 (value << 8);
 371         cmd.flags = 0;
 372
 373         return mmc_send_cmd(mmc, &cmd, NULL);
 374 }
 375
 376 int mmc_change_freq(struct mmc *mmc)
 377 {
 378         char ext_csd[512];
 379         char cardtype;
 380         int err;
 381
 382         mmc->card_caps = 0;
 383
 384         /* Only version 4 supports high-speed */
 385         if (mmc->version < MMC_VERSION_4)
 386                 return 0;
 387
 388         mmc->card_caps |= MMC_MODE_4BIT;
 389
 390         err = mmc_send_ext_csd(mmc, ext_csd);
 391
 392         if (err)
 393                 return err;
 394
 395         if (ext_csd[212] || ext_csd[213] || ext_csd[214] || ext_csd[215])
 396                 mmc->high_capacity = 1;
 397
 398         if (mmc->high_capacity)
 399                 mmc->capacity = (((ext_csd[215] << 24) | (ext_csd[214] << 16) |
 400                         (ext_csd[213] << 8) | (ext_csd[21])) / (2 * 1024));
 401
 402         cardtype = ext_csd[196] & 0xf;
 403
 404         err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING, 1);
 405
 406         if (err)
 407                 return err;
 408
 409         /* Now check to see that it worked */
 410         err = mmc_send_ext_csd(mmc, ext_csd);
 411
 412         if (err)
 413                 return err;
 414
 415         /* No high-speed support */
 416         if (!ext_csd[185])
 417                 return 0;
 418
 419         /* High Speed is set, there are two types: 52MHz and 26MHz */
 420         if (cardtype & MMC_HS_52MHZ)
 421                 mmc->card_caps |= MMC_MODE_HS_52MHz | MMC_MODE_HS;
 422         else
 423                 mmc->card_caps |= MMC_MODE_HS;
 424
 425         return 0;
 426 }
 427
 428 int sd_switch(struct mmc *mmc, int mode, int group, u8 value, u8 *resp)
 429 {
 430         struct mmc_cmd cmd;
 431         struct mmc_data data;
 432
 433         /* Switch the frequency */
 434         cmd.cmdidx = SD_CMD_SWITCH_FUNC;
 435         cmd.resp_type = MMC_RSP_R1;
 436         cmd.cmdarg = (mode << 31) | 0xffffff;
 437         cmd.cmdarg &= ~(0xf << (group * 4));
 438         cmd.cmdarg |= value << (group * 4);
 439         cmd.flags = 0;
 440
 441         data.dest = (char *)resp;
 442         data.blocksize = 64;
 443         data.blocks = 1;
 444         data.flags = MMC_DATA_READ;
 445
 446         return mmc_send_cmd(mmc, &cmd, &data);
 447 }
 448
 449
 450 int sd_change_freq(struct mmc *mmc)
 451 {
 452         int err;
 453         struct mmc_cmd cmd;
 454         uint scr[2];
 455         uint switch_status[16];
 456         struct mmc_data data;
 457         int timeout;
 458
 459         mmc->card_caps = 0;
 460
 461         /* Read the SCR to find out if this card supports higher speeds */
 462         cmd.cmdidx = MMC_CMD_APP_CMD;
 463         cmd.resp_type = MMC_RSP_R1;
 464         cmd.cmdarg = mmc->rca << 16;
 465         cmd.flags = 0;
 466
 467         err = mmc_send_cmd(mmc, &cmd, NULL);
 468
 469         if (err)
 470                 return err;
 471
 472         cmd.cmdidx = SD_CMD_APP_SEND_SCR;
 473         cmd.resp_type = MMC_RSP_R1;
 474         cmd.cmdarg = 0;
 475         cmd.flags = 0;
 476
 477         timeout = 3;
 478
 479 retry_scr:
 480         data.dest = (char *)&scr;
 481         data.blocksize = 8;
 482         data.blocks = 1;
 483         data.flags = MMC_DATA_READ;
 484
 485         err = mmc_send_cmd(mmc, &cmd, &data);
 486
 487         if (err) {
 488                 if (timeout--)
 489                         goto retry_scr;
 490
 491                 return err;
 492         }
 493
 494         mmc->scr[0] = __be32_to_cpu(scr[0]);
 495         mmc->scr[1] = __be32_to_cpu(scr[1]);
 496
 497         switch ((mmc->scr[0] >> 24) & 0xf) {
 498                 case 0:
 499                         mmc->version = SD_VERSION_1_0;
 500                         break;
 501                 case 1:
 502                         mmc->version = SD_VERSION_1_10;
 503                         break;
 504                 case 2:
 505                         mmc->version = SD_VERSION_2;
 506                         break;
 507                 default:
 508                         mmc->version = SD_VERSION_1_0;
 509                         break;
 510         }
 511
 512         /* Version 1.0 doesn't support switching */
 513         if (mmc->version == SD_VERSION_1_0)
 514                 return 0;
 515
 516         timeout = 4;
 517         while (timeout--) {
 518                 err = sd_switch(mmc, SD_SWITCH_CHECK, 0, 1,
 519                                 (u8 *)&switch_status);
 520
 521                 if (err)
 522                         return err;
 523
 524                 /* The high-speed function is busy.  Try again */
 525                 if (!(__be32_to_cpu(switch_status[7]) & SD_HIGHSPEED_BUSY))
 526                         break;
 527         }
 528
 529         if (mmc->scr[0] & SD_DATA_4BIT)
 530                 mmc->card_caps |= MMC_MODE_4BIT;
 531
 532         /* If high-speed isn't supported, we return */
 533         if (!(__be32_to_cpu(switch_status[3]) & SD_HIGHSPEED_SUPPORTED))
 534                 return 0;
 535
 536         err = sd_switch(mmc, SD_SWITCH_SWITCH, 0, 1, (u8 *)&switch_status);
 537
 538         if (err)
 539                 return err;
 540
 541         if ((__be32_to_cpu(switch_status[4]) & 0x0f000000) == 0x01000000)
 542                 mmc->card_caps |= MMC_MODE_HS;
 543
 544         return 0;
 545 }
 546
 547 /* frequency bases */
 548 /* divided by 10 to be nice to platforms without floating point */
 549 int fbase[] = {
 550         10000,
 551         100000,
 552         1000000,
 553         10000000,
 554 };
 555
 556 /* Multiplier values for TRAN_SPEED.  Multiplied by 10 to be nice
 557  * to platforms without floating point.
 558  */
 559 int multipliers[] = {
 560         0,      /* reserved */
 561         10,
 562         12,
 563         13,
 564         15,
 565         20,
 566         25,
 567         30,
 568         35,
 569         40,
 570         45,
 571         50,
 572         55,
 573         60,
 574         70,
 575         80,
 576 };
 577
 578 void mmc_set_ios(struct mmc *mmc)
 579 {
 580         mmc->set_ios(mmc);
 581 }
 582
 583 void mmc_set_clock(struct mmc *mmc, uint clock)
 584 {
 585         if (clock > mmc->f_max)
 586                 clock = mmc->f_max;
 587
 588         if (clock < mmc->f_min)
 589                 clock = mmc->f_min;
 590
 591         mmc->clock = clock;
 592
 593         mmc_set_ios(mmc);
 594 }
 595
 596 void mmc_set_bus_width(struct mmc *mmc, uint width)
 597 {
 598         mmc->bus_width = width;
 599
 600         mmc_set_ios(mmc);
 601 }
 602
 603 int mmc_startup(struct mmc *mmc)
 604 {
 605         int err;
 606         uint mult, freq;
 607         u64 cmult, csize;
 608         struct mmc_cmd cmd;
 609
 610         /* Put the Card in Identify Mode */
 611         cmd.cmdidx = MMC_CMD_ALL_SEND_CID;
 612         cmd.resp_type = MMC_RSP_R2;
 613         cmd.cmdarg = 0;
 614         cmd.flags = 0;
 615
 616         err = mmc_send_cmd(mmc, &cmd, NULL);
 617
 618         if (err)
 619                 return err;
 620
 621         memcpy(mmc->cid, cmd.response, 16);
 622
 623         /*
 624          * For MMC cards, set the Relative Address.
 625          * For SD cards, get the Relatvie Address.
 626          * This also puts the cards into Standby State
 627          */
 628         cmd.cmdidx = SD_CMD_SEND_RELATIVE_ADDR;
 629         cmd.cmdarg = mmc->rca << 16;
 630         cmd.resp_type = MMC_RSP_R6;
 631         cmd.flags = 0;
 632
 633         err = mmc_send_cmd(mmc, &cmd, NULL);
 634
 635         if (err)
 636                 return err;
 637
 638         if (IS_SD(mmc))
 639                 mmc->rca = (cmd.response[0] >> 16) & 0xffff;
 640
 641         /* Get the Card-Specific Data */
 642         cmd.cmdidx = MMC_CMD_SEND_CSD;
 643         cmd.resp_type = MMC_RSP_R2;
 644         cmd.cmdarg = mmc->rca << 16;
 645         cmd.flags = 0;
 646
 647         err = mmc_send_cmd(mmc, &cmd, NULL);
 648
 649         if (err)
 650                 return err;
 651
 652         mmc->csd[0] = cmd.response[0];
 653         mmc->csd[1] = cmd.response[1];
 654         mmc->csd[2] = cmd.response[2];
 655         mmc->csd[3] = cmd.response[3];
 656
 657         if (mmc->version == MMC_VERSION_UNKNOWN) {
 658                 int version = (cmd.response[0] >> 26) & 0xf;
 659
 660                 switch (version) {
 661                         case 0:
 662                                 mmc->version = MMC_VERSION_1_2;
 663                                 break;
 664                         case 1:
 665                                 mmc->version = MMC_VERSION_1_4;
 666                                 break;
 667                         case 2:
 668                                 mmc->version = MMC_VERSION_2_2;
 669                                 break;
 670                         case 3:
 671                                 mmc->version = MMC_VERSION_3;
 672                                 break;
 673                         case 4:
 674                                 mmc->version = MMC_VERSION_4;
 675                                 break;
 676                         default:
 677                                 mmc->version = MMC_VERSION_1_2;
 678                                 break;
 679                 }
 680         }
 681
 682         /* divide frequency by 10, since the mults are 10x bigger */
 683         freq = fbase[(cmd.response[0] & 0x7)];
 684         mult = multipliers[((cmd.response[0] >> 3) & 0xf)];
 685
 686         mmc->tran_speed = freq * mult;
 687
 688         mmc->read_bl_len = 1 << ((cmd.response[1] >> 16) & 0xf);
 689
 690         if (IS_SD(mmc))
 691                 mmc->write_bl_len = mmc->read_bl_len;
 692         else
 693                 mmc->write_bl_len = 1 << ((cmd.response[3] >> 22) & 0xf);
 694
 695         if (mmc->high_capacity) {
 696                 csize = (mmc->csd[1] & 0x3f) << 16
 697                         | (mmc->csd[2] & 0xffff0000) >> 16;
 698                 cmult = 8;
 699         } else {
 700                 csize = (mmc->csd[1] & 0x3ff) << 2
 701                         | (mmc->csd[2] & 0xc0000000) >> 30;
 702                 cmult = (mmc->csd[2] & 0x00038000) >> 15;
 703         }
 704
 705         mmc->capacity = (csize + 1) << (cmult + 2);
 706         mmc->capacity *= mmc->read_bl_len;
 707
 708         if (mmc->read_bl_len > 512)
 709                 mmc->read_bl_len = 512;
 710
 711         if (mmc->write_bl_len > 512)
 712                 mmc->write_bl_len = 512;
 713
 714         /* Select the card, and put it into Transfer Mode */
 715         cmd.cmdidx = MMC_CMD_SELECT_CARD;
 716         cmd.resp_type = MMC_RSP_R1b;
 717         cmd.cmdarg = mmc->rca << 16;
 718         cmd.flags = 0;
 719         err = mmc_send_cmd(mmc, &cmd, NULL);
 720
 721         if (err)
 722                 return err;
 723
 724         if (IS_SD(mmc))
 725                 err = sd_change_freq(mmc);
 726         else
 727                 err = mmc_change_freq(mmc);
 728
 729         if (err)
 730                 return err;
 731
 732         /* Restrict card's capabilities by what the host can do */
 733         mmc->card_caps &= mmc->host_caps;
 734
 735         if (IS_SD(mmc)) {
 736                 if (mmc->card_caps & MMC_MODE_4BIT) {
 737                         cmd.cmdidx = MMC_CMD_APP_CMD;
 738                         cmd.resp_type = MMC_RSP_R1;
 739                         cmd.cmdarg = mmc->rca << 16;
 740                         cmd.flags = 0;
 741
 742                         err = mmc_send_cmd(mmc, &cmd, NULL);
 743                         if (err)
 744                                 return err;
 745
 746                         cmd.cmdidx = SD_CMD_APP_SET_BUS_WIDTH;
 747                         cmd.resp_type = MMC_RSP_R1;
 748                         cmd.cmdarg = 2;
 749                         cmd.flags = 0;
 750                         err = mmc_send_cmd(mmc, &cmd, NULL);
 751                         if (err)
 752                                 return err;
 753
 754                         mmc_set_bus_width(mmc, 4);
 755                 }
 756
 757                 if (mmc->card_caps & MMC_MODE_HS)
 758                         mmc_set_clock(mmc, 50000000);
 759                 else
 760                         mmc_set_clock(mmc, 25000000);
 761         } else {
 762                 if (mmc->card_caps & MMC_MODE_4BIT) {
 763                         /* Set the card to use 4 bit*/
 764                         err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
 765                                         EXT_CSD_BUS_WIDTH,
 766                                         EXT_CSD_BUS_WIDTH_4);
 767
 768                         if (err)
 769                                 return err;
 770
 771                         mmc_set_bus_width(mmc, 4);
 772                 } else if (mmc->card_caps & MMC_MODE_8BIT) {
 773                         /* Set the card to use 8 bit*/
 774                         err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
 775                                         EXT_CSD_BUS_WIDTH,
 776                                         EXT_CSD_BUS_WIDTH_8);
 777
 778                         if (err)
 779                                 return err;
 780
 781                         mmc_set_bus_width(mmc, 8);
 782                 }
 783
 784                 if (mmc->card_caps & MMC_MODE_HS) {
 785                         if (mmc->card_caps & MMC_MODE_HS_52MHz)
 786                                 mmc_set_clock(mmc, 52000000);
 787                         else
 788                                 mmc_set_clock(mmc, 26000000);
 789                 } else
 790                         mmc_set_clock(mmc, 20000000);
 791         }
 792
 793         /* fill in device description */
 794         mmc->block_dev.lun = 0;
 795         mmc->block_dev.type = 0;
 796         mmc->block_dev.blksz = mmc->read_bl_len;
 797         mmc->block_dev.lba = lldiv(mmc->capacity, mmc->read_bl_len);
 798         sprintf(mmc->block_dev.vendor, "Man %06x Snr %08x", mmc->cid[0] >> 8,
 799                         (mmc->cid[2] << 8) | (mmc->cid[3] >> 24));
 800         sprintf(mmc->block_dev.product, "%c%c%c%c%c", mmc->cid[0] & 0xff,
 801                         (mmc->cid[1] >> 24), (mmc->cid[1] >> 16) & 0xff,
 802                         (mmc->cid[1] >> 8) & 0xff, mmc->cid[1] & 0xff);
 803         sprintf(mmc->block_dev.revision, "%d.%d", mmc->cid[2] >> 28,
 804                         (mmc->cid[2] >> 24) & 0xf);
 805         init_part(&mmc->block_dev);
 806
 807         return 0;
 808 }
 809
 810 int mmc_send_if_cond(struct mmc *mmc)
 811 {
 812         struct mmc_cmd cmd;
 813         int err;
 814
 815         cmd.cmdidx = SD_CMD_SEND_IF_COND;
 816         /* We set the bit if the host supports voltages between 2.7 and 3.6 V */
 817         cmd.cmdarg = ((mmc->voltages & 0xff8000) != 0) << 8 | 0xaa;
 818         cmd.resp_type = MMC_RSP_R7;
 819         cmd.flags = 0;
 820
 821         err = mmc_send_cmd(mmc, &cmd, NULL);
 822
 823         if (err)
 824                 return err;
 825
 826         if ((cmd.response[0] & 0xff) != 0xaa)
 827                 return UNUSABLE_ERR;
 828         else
 829                 mmc->version = SD_VERSION_2;
 830
 831         return 0;
 832 }
 833
 834 int mmc_register(struct mmc *mmc)
 835 {
 836         /* Setup the universal parts of the block interface just once */
 837         mmc->block_dev.if_type = IF_TYPE_MMC;
 838         mmc->block_dev.dev = cur_dev_num++;
 839         mmc->block_dev.removable = 1;
 840         mmc->block_dev.block_read = mmc_bread;
 841         mmc->block_dev.block_write = mmc_bwrite;
 842
 843         INIT_LIST_HEAD (&mmc->link);
 844
 845         list_add_tail (&mmc->link, &mmc_devices);
 846
 847         return 0;
 848 }
 849
 850 block_dev_desc_t *mmc_get_dev(int dev)
 851 {
 852         struct mmc *mmc = find_mmc_device(dev);
 853
 854         return mmc ? &mmc->block_dev : NULL;
 855 }
 856
 857 int mmc_init(struct mmc *mmc)
 858 {
 859         int err;
 860
 861         err = mmc->init(mmc);
 862
 863         if (err)
 864                 return err;
 865
 866         mmc_set_bus_width(mmc, 1);
 867         mmc_set_clock(mmc, 1);
 868
 869         /* Reset the Card */
 870         err = mmc_go_idle(mmc);
 871
 872         if (err)
 873                 return err;
 874
 875         /* Test for SD version 2 */
 876         err = mmc_send_if_cond(mmc);
 877
 878         /* Now try to get the SD card's operating condition */
 879         err = sd_send_op_cond(mmc);
 880
 881         /* If the command timed out, we check for an MMC card */
 882         if (err == TIMEOUT) {
 883                 err = mmc_send_op_cond(mmc);
 884
 885                 if (err) {
 886                         printf("Card did not respond to voltage select!\n");
 887                         return UNUSABLE_ERR;
 888                 }
 889         }
 890
 891         return mmc_startup(mmc);
 892 }
 893
 894 /*
 895  * CPU and board-specific MMC initializations.  Aliased function
 896  * signals caller to move on
 897  */
 898 static int __def_mmc_init(bd_t *bis)
 899 {
 900         return -1;
 901 }
 902
 903 int cpu_mmc_init(bd_t *bis) __attribute__((weak, alias("__def_mmc_init")));
 904 int board_mmc_init(bd_t *bis) __attribute__((weak, alias("__def_mmc_init")));
 905
 906 void print_mmc_devices(char separator)
 907 {
 908         struct mmc *m;
 909         struct list_head *entry;
 910
 911         list_for_each(entry, &mmc_devices) {
 912                 m = list_entry(entry, struct mmc, link);
 913
 914                 printf("%s: %d", m->name, m->block_dev.dev);
 915
 916                 if (entry->next != &mmc_devices)
 917                         printf("%c ", separator);
 918         }
 919
 920         printf("\n");
 921 }
 922
 923 int mmc_initialize(bd_t *bis)
 924 {
 925         INIT_LIST_HEAD (&mmc_devices);
 926         cur_dev_num = 0;
 927
 928         if (board_mmc_init(bis) < 0)
 929                 cpu_mmc_init(bis);
 930
 931         print_mmc_devices(',');
 932
 933         return 0;
 934 }