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