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