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