drivers/mmc/mmc.c

   1 /*
   2  * (C) Copyright 2008-2010 Freescale Semiconductor, Inc.
   3  * Terry Lv
   4  *
   5  * Copyright 2008, Freescale Semiconductor, Inc
   6  * Andy Fleming
   7  *
   8  * Based vaguely on the Linux code
   9  *
  10  * See file CREDITS for list of people who contributed to this
  11  * project.
  12  *
  13  * This program is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU General Public License as
  15  * published by the Free Software Foundation; either version 2 of
  16  * the License, or (at your option) any later version.
  17  *
  18  * This program is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU General Public License
  24  * along with this program; if not, write to the Free Software
  25  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  26  * MA 02111-1307 USA
  27  */
  28
  29 #include <config.h>
  30 #include <common.h>
  31 #include <command.h>
  32 #include <mmc.h>
  33 #include <part.h>
  34 #include <malloc.h>
  35 #include <linux/list.h>
  36 #include <mmc.h>
  37 #include <div64.h>
  38 #include <fsl_esdhc.h>
  39
  40 static struct list_head mmc_devices;
  41 static int cur_dev_num = -1;
  42
  43 static int mmc_send_cmd(struct mmc *mmc,
  44         struct mmc_cmd *cmd, struct mmc_data *data)
  45 {
  46         return mmc->send_cmd(mmc, cmd, data);
  47 }
  48
  49 static int mmc_set_blocklen(struct mmc *mmc, int len)
  50 {
  51         struct mmc_cmd cmd;
  52
  53         cmd.cmdidx = MMC_CMD_SET_BLOCKLEN;
  54         cmd.resp_type = MMC_RSP_R1;
  55         cmd.cmdarg = len;
  56         cmd.flags = 0;
  57
  58         return mmc_send_cmd(mmc, &cmd, NULL);
  59 }
  60
  61 struct mmc *find_mmc_device(int dev_num)
  62 {
  63         struct mmc *m;
  64         struct list_head *entry;
  65
  66         list_for_each(entry, &mmc_devices) {
  67                 m = list_entry(entry, struct mmc, link);
  68
  69                 if (m->block_dev.dev == dev_num)
  70                         return m;
  71         }
  72
  73         printf("MMC Device %d not found\n", dev_num);
  74
  75         return NULL;
  76 }
  77
  78 static ulong
  79 mmc_bwrite(int dev_num, ulong start, lbaint_t blkcnt, const void*src)
  80 {
  81         struct mmc_cmd cmd;
  82         struct mmc_data data;
  83         int err;
  84         int stoperr = 0;
  85         struct mmc *mmc = find_mmc_device(dev_num);
  86         int blklen;
  87         lbaint_t blk_offset = 0, blk_left = blkcnt;
  88
  89         if (!mmc)
  90                 return -1;
  91
  92         blklen = mmc->write_bl_len;
  93
  94 #ifdef CONFIG_EMMC_DDR_MODE
  95         if (mmc->bus_width == EMMC_MODE_4BIT_DDR ||
  96                 mmc->bus_width == EMMC_MODE_8BIT_DDR) {
  97                 err = 0;
  98                 blklen = 512;
  99         } else
 100 #endif
 101         err = mmc_set_blocklen(mmc, mmc->write_bl_len);
 102
 103         if (err) {
 104                 puts("set write bl len failed\n\r");
 105                 return err;
 106         }
 107
 108         do {
 109                 cmd.cmdidx = (blk_left > 1) \
 110                                 ? MMC_CMD_WRITE_MULTIPLE_BLOCK \
 111                                 : MMC_CMD_WRITE_SINGLE_BLOCK;
 112
 113                 cmd.cmdarg = (mmc->high_capacity) \
 114                                 ? (start + blk_offset) \
 115                                 : ((start + blk_offset) * blklen);
 116
 117                 cmd.resp_type = MMC_RSP_R1;
 118                 cmd.flags = 0;
 119
 120                 data.src = src + blk_offset * blklen;
 121                 data.blocks = (blk_left > MAX_BLK_CNT) \
 122                                           ? MAX_BLK_CNT : blk_left;
 123                 data.blocksize = blklen;
 124                 data.flags = MMC_DATA_WRITE;
 125
 126                 err = mmc_send_cmd(mmc, &cmd, &data);
 127
 128                 if (err) {
 129                         puts("mmc write failed\n\r");
 130                         return err;
 131                 }
 132
 133                 if (blk_left > 1) {
 134                         cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION;
 135                         cmd.cmdarg = 0;
 136                         cmd.resp_type = MMC_RSP_R1b;
 137                         cmd.flags = 0;
 138                         stoperr = mmc_send_cmd(mmc, &cmd, NULL);
 139                 }
 140
 141                 if (blk_left > MAX_BLK_CNT) {
 142                         blk_left -= MAX_BLK_CNT;
 143                         blk_offset += MAX_BLK_CNT;
 144                 } else
 145                         break;
 146         } while (blk_left > 0);
 147
 148         return blkcnt;
 149 }
 150
 151 static int mmc_read_block(struct mmc *mmc, void *dst, uint blocknum)
 152 {
 153         struct mmc_cmd cmd;
 154         struct mmc_data data;
 155
 156         cmd.cmdidx = MMC_CMD_READ_SINGLE_BLOCK;
 157
 158         if (mmc->high_capacity)
 159                 cmd.cmdarg = blocknum;
 160         else
 161                 cmd.cmdarg = blocknum * mmc->read_bl_len;
 162
 163         cmd.resp_type = MMC_RSP_R1;
 164         cmd.flags = 0;
 165
 166         data.dest = dst;
 167         data.blocks = 1;
 168         data.blocksize = mmc->read_bl_len;
 169         data.flags = MMC_DATA_READ;
 170
 171         return mmc_send_cmd(mmc, &cmd, &data);
 172 }
 173
 174 int mmc_read(struct mmc *mmc, u64 src, uchar *dst, int size)
 175 {
 176         char *buffer;
 177         int i;
 178         int blklen = mmc->read_bl_len;
 179         int startblock = lldiv(src, mmc->read_bl_len);
 180         int endblock = lldiv(src + size - 1, mmc->read_bl_len);
 181         int err = 0;
 182
 183 #ifdef CONFIG_EMMC_DDR_MODE
 184         if (mmc->bus_width == EMMC_MODE_4BIT_DDR ||
 185                 mmc->bus_width == EMMC_MODE_8BIT_DDR)
 186                 blklen = 512;
 187 #endif
 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 #ifdef CONFIG_EMMC_DDR_MODE
 198         if (mmc->bus_width == EMMC_MODE_4BIT_DDR ||
 199                 mmc->bus_width == EMMC_MODE_8BIT_DDR)
 200                 err = 0;
 201         else
 202 #endif
 203         /* We always do full block reads from the card */
 204         err = mmc_set_blocklen(mmc, mmc->read_bl_len);
 205
 206         if (err)
 207                 goto free_buffer;
 208
 209         for (i = startblock; i <= endblock; i++) {
 210                 int segment_size;
 211                 int offset;
 212
 213                 err = mmc_read_block(mmc, buffer, i);
 214
 215                 if (err)
 216                         goto free_buffer;
 217
 218                 /*
 219                  * The first block may not be aligned, so we
 220                  * copy from the desired point in the block
 221                  */
 222                 offset = (src & (blklen - 1));
 223                 segment_size = MIN(blklen - offset, size);
 224
 225                 memcpy(dst, buffer + offset, segment_size);
 226
 227                 dst += segment_size;
 228                 src += segment_size;
 229                 size -= segment_size;
 230         }
 231
 232 free_buffer:
 233         free(buffer);
 234
 235         return err;
 236 }
 237
 238 static ulong mmc_bread(int dev_num, ulong start, lbaint_t blkcnt, void *dst)
 239 {
 240         struct mmc_cmd cmd;
 241         struct mmc_data data;
 242         int err;
 243         int stoperr = 0;
 244         struct mmc *mmc = find_mmc_device(dev_num);
 245         int blklen;
 246         lbaint_t blk_offset = 0, blk_left = blkcnt;
 247
 248         if (!mmc)
 249                 return -1;
 250
 251         if (mmc->bus_width == EMMC_MODE_4BIT_DDR ||
 252                 mmc->bus_width == EMMC_MODE_8BIT_DDR) {
 253                 blklen = 512;
 254                 err = 0;
 255         } else {
 256                 blklen = mmc->read_bl_len;
 257                 err = mmc_set_blocklen(mmc, blklen);
 258         }
 259
 260         if (err) {
 261                 puts("set read bl len failed\n\r");
 262                 return err;
 263         }
 264
 265         do {
 266                 cmd.cmdidx = (blk_left > 1) \
 267                                 ? MMC_CMD_READ_MULTIPLE_BLOCK \
 268                                 : MMC_CMD_READ_SINGLE_BLOCK;
 269
 270                 cmd.cmdarg = (mmc->high_capacity) \
 271                                 ? (start + blk_offset) \
 272                                 : ((start + blk_offset) * blklen);
 273
 274                 cmd.resp_type = MMC_RSP_R1;
 275                 cmd.flags = 0;
 276
 277                 data.dest = dst + blk_offset * blklen;
 278                 data.blocks = (blk_left > MAX_BLK_CNT) ? MAX_BLK_CNT : blk_left;
 279                 data.blocksize = blklen;
 280                 data.flags = MMC_DATA_READ;
 281
 282                 err = mmc_send_cmd(mmc, &cmd, &data);
 283
 284                 if (err) {
 285                         puts("mmc read failed\n\r");
 286                         return err;
 287                 }
 288
 289                 if (blk_left > 1) {
 290                         cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION;
 291                         cmd.cmdarg = 0;
 292                         cmd.resp_type = MMC_RSP_R1b;
 293                         cmd.flags = 0;
 294                         stoperr = mmc_send_cmd(mmc, &cmd, NULL);
 295                 }
 296
 297                 if (blk_left > MAX_BLK_CNT) {
 298                         blk_left -= MAX_BLK_CNT;
 299                         blk_offset += MAX_BLK_CNT;
 300                 } else
 301                         break;
 302         } while (blk_left > 0);
 303
 304         return blkcnt;
 305 }
 306
 307 #define CARD_STATE(r) ((u32)((r) & 0x1e00) >> 9)
 308
 309 static int mmc_go_idle(struct mmc *mmc)
 310 {
 311         struct mmc_cmd cmd;
 312         int err;
 313
 314         udelay(1000);
 315
 316         cmd.cmdidx = MMC_CMD_GO_IDLE_STATE;
 317         cmd.cmdarg = 0;
 318         cmd.resp_type = MMC_RSP_NONE;
 319         cmd.flags = 0;
 320
 321         err = mmc_send_cmd(mmc, &cmd, NULL);
 322
 323         if (err)
 324                 return err;
 325
 326         udelay(2000);
 327
 328         return 0;
 329 }
 330
 331 static int
 332 sd_send_op_cond(struct mmc *mmc)
 333 {
 334         int timeout = 1000;
 335         int err;
 336         struct mmc_cmd cmd;
 337
 338         do {
 339                 cmd.cmdidx = MMC_CMD_APP_CMD;
 340                 cmd.resp_type = MMC_RSP_R1;
 341                 cmd.cmdarg = 0;
 342                 cmd.flags = 0;
 343
 344                 err = mmc_send_cmd(mmc, &cmd, NULL);
 345
 346                 if (err)
 347                         return err;
 348
 349                 cmd.cmdidx = SD_CMD_APP_SEND_OP_COND;
 350                 cmd.resp_type = MMC_RSP_R3;
 351
 352                 /*
 353                  * Most cards do not answer if some reserved bits
 354                  * in the ocr are set. However, Some controller
 355                  * can set bit 7 (reserved for low voltages), but
 356                  * how to manage low voltages SD card is not yet
 357                  * specified.
 358                  */
 359                 cmd.cmdarg = mmc->voltages & 0xff8000;
 360
 361                 if (mmc->version == SD_VERSION_2)
 362                         cmd.cmdarg |= OCR_HCS;
 363
 364                 err = mmc_send_cmd(mmc, &cmd, NULL);
 365
 366                 if (err)
 367                         return err;
 368
 369                 udelay(1000);
 370         } while ((!(cmd.response[0] & OCR_BUSY)) && timeout--);
 371
 372         if (timeout <= 0)
 373                 return UNUSABLE_ERR;
 374
 375         if (mmc->version != SD_VERSION_2)
 376                 mmc->version = SD_VERSION_1_0;
 377
 378         mmc->ocr = cmd.response[0];
 379
 380         mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS);
 381         mmc->rca = 0;
 382
 383         return 0;
 384 }
 385
 386 static int mmc_send_op_cond(struct mmc *mmc)
 387 {
 388         int timeout = 1000;
 389         struct mmc_cmd cmd;
 390         int err;
 391
 392         /* Some cards seem to need this */
 393         mmc_go_idle(mmc);
 394
 395         do {
 396                 cmd.cmdidx = MMC_CMD_SEND_OP_COND;
 397                 cmd.resp_type = MMC_RSP_R3;
 398                 cmd.cmdarg = OCR_HCS | mmc->voltages;
 399                 cmd.flags = 0;
 400
 401                 err = mmc_send_cmd(mmc, &cmd, NULL);
 402
 403                 if (err)
 404                         return err;
 405
 406                 udelay(1000);
 407         } while (!(cmd.response[0] & OCR_BUSY) && timeout--);
 408
 409         if (timeout <= 0)
 410                 return UNUSABLE_ERR;
 411
 412         mmc->version = MMC_VERSION_UNKNOWN;
 413         mmc->ocr = cmd.response[0];
 414
 415         mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS);
 416         mmc->rca = 0;
 417
 418         return 0;
 419 }
 420
 421
 422 static int mmc_send_ext_csd(struct mmc *mmc, char *ext_csd)
 423 {
 424         struct mmc_cmd cmd;
 425         struct mmc_data data;
 426         int err;
 427
 428         /* Get the Card Status Register */
 429         cmd.cmdidx = MMC_CMD_SEND_EXT_CSD;
 430         cmd.resp_type = MMC_RSP_R1;
 431         cmd.cmdarg = 0;
 432         cmd.flags = 0;
 433
 434         data.dest = ext_csd;
 435         data.blocks = 1;
 436         data.blocksize = 512;
 437         data.flags = MMC_DATA_READ;
 438
 439         err = mmc_send_cmd(mmc, &cmd, &data);
 440
 441         return err;
 442 }
 443
 444
 445 static int mmc_switch(struct mmc *mmc, u8 set, u8 index, u8 value)
 446 {
 447         struct mmc_cmd cmd;
 448
 449         cmd.cmdidx = MMC_CMD_SWITCH;
 450         cmd.resp_type = MMC_RSP_R1b;
 451         cmd.cmdarg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) |
 452                 (index << 16) |
 453                 (value << 8);
 454         cmd.flags = 0;
 455
 456         return mmc_send_cmd(mmc, &cmd, NULL);
 457 }
 458
 459 static int mmc_change_freq(struct mmc *mmc)
 460 {
 461         char *ext_csd;
 462         char cardtype;
 463         int err;
 464
 465         mmc->card_caps = 0;
 466
 467         /* Only version 4 supports high-speed */
 468         if (mmc->version < MMC_VERSION_4)
 469                 return 0;
 470
 471         mmc->card_caps |= ((mmc->host_caps & MMC_MODE_8BIT)
 472                 ? MMC_MODE_8BIT : MMC_MODE_4BIT);
 473
 474         ext_csd = (char *)malloc(512);
 475
 476         if (!ext_csd) {
 477                 puts("Could not allocate buffer for MMC ext csd!\n");
 478                 return -1;
 479         }
 480
 481         err = mmc_send_ext_csd(mmc, ext_csd);
 482
 483         if (err)
 484                 goto err_rtn;
 485
 486         if (mmc->high_capacity) {
 487                 mmc->capacity = ext_csd[EXT_CSD_SEC_CNT + 3] << 24 |
 488                                 ext_csd[EXT_CSD_SEC_CNT + 2] << 16 |
 489                                 ext_csd[EXT_CSD_SEC_CNT + 1] << 8 |
 490                                 ext_csd[EXT_CSD_SEC_CNT];
 491                 mmc->capacity *= 512;
 492         }
 493
 494         cardtype = ext_csd[EXT_CSD_CARD_TYPE] & 0xf;
 495
 496         err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING, 1);
 497
 498         if (err)
 499                 goto err_rtn;
 500
 501         /* Now check to see that it worked */
 502         err = mmc_send_ext_csd(mmc, ext_csd);
 503
 504         if (err)
 505                 goto err_rtn;
 506
 507         /* No high-speed support */
 508         if (!ext_csd[EXT_CSD_HS_TIMING])
 509                 goto no_err_rtn;
 510
 511         /* High Speed is set, there are two types: 52MHz and 26MHz */
 512         if (cardtype & MMC_HS_52MHZ)
 513                 mmc->card_caps |= MMC_MODE_HS_52MHz | MMC_MODE_HS;
 514         else
 515                 mmc->card_caps |= MMC_MODE_HS;
 516 #ifdef CONFIG_EMMC_DDR_MODE
 517         if (cardtype & EMMC_MODE_DDR_3V) {
 518                 if (mmc->card_caps & MMC_MODE_8BIT)
 519                         mmc->card_caps |= EMMC_MODE_8BIT_DDR;
 520                 else
 521                         mmc->card_caps |= EMMC_MODE_4BIT_DDR;
 522         }
 523
 524 #endif
 525
 526 no_err_rtn:
 527         free(ext_csd);
 528         return 0;
 529
 530 err_rtn:
 531         free(ext_csd);
 532         return err;
 533 }
 534
 535 static int sd_switch(struct mmc *mmc, int mode, int group, u8 value, u8 *resp)
 536 {
 537         struct mmc_cmd cmd;
 538         struct mmc_data data;
 539
 540         /* Switch the frequency */
 541         cmd.cmdidx = SD_CMD_SWITCH_FUNC;
 542         cmd.resp_type = MMC_RSP_R1;
 543         cmd.cmdarg = (mode << 31) | 0xffffff;
 544         cmd.cmdarg &= ~(0xf << (group * 4));
 545         cmd.cmdarg |= value << (group * 4);
 546         cmd.flags = 0;
 547
 548         data.dest = (char *)resp;
 549         data.blocksize = 64;
 550         data.blocks = 1;
 551         data.flags = MMC_DATA_READ;
 552
 553         return mmc_send_cmd(mmc, &cmd, &data);
 554 }
 555
 556
 557 static int sd_change_freq(struct mmc *mmc)
 558 {
 559         int err;
 560         struct mmc_cmd cmd;
 561         uint scr[2];
 562         uint switch_status[16];
 563         struct mmc_data data;
 564         int timeout;
 565
 566         mmc->card_caps = 0;
 567
 568         /* Read the SCR to find out if this card supports higher speeds */
 569         cmd.cmdidx = MMC_CMD_APP_CMD;
 570         cmd.resp_type = MMC_RSP_R1;
 571         cmd.cmdarg = mmc->rca << 16;
 572         cmd.flags = 0;
 573
 574         err = mmc_send_cmd(mmc, &cmd, NULL);
 575
 576         if (err)
 577                 return err;
 578
 579         cmd.cmdidx = SD_CMD_APP_SEND_SCR;
 580         cmd.resp_type = MMC_RSP_R1;
 581         cmd.cmdarg = 0;
 582         cmd.flags = 0;
 583
 584         timeout = 3;
 585
 586 retry_scr:
 587         data.dest = (char *)&scr;
 588         data.blocksize = 8;
 589         data.blocks = 1;
 590         data.flags = MMC_DATA_READ;
 591
 592         err = mmc_send_cmd(mmc, &cmd, &data);
 593
 594         if (err) {
 595                 if (timeout--)
 596                         goto retry_scr;
 597
 598                 return err;
 599         }
 600
 601         mmc->scr[0] = __be32_to_cpu(scr[0]);
 602         mmc->scr[1] = __be32_to_cpu(scr[1]);
 603
 604         switch ((mmc->scr[0] >> 24) & 0xf) {
 605                 case 0:
 606                         mmc->version = SD_VERSION_1_0;
 607                         break;
 608                 case 1:
 609                         mmc->version = SD_VERSION_1_10;
 610                         break;
 611                 case 2:
 612                         mmc->version = SD_VERSION_2;
 613                         break;
 614                 default:
 615                         mmc->version = SD_VERSION_1_0;
 616                         break;
 617         }
 618
 619         /* Version 1.0 doesn't support switching */
 620         if (mmc->version == SD_VERSION_1_0)
 621                 return 0;
 622
 623         timeout = 4;
 624         while (timeout--) {
 625                 err = sd_switch(mmc, SD_SWITCH_CHECK, 0, 1,
 626                                 (u8 *)&switch_status);
 627
 628                 if (err)
 629                         return err;
 630
 631                 /* The high-speed function is busy.  Try again */
 632                 if (!(__be32_to_cpu(switch_status[7]) & SD_HIGHSPEED_BUSY))
 633                         break;
 634         }
 635
 636         if (mmc->scr[0] & SD_DATA_4BIT)
 637                 mmc->card_caps |= MMC_MODE_4BIT;
 638
 639         /* If high-speed isn't supported, we return */
 640         if (!(__be32_to_cpu(switch_status[3]) & SD_HIGHSPEED_SUPPORTED))
 641                 return 0;
 642
 643         err = sd_switch(mmc, SD_SWITCH_SWITCH, 0, 1, (u8 *)&switch_status);
 644
 645         if (err)
 646                 return err;
 647
 648         if ((__be32_to_cpu(switch_status[4]) & 0x0f000000) == 0x01000000)
 649                 mmc->card_caps |= MMC_MODE_HS;
 650
 651         return 0;
 652 }
 653
 654 /* frequency bases */
 655 /* divided by 10 to be nice to platforms without floating point */
 656 static int fbase[] = {
 657         10000,
 658         100000,
 659         1000000,
 660         10000000,
 661 };
 662
 663 /* Multiplier values for TRAN_SPEED.  Multiplied by 10 to be nice
 664  * to platforms without floating point.
 665  */
 666 static int multipliers[] = {
 667         0,      /* reserved */
 668         10,
 669         12,
 670         13,
 671         15,
 672         20,
 673         25,
 674         30,
 675         35,
 676         40,
 677         45,
 678         50,
 679         55,
 680         60,
 681         70,
 682         80,
 683 };
 684
 685 static void mmc_set_ios(struct mmc *mmc)
 686 {
 687         mmc->set_ios(mmc);
 688 }
 689
 690 static void mmc_set_clock(struct mmc *mmc, uint clock)
 691 {
 692         if (clock > mmc->f_max)
 693                 clock = mmc->f_max;
 694
 695         if (clock < mmc->f_min)
 696                 clock = mmc->f_min;
 697
 698         mmc->clock = clock;
 699
 700         mmc_set_ios(mmc);
 701 }
 702
 703 static void mmc_set_bus_width(struct mmc *mmc, uint width)
 704 {
 705         mmc->bus_width = width;
 706
 707         mmc_set_ios(mmc);
 708 }
 709
 710 #ifdef CONFIG_BOOT_PARTITION_ACCESS
 711 /* Return 0/1/2 for partition id before switch; Return -1 if fail to switch */
 712 int mmc_switch_partition(struct mmc *mmc, uint part, uint enable_boot)
 713 {
 714         char *ext_csd;
 715         int err;
 716         uint old_part, new_part;
 717         char boot_config;
 718 #ifdef CONFIG_EMMC_DDR_MODE
 719         char boot_bus_width, card_boot_bus_width;
 720 #endif
 721
 722         /* partition must be -
 723                 0 - user area
 724                 1 - boot partition 1
 725                 2 - boot partition 2
 726         */
 727         if (part > 2) {
 728                 printf("\nWrong partition id - "
 729                         "0 (user area), 1 (boot1), 2 (boot2)\n");
 730                 return 1;
 731         }
 732
 733         /* Before calling this func, "mmc" struct must have been initialized */
 734         if (mmc->version < MMC_VERSION_4) {
 735                 puts("\nError: invalid mmc version! "
 736                         "mmc version is below version 4!");
 737                 return -1;
 738         }
 739
 740         if (mmc->boot_size_mult <= 0) {
 741                 /* it's a normal SD/MMC but user request to boot partition */
 742                 printf("\nError: This is a normal SD/MMC card but you"
 743                         "request to access boot partition\n");
 744                 return -1;
 745         }
 746
 747         /*
 748          * Part must be 0 (user area), 1 (boot partition1)
 749          * or 2 (boot partition2)
 750          */
 751         if (part > 2) {
 752                 puts("\nError: partition id must be 0(user area), "
 753                         "1(boot partition1) or 2(boot partition2)\n");
 754                 return -1;
 755         }
 756
 757         ext_csd = (char *)malloc(512);
 758         if (!ext_csd) {
 759                 puts("\nError: Could not allocate buffer for MMC ext csd!\n");
 760                 return -1;
 761         }
 762
 763         err = mmc_send_ext_csd(mmc, ext_csd);
 764         if (err) {
 765                 puts("\nWarning: fail to get ext csd for MMC!\n");
 766                 goto err_rtn;
 767         }
 768
 769         old_part = ext_csd[EXT_CSD_BOOT_CONFIG] &
 770                         EXT_CSD_BOOT_PARTITION_ACCESS_MASK;
 771
 772         /* Send SWITCH command to change partition for access */
 773         boot_config = (ext_csd[EXT_CSD_BOOT_CONFIG] &
 774                         ~EXT_CSD_BOOT_PARTITION_ACCESS_MASK) |
 775                         (char)part;
 776
 777         /* enable access plus boot from that partition and boot_ack bit */
 778         if (enable_boot != 0)
 779                 boot_config = (char)(part) | (char)(part << 3) | (char)(1 << 6);
 780
 781         err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
 782                         EXT_CSD_BOOT_CONFIG, boot_config);
 783         if (err) {
 784                 puts("\nError: fail to send SWITCH command to card "
 785                         "to swich partition for access!\n");
 786                 goto err_rtn;
 787         }
 788
 789         /* Now check whether it works */
 790         err = mmc_send_ext_csd(mmc, ext_csd);
 791         if (err) {
 792                 puts("\nWarning: fail to get ext csd for MMC!\n");
 793                 goto err_rtn;
 794         }
 795
 796         new_part = ext_csd[EXT_CSD_BOOT_CONFIG] &
 797                         EXT_CSD_BOOT_PARTITION_ACCESS_MASK;
 798         if ((char)part != new_part) {
 799                 printf("\nWarning: after SWITCH, current part id %d is "
 800                         "not same as requested partition %d!\n",
 801                         new_part, part);
 802                 goto err_rtn;
 803         }
 804
 805 #ifdef CONFIG_EMMC_DDR_MODE
 806         /* Program boot_bus_width field for eMMC 4.4 boot mode */
 807         if ((ext_csd[EXT_CSD_CARD_TYPE] & 0xC) && enable_boot != 0) {
 808
 809                 /* Configure according to this host's capabilities */
 810                 if (mmc->host_caps & EMMC_MODE_8BIT_DDR)
 811                         boot_bus_width =  EXT_CSD_BOOT_BUS_WIDTH_DDR |
 812                                 EXT_CSD_BOOT_BUS_WIDTH_8BIT;
 813                 else if (mmc->host_caps & EMMC_MODE_4BIT_DDR)
 814                         boot_bus_width =  EXT_CSD_BOOT_BUS_WIDTH_DDR |
 815                                 EXT_CSD_BOOT_BUS_WIDTH_4BIT;
 816                 else if (mmc->host_caps & MMC_MODE_8BIT)
 817                         boot_bus_width = EXT_CSD_BOOT_BUS_WIDTH_8BIT;
 818                 else if (mmc->host_caps & MMC_MODE_4BIT)
 819                         boot_bus_width = EXT_CSD_BOOT_BUS_WIDTH_4BIT;
 820                 else
 821                         boot_bus_width = 0;
 822
 823                 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
 824                         EXT_CSD_BOOT_BUS_WIDTH, boot_bus_width);
 825
 826                 /* Ensure that it programmed properly */
 827                 err = mmc_send_ext_csd(mmc, ext_csd);
 828                 if (err) {
 829                         puts("\nWarning: fail to get ext csd for MMC!\n");
 830                         goto err_rtn;
 831                 }
 832
 833                 card_boot_bus_width = ext_csd[EXT_CSD_BOOT_BUS_WIDTH];
 834                 if (card_boot_bus_width != boot_bus_width) {
 835                         printf("\nWarning: current boot_bus_width, 0x%x, is "
 836                                 "not same as requested boot_bus_width 0x%x!\n",
 837                                 card_boot_bus_width, boot_bus_width);
 838                         goto err_rtn;
 839                 }
 840         }
 841 #endif
 842
 843         /* Seems everything is ok, return the partition id before switch */
 844         free(ext_csd);
 845         return old_part;
 846
 847 err_rtn:
 848         free(ext_csd);
 849         return -1;
 850 }
 851
 852 int sd_switch_partition(struct mmc *mmc, uint part)
 853 {
 854         struct mmc_cmd cmd;
 855         int err;
 856
 857         if (part > 1) {
 858                 printf("\nWrong partition id - 0 (user area), 1 (boot1)\n");
 859                 return 1;
 860         }
 861
 862         cmd.cmdidx = SD_CMD_SELECT_PARTITION;
 863         cmd.resp_type = MMC_RSP_R1;
 864         cmd.cmdarg = part << 24;
 865         cmd.flags = 0;
 866
 867         err = mmc_send_cmd(mmc, &cmd, NULL);
 868
 869         if (err)
 870                 return -1;
 871
 872         return 0;
 873 }
 874
 875 static int mmc_get_cur_boot_partition(struct mmc *mmc)
 876 {
 877         char *ext_csd;
 878         int err;
 879
 880         ext_csd = (char *)malloc(512);
 881
 882         if (!ext_csd) {
 883                 puts("\nError! Could not allocate buffer for MMC ext csd!\n");
 884                 return -1;
 885         }
 886
 887         err = mmc_send_ext_csd(mmc, ext_csd);
 888
 889         if (err) {
 890                 mmc->boot_config = 0;
 891                 mmc->boot_size_mult = 0;
 892                 /* continue since it's not a fatal error */
 893         } else {
 894                 mmc->boot_config = ext_csd[EXT_CSD_BOOT_CONFIG];
 895                 mmc->boot_size_mult = ext_csd[EXT_CSD_BOOT_SIZE_MULT];
 896         }
 897
 898         free(ext_csd);
 899
 900         return err;
 901 }
 902
 903 #endif
 904
 905 static int mmc_startup(struct mmc *mmc)
 906 {
 907         int err;
 908         uint mult, freq;
 909         u64 cmult, csize;
 910         struct mmc_cmd cmd;
 911
 912         /* Put the Card in Identify Mode */
 913         cmd.cmdidx = MMC_CMD_ALL_SEND_CID;
 914         cmd.resp_type = MMC_RSP_R2;
 915         cmd.cmdarg = 0;
 916         cmd.flags = 0;
 917
 918         err = mmc_send_cmd(mmc, &cmd, NULL);
 919
 920         if (err)
 921                 return err;
 922
 923         memcpy(mmc->cid, cmd.response, 16);
 924
 925         /*
 926          * For MMC cards, set the Relative Address.
 927          * For SD cards, get the Relatvie Address.
 928          * This also puts the cards into Standby State
 929          */
 930         cmd.cmdidx = SD_CMD_SEND_RELATIVE_ADDR;
 931         cmd.cmdarg = mmc->rca << 16;
 932         cmd.resp_type = MMC_RSP_R6;
 933         cmd.flags = 0;
 934
 935         err = mmc_send_cmd(mmc, &cmd, NULL);
 936
 937         if (err)
 938                 return err;
 939
 940         if (IS_SD(mmc))
 941                 mmc->rca = (cmd.response[0] >> 16) & 0xffff;
 942
 943         /* Get the Card-Specific Data */
 944         cmd.cmdidx = MMC_CMD_SEND_CSD;
 945         cmd.resp_type = MMC_RSP_R2;
 946         cmd.cmdarg = mmc->rca << 16;
 947         cmd.flags = 0;
 948
 949         err = mmc_send_cmd(mmc, &cmd, NULL);
 950
 951         if (err)
 952                 return err;
 953
 954         mmc->csd[0] = cmd.response[0];
 955         mmc->csd[1] = cmd.response[1];
 956         mmc->csd[2] = cmd.response[2];
 957         mmc->csd[3] = cmd.response[3];
 958
 959         if (mmc->version == MMC_VERSION_UNKNOWN) {
 960                 int version = (cmd.response[0] >> 26) & 0xf;
 961
 962                 switch (version) {
 963                         case 0:
 964                                 mmc->version = MMC_VERSION_1_2;
 965                                 break;
 966                         case 1:
 967                                 mmc->version = MMC_VERSION_1_4;
 968                                 break;
 969                         case 2:
 970                                 mmc->version = MMC_VERSION_2_2;
 971                                 break;
 972                         case 3:
 973                                 mmc->version = MMC_VERSION_3;
 974                                 break;
 975                         case 4:
 976                                 mmc->version = MMC_VERSION_4;
 977                                 break;
 978                         default:
 979                                 mmc->version = MMC_VERSION_1_2;
 980                                 break;
 981                 }
 982         }
 983
 984         /* divide frequency by 10, since the mults are 10x bigger */
 985         freq = fbase[(cmd.response[0] & 0x7)];
 986         mult = multipliers[((cmd.response[0] >> 3) & 0xf)];
 987
 988         mmc->tran_speed = freq * mult;
 989
 990         mmc->read_bl_len = 1 << ((cmd.response[1] >> 16) & 0xf);
 991
 992         if (IS_SD(mmc))
 993                 mmc->write_bl_len = mmc->read_bl_len;
 994         else
 995                 mmc->write_bl_len = 1 << ((cmd.response[3] >> 22) & 0xf);
 996
 997         if (IS_SD(mmc)) {
 998                 int csd_struct = (cmd.response[0] >> 30) & 0x3;
 999
1000                 switch (csd_struct) {
1001                 case 1:
1002                         csize = (mmc->csd[1] & 0x3f) << 16
1003                                 | (mmc->csd[2] & 0xffff0000) >> 16;
1004                         cmult = 8;
1005                         break;
1006                 case 0:
1007                 default:
1008                         if (0 != csd_struct)
1009                                 printf("unrecognised CSD structure version %d\n",
1010                                                 csd_struct);
1011                         csize = (mmc->csd[1] & 0x3ff) << 2
1012                                 | (mmc->csd[2] & 0xc0000000) >> 30;
1013                         cmult = (mmc->csd[2] & 0x00038000) >> 15;
1014                         break;
1015                 }
1016         } else {
1017                 csize = (mmc->csd[1] & 0x3ff) << 2
1018                         | (mmc->csd[2] & 0xc0000000) >> 30;
1019                 cmult = (mmc->csd[2] & 0x00038000) >> 15;
1020         }
1021
1022         mmc->capacity = (csize + 1) << (cmult + 2);
1023         mmc->capacity *= mmc->read_bl_len;
1024
1025         if (mmc->read_bl_len > 512)
1026                 mmc->read_bl_len = 512;
1027
1028         if (mmc->write_bl_len > 512)
1029                 mmc->write_bl_len = 512;
1030
1031         /* Select the card, and put it into Transfer Mode */
1032         cmd.cmdidx = MMC_CMD_SELECT_CARD;
1033         cmd.resp_type = MMC_RSP_R1b;
1034         cmd.cmdarg = mmc->rca << 16;
1035         cmd.flags = 0;
1036         err = mmc_send_cmd(mmc, &cmd, NULL);
1037
1038         if (err)
1039                 return err;
1040
1041         if (IS_SD(mmc))
1042                 err = sd_change_freq(mmc);
1043         else
1044                 err = mmc_change_freq(mmc);
1045
1046         if (err)
1047                 return err;
1048
1049         /* Restrict card's capabilities by what the host can do */
1050         mmc->card_caps &= mmc->host_caps;
1051
1052         if (IS_SD(mmc)) {
1053                 if (mmc->card_caps & MMC_MODE_4BIT) {
1054                         cmd.cmdidx = MMC_CMD_APP_CMD;
1055                         cmd.resp_type = MMC_RSP_R1;
1056                         cmd.cmdarg = mmc->rca << 16;
1057                         cmd.flags = 0;
1058
1059                         err = mmc_send_cmd(mmc, &cmd, NULL);
1060                         if (err)
1061                                 return err;
1062
1063                         cmd.cmdidx = SD_CMD_APP_SET_BUS_WIDTH;
1064                         cmd.resp_type = MMC_RSP_R1;
1065                         cmd.cmdarg = 2;
1066                         cmd.flags = 0;
1067                         err = mmc_send_cmd(mmc, &cmd, NULL);
1068                         if (err)
1069                                 return err;
1070
1071                         mmc_set_bus_width(mmc, 4);
1072                 }
1073
1074                 if (mmc->card_caps & MMC_MODE_HS)
1075                         mmc_set_clock(mmc, 50000000);
1076                 else
1077                         mmc_set_clock(mmc, 25000000);
1078         } else {
1079                 if (mmc->card_caps & MMC_MODE_4BIT) {
1080                         /* Set the card to use 4 bit*/
1081                         err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1082                                         EXT_CSD_BUS_WIDTH,
1083                                         EXT_CSD_BUS_WIDTH_4);
1084
1085                         if (err)
1086                                 return err;
1087
1088                         mmc_set_bus_width(mmc, 4);
1089                 } else if (mmc->card_caps & MMC_MODE_8BIT) {
1090                         /* Set the card to use 8 bit*/
1091                         err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1092                                         EXT_CSD_BUS_WIDTH,
1093                                         EXT_CSD_BUS_WIDTH_8);
1094
1095                         if (err)
1096                                 return err;
1097
1098                         mmc_set_bus_width(mmc, 8);
1099                 }
1100
1101 #ifdef CONFIG_EMMC_DDR_MODE
1102
1103                 if (mmc->card_caps & EMMC_MODE_8BIT_DDR) {
1104                         /* Set the card to use 8 bit DDR mode */
1105                         err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1106                                         EXT_CSD_BUS_WIDTH,
1107                                         EXT_CSD_BUS_WIDTH_8_DDR);
1108                         if (err)
1109                                 return err;
1110
1111
1112                         /* Setup the host controller for DDR mode */
1113                         mmc_set_bus_width(mmc, EMMC_MODE_8BIT_DDR);
1114                 } else if (mmc->card_caps & EMMC_MODE_4BIT_DDR) {
1115                         /* Set the card to use 4 bit DDR mode */
1116                         err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1117                                         EXT_CSD_BUS_WIDTH,
1118                                         EXT_CSD_BUS_WIDTH_4_DDR);
1119                         if (err)
1120                                 return err;
1121
1122                         /* Setup the host controller for DDR mode */
1123                         mmc_set_bus_width(mmc, EMMC_MODE_4BIT_DDR);
1124                 }
1125 #endif
1126
1127                 if (mmc->card_caps & MMC_MODE_HS) {
1128                         if (mmc->card_caps & MMC_MODE_HS_52MHz)
1129                                 mmc_set_clock(mmc, 52000000);
1130                         else
1131                                 mmc_set_clock(mmc, 26000000);
1132                 } else
1133                         mmc_set_clock(mmc, 20000000);
1134
1135 #ifdef CONFIG_BOOT_PARTITION_ACCESS
1136                 mmc_get_cur_boot_partition(mmc);
1137 #endif
1138         }
1139
1140         /* fill in device description */
1141         mmc->block_dev.lun = 0;
1142         mmc->block_dev.type = 0;
1143         mmc->block_dev.blksz = mmc->read_bl_len;
1144         mmc->block_dev.lba = lldiv(mmc->capacity, mmc->read_bl_len);
1145         sprintf(mmc->block_dev.vendor, "Man %06x Snr %08x", mmc->cid[0] >> 8,
1146                         (mmc->cid[2] << 8) | (mmc->cid[3] >> 24));
1147         sprintf(mmc->block_dev.product, "%c%c%c%c%c", mmc->cid[0] & 0xff,
1148                         (mmc->cid[1] >> 24), (mmc->cid[1] >> 16) & 0xff,
1149                         (mmc->cid[1] >> 8) & 0xff, mmc->cid[1] & 0xff);
1150         sprintf(mmc->block_dev.revision, "%d.%d", mmc->cid[2] >> 28,
1151                         (mmc->cid[2] >> 24) & 0xf);
1152         init_part(&mmc->block_dev);
1153
1154         return 0;
1155 }
1156
1157 static int mmc_send_if_cond(struct mmc *mmc)
1158 {
1159         struct mmc_cmd cmd;
1160         int err;
1161
1162         cmd.cmdidx = SD_CMD_SEND_IF_COND;
1163         /* We set the bit if the host supports voltages between 2.7 and 3.6 V */
1164         cmd.cmdarg = ((mmc->voltages & 0xff8000) != 0) << 8 | 0xaa;
1165         cmd.resp_type = MMC_RSP_R7;
1166         cmd.flags = 0;
1167
1168         err = mmc_send_cmd(mmc, &cmd, NULL);
1169
1170         if (err)
1171                 return err;
1172
1173         if ((cmd.response[0] & 0xff) != 0xaa)
1174                 return UNUSABLE_ERR;
1175         else
1176                 mmc->version = SD_VERSION_2;
1177
1178         return 0;
1179 }
1180
1181 int mmc_register(struct mmc *mmc)
1182 {
1183         /* Setup the universal parts of the block interface just once */
1184         mmc->block_dev.if_type = IF_TYPE_MMC;
1185         mmc->block_dev.dev = cur_dev_num++;
1186         mmc->block_dev.removable = 1;
1187         mmc->block_dev.block_read = mmc_bread;
1188         mmc->block_dev.block_write = mmc_bwrite;
1189 #if defined(CONFIG_DOS_PARTITION)
1190         mmc->block_dev.part_type = PART_TYPE_DOS;
1191         mmc->block_dev.type = DEV_TYPE_HARDDISK;
1192 #elif defined(CONFIG_MAC_PARTITION)
1193         mmc->block_dev.part_type = PART_TYPE_MAC;
1194         mmc->block_dev.type = DEV_TYPE_HARDDISK;
1195 #elif defined(CONFIG_ISO_PARTITION)
1196         mmc->block_dev.part_type = PART_TYPE_ISO;
1197         mmc->block_dev.type = DEV_TYPE_HARDDISK;
1198 #elif defined(CONFIG_AMIGA_PARTITION)
1199         mmc->block_dev.part_type = PART_TYPE_AMIGA;
1200         mmc->block_dev.type = DEV_TYPE_HARDDISK;
1201 #elif defined(CONFIG_EFI_PARTITION)
1202         mmc->block_dev.part_type = PART_TYPE_EFI;
1203         mmc->block_dev.type = DEV_TYPE_HARDDISK;
1204 #endif
1205
1206         INIT_LIST_HEAD (&mmc->link);
1207
1208         list_add_tail (&mmc->link, &mmc_devices);
1209
1210         return 0;
1211 }
1212
1213 block_dev_desc_t *mmc_get_dev(int dev)
1214 {
1215         struct mmc *mmc = find_mmc_device(dev);
1216
1217         return mmc ? &mmc->block_dev : NULL;
1218 }
1219
1220 int mmc_init(struct mmc *mmc)
1221 {
1222         int err;
1223
1224         err = mmc->init(mmc);
1225
1226         if (err)
1227                 return err;
1228
1229         mmc_set_bus_width(mmc, 1);
1230         mmc_set_clock(mmc, 1);
1231
1232         /* Reset the Card */
1233         err = mmc_go_idle(mmc);
1234
1235         if (err)
1236                 return err;
1237
1238         /* Test for SD version 2 */
1239         err = mmc_send_if_cond(mmc);
1240
1241         /* Now try to get the SD card's operating condition */
1242         err = sd_send_op_cond(mmc);
1243
1244         /* If the command timed out, we check for an MMC card */
1245         if (err == TIMEOUT) {
1246                 err = mmc_send_op_cond(mmc);
1247
1248                 if (err) {
1249                         printf("Card did not respond to voltage select!\n");
1250                         return UNUSABLE_ERR;
1251                 }
1252         }
1253
1254         return mmc_startup(mmc);
1255 }
1256
1257 /*
1258  * CPU and board-specific MMC initializations.  Aliased function
1259  * signals caller to move on
1260  */
1261 static int __def_mmc_init(bd_t *bis)
1262 {
1263         return -1;
1264 }
1265
1266 int cpu_mmc_init(bd_t *bis) __attribute__((weak, alias("__def_mmc_init")));
1267 int board_mmc_init(bd_t *bis) __attribute__((weak, alias("__def_mmc_init")));
1268
1269 void print_mmc_devices(char separator)
1270 {
1271         struct mmc *m;
1272         struct list_head *entry;
1273
1274         list_for_each(entry, &mmc_devices) {
1275                 m = list_entry(entry, struct mmc, link);
1276
1277                 printf("%s: %d", m->name, m->block_dev.dev);
1278
1279                 if (entry->next != &mmc_devices)
1280                         printf("%c ", separator);
1281         }
1282
1283         printf("\n");
1284 }
1285
1286 int mmc_initialize(bd_t *bis)
1287 {
1288         INIT_LIST_HEAD (&mmc_devices);
1289         cur_dev_num = 0;
1290
1291         if (board_mmc_init(bis) < 0)
1292                 cpu_mmc_init(bis);
1293
1294         print_mmc_devices(',');
1295
1296         return 0;
1297 }
1298