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