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