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