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         /*  Extended CSD revision Number */
 396         mmc->ext_csd_rev = ext_csd[192];
 397
 398         if (ext_csd[212] || ext_csd[213] || ext_csd[214] || ext_csd[215])
 399                 mmc->high_capacity = 1;
 400
 401         if (mmc->high_capacity)
 402                 mmc->capacity = ((ext_csd[215] << 24) | (ext_csd[214] << 16) |
 403                         (ext_csd[213] << 8) | (ext_csd[21]));
 404
 405         cardtype = ext_csd[196] & 0xf;
 406
 407         err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING, 1);
 408
 409         if (err)
 410                 return err;
 411
 412         /* Now check to see that it worked */
 413         err = mmc_send_ext_csd(mmc, ext_csd);
 414
 415         if (err)
 416                 return err;
 417
 418         /* No high-speed support */
 419         if (!ext_csd[185])
 420                 return 0;
 421
 422         /* High Speed is set, there are two types: 52MHz and 26MHz */
 423         if (cardtype & MMC_HS_52MHZ)
 424                 mmc->card_caps |= MMC_MODE_HS_52MHz | MMC_MODE_HS;
 425         else
 426                 mmc->card_caps |= MMC_MODE_HS;
 427
 428         return 0;
 429 }
 430
 431 int sd_switch(struct mmc *mmc, int mode, int group, u8 value, u8 *resp)
 432 {
 433         struct mmc_cmd cmd;
 434         struct mmc_data data;
 435
 436         /* Switch the frequency */
 437         cmd.cmdidx = SD_CMD_SWITCH_FUNC;
 438         cmd.resp_type = MMC_RSP_R1;
 439         cmd.cmdarg = (mode << 31) | 0xffffff;
 440         cmd.cmdarg &= ~(0xf << (group * 4));
 441         cmd.cmdarg |= value << (group * 4);
 442         cmd.flags = 0;
 443
 444         data.dest = (char *)resp;
 445         data.blocksize = 64;
 446         data.blocks = 1;
 447         data.flags = MMC_DATA_READ;
 448
 449         return mmc_send_cmd(mmc, &cmd, &data);
 450 }
 451
 452
 453 int sd_change_freq(struct mmc *mmc)
 454 {
 455         int err;
 456         struct mmc_cmd cmd;
 457         uint scr[2];
 458         uint switch_status[16];
 459         struct mmc_data data;
 460         int timeout;
 461
 462         mmc->card_caps = 0;
 463
 464         /* Read the SCR to find out if this card supports higher speeds */
 465         cmd.cmdidx = MMC_CMD_APP_CMD;
 466         cmd.resp_type = MMC_RSP_R1;
 467         cmd.cmdarg = mmc->rca << 16;
 468         cmd.flags = 0;
 469
 470         err = mmc_send_cmd(mmc, &cmd, NULL);
 471
 472         if (err)
 473                 return err;
 474
 475         cmd.cmdidx = SD_CMD_APP_SEND_SCR;
 476         cmd.resp_type = MMC_RSP_R1;
 477         cmd.cmdarg = 0;
 478         cmd.flags = 0;
 479
 480         timeout = 3;
 481
 482 retry_scr:
 483         data.dest = (char *)&scr;
 484         data.blocksize = 8;
 485         data.blocks = 1;
 486         data.flags = MMC_DATA_READ;
 487
 488         err = mmc_send_cmd(mmc, &cmd, &data);
 489
 490         if (err) {
 491                 if (timeout--)
 492                         goto retry_scr;
 493
 494                 return err;
 495         }
 496
 497         mmc->scr[0] = __be32_to_cpu(scr[0]);
 498         mmc->scr[1] = __be32_to_cpu(scr[1]);
 499
 500         switch ((mmc->scr[0] >> 24) & 0xf) {
 501                 case 0:
 502                         mmc->version = SD_VERSION_1_0;
 503                         break;
 504                 case 1:
 505                         mmc->version = SD_VERSION_1_10;
 506                         break;
 507                 case 2:
 508                         mmc->version = SD_VERSION_2;
 509                         break;
 510                 default:
 511                         mmc->version = SD_VERSION_1_0;
 512                         break;
 513         }
 514
 515         /* Version 1.0 doesn't support switching */
 516         if (mmc->version == SD_VERSION_1_0)
 517                 return 0;
 518
 519         timeout = 4;
 520         while (timeout--) {
 521                 err = sd_switch(mmc, SD_SWITCH_CHECK, 0, 1,
 522                                 (u8 *)&switch_status);
 523
 524                 if (err)
 525                         return err;
 526
 527                 /* The high-speed function is busy.  Try again */
 528                 if (!(__be32_to_cpu(switch_status[7]) & SD_HIGHSPEED_BUSY))
 529                         break;
 530         }
 531
 532         if (mmc->scr[0] & SD_DATA_4BIT)
 533                 mmc->card_caps |= MMC_MODE_4BIT;
 534
 535         /* If high-speed isn't supported, we return */
 536         if (!(__be32_to_cpu(switch_status[3]) & SD_HIGHSPEED_SUPPORTED))
 537                 return 0;
 538
 539         err = sd_switch(mmc, SD_SWITCH_SWITCH, 0, 1, (u8 *)&switch_status);
 540
 541         if (err)
 542                 return err;
 543
 544         if ((__be32_to_cpu(switch_status[4]) & 0x0f000000) == 0x01000000)
 545                 mmc->card_caps |= MMC_MODE_HS;
 546
 547         return 0;
 548 }
 549
 550 /* frequency bases */
 551 /* divided by 10 to be nice to platforms without floating point */
 552 int fbase[] = {
 553         10000,
 554         100000,
 555         1000000,
 556         10000000,
 557 };
 558
 559 /* Multiplier values for TRAN_SPEED.  Multiplied by 10 to be nice
 560  * to platforms without floating point.
 561  */
 562 int multipliers[] = {
 563         0,      /* reserved */
 564         10,
 565         12,
 566         13,
 567         15,
 568         20,
 569         25,
 570         30,
 571         35,
 572         40,
 573         45,
 574         50,
 575         55,
 576         60,
 577         70,
 578         80,
 579 };
 580
 581 void mmc_set_ios(struct mmc *mmc)
 582 {
 583         mmc->set_ios(mmc);
 584 }
 585
 586 void mmc_set_clock(struct mmc *mmc, uint clock)
 587 {
 588         if (clock > mmc->f_max)
 589                 clock = mmc->f_max;
 590
 591         if (clock < mmc->f_min)
 592                 clock = mmc->f_min;
 593
 594         mmc->clock = clock;
 595
 596         mmc_set_ios(mmc);
 597 }
 598
 599 void mmc_set_bus_width(struct mmc *mmc, uint width)
 600 {
 601         mmc->bus_width = width;
 602
 603         mmc_set_ios(mmc);
 604 }
 605
 606 int mmc_startup(struct mmc *mmc)
 607 {
 608         int err;
 609         uint mult, freq;
 610         u64 cmult, csize;
 611         struct mmc_cmd cmd;
 612
 613         /* Put the Card in Identify Mode */
 614         cmd.cmdidx = MMC_CMD_ALL_SEND_CID;
 615         cmd.resp_type = MMC_RSP_R2;
 616         cmd.cmdarg = 0;
 617         cmd.flags = 0;
 618
 619         err = mmc_send_cmd(mmc, &cmd, NULL);
 620
 621         if (err)
 622                 return err;
 623
 624         memcpy(mmc->cid, cmd.response, 16);
 625
 626         /*
 627          * For MMC cards, set the Relative Address.
 628          * For SD cards, get the Relatvie Address.
 629          * This also puts the cards into Standby State
 630          */
 631         cmd.cmdidx = SD_CMD_SEND_RELATIVE_ADDR;
 632         cmd.cmdarg = mmc->rca << 16;
 633         cmd.resp_type = MMC_RSP_R6;
 634         cmd.flags = 0;
 635
 636         err = mmc_send_cmd(mmc, &cmd, NULL);
 637
 638         if (err)
 639                 return err;
 640
 641         if (IS_SD(mmc))
 642                 mmc->rca = (cmd.response[0] >> 16) & 0xffff;
 643
 644         /* Get the Card-Specific Data */
 645         cmd.cmdidx = MMC_CMD_SEND_CSD;
 646         cmd.resp_type = MMC_RSP_R2;
 647         cmd.cmdarg = mmc->rca << 16;
 648         cmd.flags = 0;
 649
 650         err = mmc_send_cmd(mmc, &cmd, NULL);
 651
 652         if (err)
 653                 return err;
 654
 655         mmc->csd[0] = cmd.response[0];
 656         mmc->csd[1] = cmd.response[1];
 657         mmc->csd[2] = cmd.response[2];
 658         mmc->csd[3] = cmd.response[3];
 659
 660         if (mmc->version == MMC_VERSION_UNKNOWN) {
 661                 int version = (mmc->csd[0] >> 26) & 0xf;
 662
 663                 switch (version) {
 664                         case 0:
 665                                 mmc->version = MMC_VERSION_1_2;
 666                                 break;
 667                         case 1:
 668                                 mmc->version = MMC_VERSION_1_4;
 669                                 break;
 670                         case 2:
 671                                 mmc->version = MMC_VERSION_2_2;
 672                                 break;
 673                         case 3:
 674                                 mmc->version = MMC_VERSION_3;
 675                                 break;
 676                         case 4:
 677                                 mmc->version = MMC_VERSION_4;
 678                                 break;
 679                         default:
 680                                 mmc->version = MMC_VERSION_1_2;
 681                                 break;
 682                 }
 683         }
 684
 685         /* divide frequency by 10, since the mults are 10x bigger */
 686         freq = fbase[(mmc->csd[0] & 0x7)];
 687         mult = multipliers[((mmc->csd[0] >> 3) & 0xf)];
 688
 689         mmc->tran_speed = freq * mult;
 690
 691         mmc->read_bl_len = 1 << ((mmc->csd[1] >> 16) & 0xf);
 692
 693         if (IS_SD(mmc))
 694                 mmc->write_bl_len = mmc->read_bl_len;
 695         else
 696                 mmc->write_bl_len = 1 << ((mmc->csd[3] >> 22) & 0xf);
 697
 698         if (mmc->high_capacity) {
 699                 csize = (mmc->csd[1] & 0x3f) << 16
 700                         | (mmc->csd[2] & 0xffff0000) >> 16;
 701                 cmult = 8;
 702         } else {
 703                 csize = (mmc->csd[1] & 0x3ff) << 2
 704                         | (mmc->csd[2] & 0xc0000000) >> 30;
 705                 cmult = (mmc->csd[2] & 0x00038000) >> 15;
 706         }
 707
 708         mmc->capacity = (csize + 1) << (cmult + 2);
 709         mmc->capacity *= mmc->read_bl_len;
 710
 711         if (mmc->read_bl_len > 512)
 712                 mmc->read_bl_len = 512;
 713
 714         if (mmc->write_bl_len > 512)
 715                 mmc->write_bl_len = 512;
 716
 717         /* Select the card, and put it into Transfer Mode */
 718         cmd.cmdidx = MMC_CMD_SELECT_CARD;
 719         cmd.resp_type = MMC_RSP_R1b;
 720         cmd.cmdarg = mmc->rca << 16;
 721         cmd.flags = 0;
 722         err = mmc_send_cmd(mmc, &cmd, NULL);
 723
 724         if (err)
 725                 return err;
 726
 727         if (IS_SD(mmc))
 728                 err = sd_change_freq(mmc);
 729         else
 730                 err = mmc_change_freq(mmc);
 731
 732         if (err)
 733                 return err;
 734
 735         /* Restrict card's capabilities by what the host can do */
 736         mmc->card_caps &= mmc->host_caps;
 737
 738         if (IS_SD(mmc)) {
 739                 if (mmc->card_caps & MMC_MODE_4BIT) {
 740                         cmd.cmdidx = MMC_CMD_APP_CMD;
 741                         cmd.resp_type = MMC_RSP_R1;
 742                         cmd.cmdarg = mmc->rca << 16;
 743                         cmd.flags = 0;
 744
 745                         err = mmc_send_cmd(mmc, &cmd, NULL);
 746                         if (err)
 747                                 return err;
 748
 749                         cmd.cmdidx = SD_CMD_APP_SET_BUS_WIDTH;
 750                         cmd.resp_type = MMC_RSP_R1;
 751                         cmd.cmdarg = 2;
 752                         cmd.flags = 0;
 753                         err = mmc_send_cmd(mmc, &cmd, NULL);
 754                         if (err)
 755                                 return err;
 756
 757                         mmc_set_bus_width(mmc, 4);
 758                 }
 759
 760                 if (mmc->card_caps & MMC_MODE_HS)
 761                         mmc_set_clock(mmc, 50000000);
 762                 else
 763                         mmc_set_clock(mmc, 25000000);
 764         } else {
 765                 if (mmc->card_caps & MMC_MODE_4BIT) {
 766                         /* Set the card to use 4 bit*/
 767                         err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
 768                                         EXT_CSD_BUS_WIDTH,
 769                                         EXT_CSD_BUS_WIDTH_4);
 770
 771                         if (err)
 772                                 return err;
 773
 774                         mmc_set_bus_width(mmc, 4);
 775                 } else if (mmc->card_caps & MMC_MODE_8BIT) {
 776                         /* Set the card to use 8 bit*/
 777                         err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
 778                                         EXT_CSD_BUS_WIDTH,
 779                                         EXT_CSD_BUS_WIDTH_8);
 780
 781                         if (err)
 782                                 return err;
 783
 784                         mmc_set_bus_width(mmc, 8);
 785                 }
 786
 787                 if (mmc->card_caps & MMC_MODE_HS) {
 788                         if (mmc->card_caps & MMC_MODE_HS_52MHz)
 789                                 mmc->tran_speed = 52000000;
 790                          else
 791                                 mmc->tran_speed = 26000000;
 792                 }
 793
 794                 mmc_set_clock(mmc, mmc->tran_speed);
 795         }
 796
 797         /* fill in device description */
 798         mmc->block_dev.lun = 0;
 799         mmc->block_dev.type = 0;
 800         mmc->block_dev.blksz = mmc->read_bl_len;
 801         mmc->block_dev.lba = lldiv(mmc->capacity, mmc->read_bl_len);
 802         sprintf(mmc->block_dev.vendor, "Man %06x Snr %08x", mmc->cid[0] >> 8,
 803                         (mmc->cid[2] << 8) | (mmc->cid[3] >> 24));
 804         sprintf(mmc->block_dev.product, "%c%c%c%c%c", mmc->cid[0] & 0xff,
 805                         (mmc->cid[1] >> 24), (mmc->cid[1] >> 16) & 0xff,
 806                         (mmc->cid[1] >> 8) & 0xff, mmc->cid[1] & 0xff);
 807         sprintf(mmc->block_dev.revision, "%d.%d", mmc->cid[2] >> 28,
 808                         (mmc->cid[2] >> 24) & 0xf);
 809         init_part(&mmc->block_dev);
 810
 811         return 0;
 812 }
 813
 814 int mmc_send_if_cond(struct mmc *mmc)
 815 {
 816         struct mmc_cmd cmd;
 817         int err;
 818
 819         cmd.cmdidx = SD_CMD_SEND_IF_COND;
 820         /* We set the bit if the host supports voltages between 2.7 and 3.6 V */
 821         cmd.cmdarg = ((mmc->voltages & 0xff8000) != 0) << 8 | 0xaa;
 822         cmd.resp_type = MMC_RSP_R7;
 823         cmd.flags = 0;
 824
 825         err = mmc_send_cmd(mmc, &cmd, NULL);
 826
 827         if (err)
 828                 return err;
 829
 830         if ((cmd.response[0] & 0xff) != 0xaa)
 831                 return UNUSABLE_ERR;
 832         else
 833                 mmc->version = SD_VERSION_2;
 834
 835         return 0;
 836 }
 837
 838 int mmc_register(struct mmc *mmc)
 839 {
 840         /* Setup the universal parts of the block interface just once */
 841         mmc->block_dev.if_type = IF_TYPE_MMC;
 842         mmc->block_dev.dev = cur_dev_num++;
 843         mmc->block_dev.removable = 1;
 844         mmc->block_dev.block_read = mmc_bread;
 845         mmc->block_dev.block_write = mmc_bwrite;
 846
 847         INIT_LIST_HEAD (&mmc->link);
 848
 849         list_add_tail (&mmc->link, &mmc_devices);
 850
 851         return 0;
 852 }
 853
 854 block_dev_desc_t *mmc_get_dev(int dev)
 855 {
 856         struct mmc *mmc = find_mmc_device(dev);
 857
 858         return mmc ? &mmc->block_dev : NULL;
 859 }
 860
 861 int mmc_init(struct mmc *mmc)
 862 {
 863         int err;
 864
 865         err = mmc->init(mmc);
 866
 867         if (err)
 868                 return err;
 869
 870         mmc_set_bus_width(mmc, 1);
 871         mmc_set_clock(mmc, 1);
 872
 873         /* Reset the Card */
 874         err = mmc_go_idle(mmc);
 875
 876         if (err)
 877                 return err;
 878
 879         /* Test for SD version 2 */
 880         err = mmc_send_if_cond(mmc);
 881
 882         /* Now try to get the SD card's operating condition */
 883         err = sd_send_op_cond(mmc);
 884
 885         /* If the command timed out, we check for an MMC card */
 886         if (err == TIMEOUT) {
 887                 err = mmc_send_op_cond(mmc);
 888
 889                 if (err) {
 890                         printf("Card did not respond to voltage select!\n");
 891                         return UNUSABLE_ERR;
 892                 }
 893         }
 894
 895         return mmc_startup(mmc);
 896 }
 897
 898 /*
 899  * CPU and board-specific MMC initializations.  Aliased function
 900  * signals caller to move on
 901  */
 902 static int __def_mmc_init(bd_t *bis)
 903 {
 904         return -1;
 905 }
 906
 907 int cpu_mmc_init(bd_t *bis) __attribute__((weak, alias("__def_mmc_init")));
 908 int board_mmc_init(bd_t *bis) __attribute__((weak, alias("__def_mmc_init")));
 909
 910 void print_mmc_devices(char separator)
 911 {
 912         struct mmc *m;
 913         struct list_head *entry;
 914
 915         list_for_each(entry, &mmc_devices) {
 916                 m = list_entry(entry, struct mmc, link);
 917
 918                 printf("%s: %d", m->name, m->block_dev.dev);
 919
 920                 if (entry->next != &mmc_devices)
 921                         printf("%c ", separator);
 922         }
 923
 924         printf("\n");
 925 }
 926
 927 int mmc_initialize(bd_t *bis)
 928 {
 929         INIT_LIST_HEAD (&mmc_devices);
 930         cur_dev_num = 0;
 931
 932         if (board_mmc_init(bis) < 0)
 933                 cpu_mmc_init(bis);
 934
 935         print_mmc_devices(',');
 936
 937         return 0;
 938 }