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