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
 277                 /*
 278                  * Most cards do not answer if some reserved bits
 279                  * in the ocr are set. However, Some controller
 280                  * can set bit 7 (reserved for low voltages), but
 281                  * how to manage low voltages SD card is not yet
 282                  * specified.
 283                  */
 284                 cmd.cmdarg = mmc->voltages & 0xff8000;
 285
 286                 if (mmc->version == SD_VERSION_2)
 287                         cmd.cmdarg |= OCR_HCS;
 288
 289                 err = mmc_send_cmd(mmc, &cmd, NULL);
 290
 291                 if (err)
 292                         return err;
 293
 294                 udelay(1000);
 295         } while ((!(cmd.response[0] & OCR_BUSY)) && timeout--);
 296
 297         if (timeout <= 0)
 298                 return UNUSABLE_ERR;
 299
 300         if (mmc->version != SD_VERSION_2)
 301                 mmc->version = SD_VERSION_1_0;
 302
 303         mmc->ocr = cmd.response[0];
 304
 305         mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS);
 306         mmc->rca = 0;
 307
 308         return 0;
 309 }
 310
 311 int mmc_send_op_cond(struct mmc *mmc)
 312 {
 313         int timeout = 1000;
 314         struct mmc_cmd cmd;
 315         int err;
 316
 317         /* Some cards seem to need this */
 318         mmc_go_idle(mmc);
 319
 320         do {
 321                 cmd.cmdidx = MMC_CMD_SEND_OP_COND;
 322                 cmd.resp_type = MMC_RSP_R3;
 323                 cmd.cmdarg = OCR_HCS | mmc->voltages;
 324                 cmd.flags = 0;
 325
 326                 err = mmc_send_cmd(mmc, &cmd, NULL);
 327
 328                 if (err)
 329                         return err;
 330
 331                 udelay(1000);
 332         } while (!(cmd.response[0] & OCR_BUSY) && timeout--);
 333
 334         if (timeout <= 0)
 335                 return UNUSABLE_ERR;
 336
 337         mmc->version = MMC_VERSION_UNKNOWN;
 338         mmc->ocr = cmd.response[0];
 339
 340         mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS);
 341         mmc->rca = 0;
 342
 343         return 0;
 344 }
 345
 346
 347 int mmc_send_ext_csd(struct mmc *mmc, char *ext_csd)
 348 {
 349         struct mmc_cmd cmd;
 350         struct mmc_data data;
 351         int err;
 352
 353         /* Get the Card Status Register */
 354         cmd.cmdidx = MMC_CMD_SEND_EXT_CSD;
 355         cmd.resp_type = MMC_RSP_R1;
 356         cmd.cmdarg = 0;
 357         cmd.flags = 0;
 358
 359         data.dest = ext_csd;
 360         data.blocks = 1;
 361         data.blocksize = 512;
 362         data.flags = MMC_DATA_READ;
 363
 364         err = mmc_send_cmd(mmc, &cmd, &data);
 365
 366         return err;
 367 }
 368
 369
 370 int mmc_switch(struct mmc *mmc, u8 set, u8 index, u8 value)
 371 {
 372         struct mmc_cmd cmd;
 373
 374         cmd.cmdidx = MMC_CMD_SWITCH;
 375         cmd.resp_type = MMC_RSP_R1b;
 376         cmd.cmdarg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) |
 377                 (index << 16) |
 378                 (value << 8);
 379         cmd.flags = 0;
 380
 381         return mmc_send_cmd(mmc, &cmd, NULL);
 382 }
 383
 384 int mmc_change_freq(struct mmc *mmc)
 385 {
 386         char ext_csd[512];
 387         char cardtype;
 388         int err;
 389
 390         mmc->card_caps = 0;
 391
 392         /* Only version 4 supports high-speed */
 393         if (mmc->version < MMC_VERSION_4)
 394                 return 0;
 395
 396         mmc->card_caps |= MMC_MODE_4BIT;
 397
 398         err = mmc_send_ext_csd(mmc, ext_csd);
 399
 400         if (err)
 401                 return err;
 402
 403         if (ext_csd[212] || ext_csd[213] || ext_csd[214] || ext_csd[215])
 404                 mmc->high_capacity = 1;
 405
 406         cardtype = ext_csd[196] & 0xf;
 407
 408         err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING, 1);
 409
 410         if (err)
 411                 return err;
 412
 413         /* Now check to see that it worked */
 414         err = mmc_send_ext_csd(mmc, ext_csd);
 415
 416         if (err)
 417                 return err;
 418
 419         /* No high-speed support */
 420         if (!ext_csd[185])
 421                 return 0;
 422
 423         /* High Speed is set, there are two types: 52MHz and 26MHz */
 424         if (cardtype & MMC_HS_52MHZ)
 425                 mmc->card_caps |= MMC_MODE_HS_52MHz | MMC_MODE_HS;
 426         else
 427                 mmc->card_caps |= MMC_MODE_HS;
 428
 429         return 0;
 430 }
 431
 432 int sd_switch(struct mmc *mmc, int mode, int group, u8 value, u8 *resp)
 433 {
 434         struct mmc_cmd cmd;
 435         struct mmc_data data;
 436
 437         /* Switch the frequency */
 438         cmd.cmdidx = SD_CMD_SWITCH_FUNC;
 439         cmd.resp_type = MMC_RSP_R1;
 440         cmd.cmdarg = (mode << 31) | 0xffffff;
 441         cmd.cmdarg &= ~(0xf << (group * 4));
 442         cmd.cmdarg |= value << (group * 4);
 443         cmd.flags = 0;
 444
 445         data.dest = (char *)resp;
 446         data.blocksize = 64;
 447         data.blocks = 1;
 448         data.flags = MMC_DATA_READ;
 449
 450         return mmc_send_cmd(mmc, &cmd, &data);
 451 }
 452
 453
 454 int sd_change_freq(struct mmc *mmc)
 455 {
 456         int err;
 457         struct mmc_cmd cmd;
 458         uint scr[2];
 459         uint switch_status[16];
 460         struct mmc_data data;
 461         int timeout;
 462
 463         mmc->card_caps = 0;
 464
 465         /* Read the SCR to find out if this card supports higher speeds */
 466         cmd.cmdidx = MMC_CMD_APP_CMD;
 467         cmd.resp_type = MMC_RSP_R1;
 468         cmd.cmdarg = mmc->rca << 16;
 469         cmd.flags = 0;
 470
 471         err = mmc_send_cmd(mmc, &cmd, NULL);
 472
 473         if (err)
 474                 return err;
 475
 476         cmd.cmdidx = SD_CMD_APP_SEND_SCR;
 477         cmd.resp_type = MMC_RSP_R1;
 478         cmd.cmdarg = 0;
 479         cmd.flags = 0;
 480
 481         timeout = 3;
 482
 483 retry_scr:
 484         data.dest = (char *)&scr;
 485         data.blocksize = 8;
 486         data.blocks = 1;
 487         data.flags = MMC_DATA_READ;
 488
 489         err = mmc_send_cmd(mmc, &cmd, &data);
 490
 491         if (err) {
 492                 if (timeout--)
 493                         goto retry_scr;
 494
 495                 return err;
 496         }
 497
 498         mmc->scr[0] = __be32_to_cpu(scr[0]);
 499         mmc->scr[1] = __be32_to_cpu(scr[1]);
 500
 501         switch ((mmc->scr[0] >> 24) & 0xf) {
 502                 case 0:
 503                         mmc->version = SD_VERSION_1_0;
 504                         break;
 505                 case 1:
 506                         mmc->version = SD_VERSION_1_10;
 507                         break;
 508                 case 2:
 509                         mmc->version = SD_VERSION_2;
 510                         break;
 511                 default:
 512                         mmc->version = SD_VERSION_1_0;
 513                         break;
 514         }
 515
 516         /* Version 1.0 doesn't support switching */
 517         if (mmc->version == SD_VERSION_1_0)
 518                 return 0;
 519
 520         timeout = 4;
 521         while (timeout--) {
 522                 err = sd_switch(mmc, SD_SWITCH_CHECK, 0, 1,
 523                                 (u8 *)&switch_status);
 524
 525                 if (err)
 526                         return err;
 527
 528                 /* The high-speed function is busy.  Try again */
 529                 if (!(__be32_to_cpu(switch_status[7]) & SD_HIGHSPEED_BUSY))
 530                         break;
 531         }
 532
 533         if (mmc->scr[0] & SD_DATA_4BIT)
 534                 mmc->card_caps |= MMC_MODE_4BIT;
 535
 536         /* If high-speed isn't supported, we return */
 537         if (!(__be32_to_cpu(switch_status[3]) & SD_HIGHSPEED_SUPPORTED))
 538                 return 0;
 539
 540         err = sd_switch(mmc, SD_SWITCH_SWITCH, 0, 1, (u8 *)&switch_status);
 541
 542         if (err)
 543                 return err;
 544
 545         if ((__be32_to_cpu(switch_status[4]) & 0x0f000000) == 0x01000000)
 546                 mmc->card_caps |= MMC_MODE_HS;
 547
 548         return 0;
 549 }
 550
 551 /* frequency bases */
 552 /* divided by 10 to be nice to platforms without floating point */
 553 int fbase[] = {
 554         10000,
 555         100000,
 556         1000000,
 557         10000000,
 558 };
 559
 560 /* Multiplier values for TRAN_SPEED.  Multiplied by 10 to be nice
 561  * to platforms without floating point.
 562  */
 563 int multipliers[] = {
 564         0,      /* reserved */
 565         10,
 566         12,
 567         13,
 568         15,
 569         20,
 570         25,
 571         30,
 572         35,
 573         40,
 574         45,
 575         50,
 576         55,
 577         60,
 578         70,
 579         80,
 580 };
 581
 582 void mmc_set_ios(struct mmc *mmc)
 583 {
 584         mmc->set_ios(mmc);
 585 }
 586
 587 void mmc_set_clock(struct mmc *mmc, uint clock)
 588 {
 589         if (clock > mmc->f_max)
 590                 clock = mmc->f_max;
 591
 592         if (clock < mmc->f_min)
 593                 clock = mmc->f_min;
 594
 595         mmc->clock = clock;
 596
 597         mmc_set_ios(mmc);
 598 }
 599
 600 void mmc_set_bus_width(struct mmc *mmc, uint width)
 601 {
 602         mmc->bus_width = width;
 603
 604         mmc_set_ios(mmc);
 605 }
 606
 607 int mmc_startup(struct mmc *mmc)
 608 {
 609         int err;
 610         uint mult, freq;
 611         u64 cmult, csize;
 612         struct mmc_cmd cmd;
 613
 614         /* Put the Card in Identify Mode */
 615         cmd.cmdidx = MMC_CMD_ALL_SEND_CID;
 616         cmd.resp_type = MMC_RSP_R2;
 617         cmd.cmdarg = 0;
 618         cmd.flags = 0;
 619
 620         err = mmc_send_cmd(mmc, &cmd, NULL);
 621
 622         if (err)
 623                 return err;
 624
 625         memcpy(mmc->cid, cmd.response, 16);
 626
 627         /*
 628          * For MMC cards, set the Relative Address.
 629          * For SD cards, get the Relatvie Address.
 630          * This also puts the cards into Standby State
 631          */
 632         cmd.cmdidx = SD_CMD_SEND_RELATIVE_ADDR;
 633         cmd.cmdarg = mmc->rca << 16;
 634         cmd.resp_type = MMC_RSP_R6;
 635         cmd.flags = 0;
 636
 637         err = mmc_send_cmd(mmc, &cmd, NULL);
 638
 639         if (err)
 640                 return err;
 641
 642         if (IS_SD(mmc))
 643                 mmc->rca = (cmd.response[0] >> 16) & 0xffff;
 644
 645         /* Get the Card-Specific Data */
 646         cmd.cmdidx = MMC_CMD_SEND_CSD;
 647         cmd.resp_type = MMC_RSP_R2;
 648         cmd.cmdarg = mmc->rca << 16;
 649         cmd.flags = 0;
 650
 651         err = mmc_send_cmd(mmc, &cmd, NULL);
 652
 653         if (err)
 654                 return err;
 655
 656         mmc->csd[0] = cmd.response[0];
 657         mmc->csd[1] = cmd.response[1];
 658         mmc->csd[2] = cmd.response[2];
 659         mmc->csd[3] = cmd.response[3];
 660
 661         if (mmc->version == MMC_VERSION_UNKNOWN) {
 662                 int version = (cmd.response[0] >> 26) & 0xf;
 663
 664                 switch (version) {
 665                         case 0:
 666                                 mmc->version = MMC_VERSION_1_2;
 667                                 break;
 668                         case 1:
 669                                 mmc->version = MMC_VERSION_1_4;
 670                                 break;
 671                         case 2:
 672                                 mmc->version = MMC_VERSION_2_2;
 673                                 break;
 674                         case 3:
 675                                 mmc->version = MMC_VERSION_3;
 676                                 break;
 677                         case 4:
 678                                 mmc->version = MMC_VERSION_4;
 679                                 break;
 680                         default:
 681                                 mmc->version = MMC_VERSION_1_2;
 682                                 break;
 683                 }
 684         }
 685
 686         /* divide frequency by 10, since the mults are 10x bigger */
 687         freq = fbase[(cmd.response[0] & 0x7)];
 688         mult = multipliers[((cmd.response[0] >> 3) & 0xf)];
 689
 690         mmc->tran_speed = freq * mult;
 691
 692         mmc->read_bl_len = 1 << ((cmd.response[1] >> 16) & 0xf);
 693
 694         if (IS_SD(mmc))
 695                 mmc->write_bl_len = mmc->read_bl_len;
 696         else
 697                 mmc->write_bl_len = 1 << ((cmd.response[3] >> 22) & 0xf);
 698
 699         if (mmc->high_capacity) {
 700                 csize = (mmc->csd[1] & 0x3f) << 16
 701                         | (mmc->csd[2] & 0xffff0000) >> 16;
 702                 cmult = 8;
 703         } else {
 704                 csize = (mmc->csd[1] & 0x3ff) << 2
 705                         | (mmc->csd[2] & 0xc0000000) >> 30;
 706                 cmult = (mmc->csd[2] & 0x00038000) >> 15;
 707         }
 708
 709         mmc->capacity = (csize + 1) << (cmult + 2);
 710         mmc->capacity *= mmc->read_bl_len;
 711
 712         if (mmc->read_bl_len > 512)
 713                 mmc->read_bl_len = 512;
 714
 715         if (mmc->write_bl_len > 512)
 716                 mmc->write_bl_len = 512;
 717
 718         /* Select the card, and put it into Transfer Mode */
 719         cmd.cmdidx = MMC_CMD_SELECT_CARD;
 720         cmd.resp_type = MMC_RSP_R1b;
 721         cmd.cmdarg = mmc->rca << 16;
 722         cmd.flags = 0;
 723         err = mmc_send_cmd(mmc, &cmd, NULL);
 724
 725         if (err)
 726                 return err;
 727
 728         if (IS_SD(mmc))
 729                 err = sd_change_freq(mmc);
 730         else
 731                 err = mmc_change_freq(mmc);
 732
 733         if (err)
 734                 return err;
 735
 736         /* Restrict card's capabilities by what the host can do */
 737         mmc->card_caps &= mmc->host_caps;
 738
 739         if (IS_SD(mmc)) {
 740                 if (mmc->card_caps & MMC_MODE_4BIT) {
 741                         cmd.cmdidx = MMC_CMD_APP_CMD;
 742                         cmd.resp_type = MMC_RSP_R1;
 743                         cmd.cmdarg = mmc->rca << 16;
 744                         cmd.flags = 0;
 745
 746                         err = mmc_send_cmd(mmc, &cmd, NULL);
 747                         if (err)
 748                                 return err;
 749
 750                         cmd.cmdidx = SD_CMD_APP_SET_BUS_WIDTH;
 751                         cmd.resp_type = MMC_RSP_R1;
 752                         cmd.cmdarg = 2;
 753                         cmd.flags = 0;
 754                         err = mmc_send_cmd(mmc, &cmd, NULL);
 755                         if (err)
 756                                 return err;
 757
 758                         mmc_set_bus_width(mmc, 4);
 759                 }
 760
 761                 if (mmc->card_caps & MMC_MODE_HS)
 762                         mmc_set_clock(mmc, 50000000);
 763                 else
 764                         mmc_set_clock(mmc, 25000000);
 765         } else {
 766                 if (mmc->card_caps & MMC_MODE_4BIT) {
 767                         /* Set the card to use 4 bit*/
 768                         err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
 769                                         EXT_CSD_BUS_WIDTH,
 770                                         EXT_CSD_BUS_WIDTH_4);
 771
 772                         if (err)
 773                                 return err;
 774
 775                         mmc_set_bus_width(mmc, 4);
 776                 } else if (mmc->card_caps & MMC_MODE_8BIT) {
 777                         /* Set the card to use 8 bit*/
 778                         err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
 779                                         EXT_CSD_BUS_WIDTH,
 780                                         EXT_CSD_BUS_WIDTH_8);
 781
 782                         if (err)
 783                                 return err;
 784
 785                         mmc_set_bus_width(mmc, 8);
 786                 }
 787
 788                 if (mmc->card_caps & MMC_MODE_HS) {
 789                         if (mmc->card_caps & MMC_MODE_HS_52MHz)
 790                                 mmc_set_clock(mmc, 52000000);
 791                         else
 792                                 mmc_set_clock(mmc, 26000000);
 793                 } else
 794                         mmc_set_clock(mmc, 20000000);
 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 }