drivers/mmc/core/mmc.c

   1 /*
   2  *  linux/drivers/mmc/core/mmc.c
   3  *
   4  *  Copyright (C) 2003-2004 Russell King, All Rights Reserved.
   5  *  Copyright (C) 2005-2007 Pierre Ossman, All Rights Reserved.
   6  *  MMCv4 support Copyright (C) 2006 Philip Langdale, All Rights Reserved.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  */
  12
  13 #include <linux/err.h>
  14 #include <linux/slab.h>
  15
  16 #include <linux/mmc/host.h>
  17 #include <linux/mmc/card.h>
  18 #include <linux/mmc/mmc.h>
  19
  20 #include "core.h"
  21 #include "bus.h"
  22 #include "mmc_ops.h"
  23 #include "sd_ops.h"
  24
  25 static const unsigned int tran_exp[] = {
  26         10000,          100000,         1000000,        10000000,
  27         0,              0,              0,              0
  28 };
  29
  30 static const unsigned char tran_mant[] = {
  31         0,      10,     12,     13,     15,     20,     25,     30,
  32         35,     40,     45,     50,     55,     60,     70,     80,
  33 };
  34
  35 static const unsigned int tacc_exp[] = {
  36         1,      10,     100,    1000,   10000,  100000, 1000000, 10000000,
  37 };
  38
  39 static const unsigned int tacc_mant[] = {
  40         0,      10,     12,     13,     15,     20,     25,     30,
  41         35,     40,     45,     50,     55,     60,     70,     80,
  42 };
  43
  44 #define UNSTUFF_BITS(resp,start,size)                                   \
  45         ({                                                              \
  46                 const int __size = size;                                \
  47                 const u32 __mask = (__size < 32 ? 1 << __size : 0) - 1; \
  48                 const int __off = 3 - ((start) / 32);                   \
  49                 const int __shft = (start) & 31;                        \
  50                 u32 __res;                                              \
  51                                                                         \
  52                 __res = resp[__off] >> __shft;                          \
  53                 if (__size + __shft > 32)                               \
  54                         __res |= resp[__off-1] << ((32 - __shft) % 32); \
  55                 __res & __mask;                                         \
  56         })
  57
  58 /*
  59  * Given the decoded CSD structure, decode the raw CID to our CID structure.
  60  */
  61 static int mmc_decode_cid(struct mmc_card *card)
  62 {
  63         u32 *resp = card->raw_cid;
  64
  65         /*
  66          * The selection of the format here is based upon published
  67          * specs from sandisk and from what people have reported.
  68          */
  69         switch (card->csd.mmca_vsn) {
  70         case 0: /* MMC v1.0 - v1.2 */
  71         case 1: /* MMC v1.4 */
  72                 card->cid.manfid        = UNSTUFF_BITS(resp, 104, 24);
  73                 card->cid.prod_name[0]  = UNSTUFF_BITS(resp, 96, 8);
  74                 card->cid.prod_name[1]  = UNSTUFF_BITS(resp, 88, 8);
  75                 card->cid.prod_name[2]  = UNSTUFF_BITS(resp, 80, 8);
  76                 card->cid.prod_name[3]  = UNSTUFF_BITS(resp, 72, 8);
  77                 card->cid.prod_name[4]  = UNSTUFF_BITS(resp, 64, 8);
  78                 card->cid.prod_name[5]  = UNSTUFF_BITS(resp, 56, 8);
  79                 card->cid.prod_name[6]  = UNSTUFF_BITS(resp, 48, 8);
  80                 card->cid.hwrev         = UNSTUFF_BITS(resp, 44, 4);
  81                 card->cid.fwrev         = UNSTUFF_BITS(resp, 40, 4);
  82                 card->cid.serial        = UNSTUFF_BITS(resp, 16, 24);
  83                 card->cid.month         = UNSTUFF_BITS(resp, 12, 4);
  84                 card->cid.year          = UNSTUFF_BITS(resp, 8, 4) + 1997;
  85                 break;
  86
  87         case 2: /* MMC v2.0 - v2.2 */
  88         case 3: /* MMC v3.1 - v3.3 */
  89         case 4: /* MMC v4 */
  90                 card->cid.manfid        = UNSTUFF_BITS(resp, 120, 8);
  91                 card->cid.oemid         = UNSTUFF_BITS(resp, 104, 16);
  92                 card->cid.prod_name[0]  = UNSTUFF_BITS(resp, 96, 8);
  93                 card->cid.prod_name[1]  = UNSTUFF_BITS(resp, 88, 8);
  94                 card->cid.prod_name[2]  = UNSTUFF_BITS(resp, 80, 8);
  95                 card->cid.prod_name[3]  = UNSTUFF_BITS(resp, 72, 8);
  96                 card->cid.prod_name[4]  = UNSTUFF_BITS(resp, 64, 8);
  97                 card->cid.prod_name[5]  = UNSTUFF_BITS(resp, 56, 8);
  98                 card->cid.serial        = UNSTUFF_BITS(resp, 16, 32);
  99                 card->cid.month         = UNSTUFF_BITS(resp, 12, 4);
 100                 card->cid.year          = UNSTUFF_BITS(resp, 8, 4) + 1997;
 101                 break;
 102
 103         default:
 104                 printk(KERN_ERR "%s: card has unknown MMCA version %d\n",
 105                         mmc_hostname(card->host), card->csd.mmca_vsn);
 106                 return -EINVAL;
 107         }
 108
 109         return 0;
 110 }
 111
 112 static void mmc_set_erase_size(struct mmc_card *card)
 113 {
 114         if (card->ext_csd.erase_group_def & 1)
 115                 card->erase_size = card->ext_csd.hc_erase_size;
 116         else
 117                 card->erase_size = card->csd.erase_size;
 118
 119         mmc_init_erase(card);
 120 }
 121
 122 /*
 123  * Given a 128-bit response, decode to our card CSD structure.
 124  */
 125 static int mmc_decode_csd(struct mmc_card *card)
 126 {
 127         struct mmc_csd *csd = &card->csd;
 128         unsigned int e, m, a, b;
 129         u32 *resp = card->raw_csd;
 130
 131         /*
 132          * We only understand CSD structure v1.1 and v1.2.
 133          * v1.2 has extra information in bits 15, 11 and 10.
 134          * We also support eMMC v4.4 & v4.41.
 135          */
 136         csd->structure = UNSTUFF_BITS(resp, 126, 2);
 137         if (csd->structure == 0) {
 138                 printk(KERN_ERR "%s: unrecognised CSD structure version %d\n",
 139                         mmc_hostname(card->host), csd->structure);
 140                 return -EINVAL;
 141         }
 142
 143         csd->mmca_vsn    = UNSTUFF_BITS(resp, 122, 4);
 144         m = UNSTUFF_BITS(resp, 115, 4);
 145         e = UNSTUFF_BITS(resp, 112, 3);
 146         csd->tacc_ns     = (tacc_exp[e] * tacc_mant[m] + 9) / 10;
 147         csd->tacc_clks   = UNSTUFF_BITS(resp, 104, 8) * 100;
 148
 149         m = UNSTUFF_BITS(resp, 99, 4);
 150         e = UNSTUFF_BITS(resp, 96, 3);
 151         csd->max_dtr      = tran_exp[e] * tran_mant[m];
 152         csd->cmdclass     = UNSTUFF_BITS(resp, 84, 12);
 153
 154         e = UNSTUFF_BITS(resp, 47, 3);
 155         m = UNSTUFF_BITS(resp, 62, 12);
 156         csd->capacity     = (1 + m) << (e + 2);
 157
 158         csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4);
 159         csd->read_partial = UNSTUFF_BITS(resp, 79, 1);
 160         csd->write_misalign = UNSTUFF_BITS(resp, 78, 1);
 161         csd->read_misalign = UNSTUFF_BITS(resp, 77, 1);
 162         csd->r2w_factor = UNSTUFF_BITS(resp, 26, 3);
 163         csd->write_blkbits = UNSTUFF_BITS(resp, 22, 4);
 164         csd->write_partial = UNSTUFF_BITS(resp, 21, 1);
 165
 166         if (csd->write_blkbits >= 9) {
 167                 a = UNSTUFF_BITS(resp, 42, 5);
 168                 b = UNSTUFF_BITS(resp, 37, 5);
 169                 csd->erase_size = (a + 1) * (b + 1);
 170                 csd->erase_size <<= csd->write_blkbits - 9;
 171         }
 172
 173         return 0;
 174 }
 175
 176 /*
 177  * Read and decode extended CSD.
 178  */
 179 static int mmc_read_ext_csd(struct mmc_card *card)
 180 {
 181         int err;
 182         u8 *ext_csd;
 183
 184         BUG_ON(!card);
 185
 186         if (card->csd.mmca_vsn < CSD_SPEC_VER_4)
 187                 return 0;
 188
 189         /*
 190          * As the ext_csd is so large and mostly unused, we don't store the
 191          * raw block in mmc_card.
 192          */
 193         ext_csd = kmalloc(512, GFP_KERNEL);
 194         if (!ext_csd) {
 195                 printk(KERN_ERR "%s: could not allocate a buffer to "
 196                         "receive the ext_csd.\n", mmc_hostname(card->host));
 197                 return -ENOMEM;
 198         }
 199
 200         err = mmc_send_ext_csd(card, ext_csd);
 201         if (err) {
 202                 /* If the host or the card can't do the switch,
 203                  * fail more gracefully. */
 204                 if ((err != -EINVAL)
 205                  && (err != -ENOSYS)
 206                  && (err != -EFAULT))
 207                         goto out;
 208
 209                 /*
 210                  * High capacity cards should have this "magic" size
 211                  * stored in their CSD.
 212                  */
 213                 if (card->csd.capacity == (4096 * 512)) {
 214                         printk(KERN_ERR "%s: unable to read EXT_CSD "
 215                                 "on a possible high capacity card. "
 216                                 "Card will be ignored.\n",
 217                                 mmc_hostname(card->host));
 218                 } else {
 219                         printk(KERN_WARNING "%s: unable to read "
 220                                 "EXT_CSD, performance might "
 221                                 "suffer.\n",
 222                                 mmc_hostname(card->host));
 223                         err = 0;
 224                 }
 225
 226                 goto out;
 227         }
 228
 229         /* Version is coded in the CSD_STRUCTURE byte in the EXT_CSD register */
 230         if (card->csd.structure == 3) {
 231                 int ext_csd_struct = ext_csd[EXT_CSD_STRUCTURE];
 232                 if (ext_csd_struct > 2) {
 233                         printk(KERN_ERR "%s: unrecognised EXT_CSD structure "
 234                                 "version %d\n", mmc_hostname(card->host),
 235                                         ext_csd_struct);
 236                         err = -EINVAL;
 237                         goto out;
 238                 }
 239         }
 240
 241         card->ext_csd.rev = ext_csd[EXT_CSD_REV];
 242         if (card->ext_csd.rev > 5) {
 243                 printk(KERN_ERR "%s: unrecognised EXT_CSD revision %d\n",
 244                         mmc_hostname(card->host), card->ext_csd.rev);
 245                 err = -EINVAL;
 246                 goto out;
 247         }
 248
 249         if (card->ext_csd.rev >= 2) {
 250                 card->ext_csd.sectors =
 251                         ext_csd[EXT_CSD_SEC_CNT + 0] << 0 |
 252                         ext_csd[EXT_CSD_SEC_CNT + 1] << 8 |
 253                         ext_csd[EXT_CSD_SEC_CNT + 2] << 16 |
 254                         ext_csd[EXT_CSD_SEC_CNT + 3] << 24;
 255
 256                 /* Cards with density > 2GiB are sector addressed */
 257                 if (card->ext_csd.sectors > (2u * 1024 * 1024 * 1024) / 512)
 258                         mmc_card_set_blockaddr(card);
 259         }
 260
 261         switch (ext_csd[EXT_CSD_CARD_TYPE] & EXT_CSD_CARD_TYPE_MASK) {
 262         case EXT_CSD_CARD_TYPE_DDR_52 | EXT_CSD_CARD_TYPE_52 |
 263              EXT_CSD_CARD_TYPE_26:
 264                 card->ext_csd.hs_max_dtr = 52000000;
 265                 card->ext_csd.card_type = EXT_CSD_CARD_TYPE_DDR_52;
 266                 break;
 267         case EXT_CSD_CARD_TYPE_DDR_1_2V | EXT_CSD_CARD_TYPE_52 |
 268              EXT_CSD_CARD_TYPE_26:
 269                 card->ext_csd.hs_max_dtr = 52000000;
 270                 card->ext_csd.card_type = EXT_CSD_CARD_TYPE_DDR_1_2V;
 271                 break;
 272         case EXT_CSD_CARD_TYPE_DDR_1_8V | EXT_CSD_CARD_TYPE_52 |
 273              EXT_CSD_CARD_TYPE_26:
 274                 card->ext_csd.hs_max_dtr = 52000000;
 275                 card->ext_csd.card_type = EXT_CSD_CARD_TYPE_DDR_1_8V;
 276                 break;
 277         case EXT_CSD_CARD_TYPE_52 | EXT_CSD_CARD_TYPE_26:
 278                 card->ext_csd.hs_max_dtr = 52000000;
 279                 break;
 280         case EXT_CSD_CARD_TYPE_26:
 281                 card->ext_csd.hs_max_dtr = 26000000;
 282                 break;
 283         default:
 284                 /* MMC v4 spec says this cannot happen */
 285                 printk(KERN_WARNING "%s: card is mmc v4 but doesn't "
 286                         "support any high-speed modes.\n",
 287                         mmc_hostname(card->host));
 288         }
 289
 290         if (card->ext_csd.rev >= 3) {
 291                 u8 sa_shift = ext_csd[EXT_CSD_S_A_TIMEOUT];
 292                 card->ext_csd.part_config = ext_csd[EXT_CSD_PART_CONFIG];
 293
 294                 /* EXT_CSD value is in units of 10ms, but we store in ms */
 295                 card->ext_csd.part_time = 10 * ext_csd[EXT_CSD_PART_SWITCH_TIME];
 296
 297                 /* Sleep / awake timeout in 100ns units */
 298                 if (sa_shift > 0 && sa_shift <= 0x17)
 299                         card->ext_csd.sa_timeout =
 300                                         1 << ext_csd[EXT_CSD_S_A_TIMEOUT];
 301                 card->ext_csd.erase_group_def =
 302                         ext_csd[EXT_CSD_ERASE_GROUP_DEF];
 303                 card->ext_csd.hc_erase_timeout = 300 *
 304                         ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT];
 305                 card->ext_csd.hc_erase_size =
 306                         ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] << 10;
 307
 308                 card->ext_csd.rel_sectors = ext_csd[EXT_CSD_REL_WR_SEC_C];
 309
 310                 /*
 311                  * There are two boot regions of equal size, defined in
 312                  * multiples of 128K.
 313                  */
 314                 card->ext_csd.boot_size = ext_csd[EXT_CSD_BOOT_MULT] << 17;
 315         }
 316
 317         if (card->ext_csd.rev >= 4) {
 318                 /*
 319                  * Enhanced area feature support -- check whether the eMMC
 320                  * card has the Enhanced area enabled.  If so, export enhanced
 321                  * area offset and size to user by adding sysfs interface.
 322                  */
 323                 if ((ext_csd[EXT_CSD_PARTITION_SUPPORT] & 0x2) &&
 324                                 (ext_csd[EXT_CSD_PARTITION_ATTRIBUTE] & 0x1)) {
 325                         u8 hc_erase_grp_sz =
 326                                 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
 327                         u8 hc_wp_grp_sz =
 328                                 ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
 329
 330                         card->ext_csd.enhanced_area_en = 1;
 331                         /*
 332                          * calculate the enhanced data area offset, in bytes
 333                          */
 334                         card->ext_csd.enhanced_area_offset =
 335                                 (ext_csd[139] << 24) + (ext_csd[138] << 16) +
 336                                 (ext_csd[137] << 8) + ext_csd[136];
 337                         if (mmc_card_blockaddr(card))
 338                                 card->ext_csd.enhanced_area_offset <<= 9;
 339                         /*
 340                          * calculate the enhanced data area size, in kilobytes
 341                          */
 342                         card->ext_csd.enhanced_area_size =
 343                                 (ext_csd[142] << 16) + (ext_csd[141] << 8) +
 344                                 ext_csd[140];
 345                         card->ext_csd.enhanced_area_size *=
 346                                 (size_t)(hc_erase_grp_sz * hc_wp_grp_sz);
 347                         card->ext_csd.enhanced_area_size <<= 9;
 348                 } else {
 349                         /*
 350                          * If the enhanced area is not enabled, disable these
 351                          * device attributes.
 352                          */
 353                         card->ext_csd.enhanced_area_offset = -EINVAL;
 354                         card->ext_csd.enhanced_area_size = -EINVAL;
 355                 }
 356                 card->ext_csd.sec_trim_mult =
 357                         ext_csd[EXT_CSD_SEC_TRIM_MULT];
 358                 card->ext_csd.sec_erase_mult =
 359                         ext_csd[EXT_CSD_SEC_ERASE_MULT];
 360                 card->ext_csd.sec_feature_support =
 361                         ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT];
 362                 card->ext_csd.trim_timeout = 300 *
 363                         ext_csd[EXT_CSD_TRIM_MULT];
 364         }
 365
 366         if (card->ext_csd.rev >= 5)
 367                 card->ext_csd.rel_param = ext_csd[EXT_CSD_WR_REL_PARAM];
 368
 369         if (ext_csd[EXT_CSD_ERASED_MEM_CONT])
 370                 card->erased_byte = 0xFF;
 371         else
 372                 card->erased_byte = 0x0;
 373
 374 out:
 375         kfree(ext_csd);
 376
 377         return err;
 378 }
 379
 380 MMC_DEV_ATTR(cid, "%08x%08x%08x%08x\n", card->raw_cid[0], card->raw_cid[1],
 381         card->raw_cid[2], card->raw_cid[3]);
 382 MMC_DEV_ATTR(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1],
 383         card->raw_csd[2], card->raw_csd[3]);
 384 MMC_DEV_ATTR(date, "%02d/%04d\n", card->cid.month, card->cid.year);
 385 MMC_DEV_ATTR(erase_size, "%u\n", card->erase_size << 9);
 386 MMC_DEV_ATTR(preferred_erase_size, "%u\n", card->pref_erase << 9);
 387 MMC_DEV_ATTR(fwrev, "0x%x\n", card->cid.fwrev);
 388 MMC_DEV_ATTR(hwrev, "0x%x\n", card->cid.hwrev);
 389 MMC_DEV_ATTR(manfid, "0x%06x\n", card->cid.manfid);
 390 MMC_DEV_ATTR(name, "%s\n", card->cid.prod_name);
 391 MMC_DEV_ATTR(oemid, "0x%04x\n", card->cid.oemid);
 392 MMC_DEV_ATTR(serial, "0x%08x\n", card->cid.serial);
 393 MMC_DEV_ATTR(enhanced_area_offset, "%llu\n",
 394                 card->ext_csd.enhanced_area_offset);
 395 MMC_DEV_ATTR(enhanced_area_size, "%u\n", card->ext_csd.enhanced_area_size);
 396
 397 static struct attribute *mmc_std_attrs[] = {
 398         &dev_attr_cid.attr,
 399         &dev_attr_csd.attr,
 400         &dev_attr_date.attr,
 401         &dev_attr_erase_size.attr,
 402         &dev_attr_preferred_erase_size.attr,
 403         &dev_attr_fwrev.attr,
 404         &dev_attr_hwrev.attr,
 405         &dev_attr_manfid.attr,
 406         &dev_attr_name.attr,
 407         &dev_attr_oemid.attr,
 408         &dev_attr_serial.attr,
 409         &dev_attr_enhanced_area_offset.attr,
 410         &dev_attr_enhanced_area_size.attr,
 411         NULL,
 412 };
 413
 414 static struct attribute_group mmc_std_attr_group = {
 415         .attrs = mmc_std_attrs,
 416 };
 417
 418 static const struct attribute_group *mmc_attr_groups[] = {
 419         &mmc_std_attr_group,
 420         NULL,
 421 };
 422
 423 static struct device_type mmc_type = {
 424         .groups = mmc_attr_groups,
 425 };
 426
 427 /*
 428  * Handle the detection and initialisation of a card.
 429  *
 430  * In the case of a resume, "oldcard" will contain the card
 431  * we're trying to reinitialise.
 432  */
 433 static int mmc_init_card(struct mmc_host *host, u32 ocr,
 434         struct mmc_card *oldcard)
 435 {
 436         struct mmc_card *card;
 437         int err, ddr = 0;
 438         u32 cid[4];
 439         unsigned int max_dtr;
 440         u32 rocr;
 441
 442         BUG_ON(!host);
 443         WARN_ON(!host->claimed);
 444
 445         /*
 446          * Since we're changing the OCR value, we seem to
 447          * need to tell some cards to go back to the idle
 448          * state.  We wait 1ms to give cards time to
 449          * respond.
 450          */
 451         mmc_go_idle(host);
 452
 453         /* The extra bit indicates that we support high capacity */
 454         err = mmc_send_op_cond(host, ocr | (1 << 30), &rocr);
 455         if (err)
 456                 goto err;
 457
 458         /*
 459          * For SPI, enable CRC as appropriate.
 460          */
 461         if (mmc_host_is_spi(host)) {
 462                 err = mmc_spi_set_crc(host, use_spi_crc);
 463                 if (err)
 464                         goto err;
 465         }
 466
 467         /*
 468          * Fetch CID from card.
 469          */
 470         if (mmc_host_is_spi(host))
 471                 err = mmc_send_cid(host, cid);
 472         else
 473                 err = mmc_all_send_cid(host, cid);
 474         if (err)
 475                 goto err;
 476
 477         if (oldcard) {
 478                 if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0) {
 479                         err = -ENOENT;
 480                         goto err;
 481                 }
 482
 483                 card = oldcard;
 484         } else {
 485                 /*
 486                  * Allocate card structure.
 487                  */
 488                 card = mmc_alloc_card(host, &mmc_type);
 489                 if (IS_ERR(card)) {
 490                         err = PTR_ERR(card);
 491                         goto err;
 492                 }
 493
 494                 card->type = MMC_TYPE_MMC;
 495                 card->rca = 1;
 496                 memcpy(card->raw_cid, cid, sizeof(card->raw_cid));
 497         }
 498
 499         /*
 500          * For native busses:  set card RCA and quit open drain mode.
 501          */
 502         if (!mmc_host_is_spi(host)) {
 503                 err = mmc_set_relative_addr(card);
 504                 if (err)
 505                         goto free_card;
 506
 507                 mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL);
 508         }
 509
 510         if (!oldcard) {
 511                 /*
 512                  * Fetch CSD from card.
 513                  */
 514                 err = mmc_send_csd(card, card->raw_csd);
 515                 if (err)
 516                         goto free_card;
 517
 518                 err = mmc_decode_csd(card);
 519                 if (err)
 520                         goto free_card;
 521                 err = mmc_decode_cid(card);
 522                 if (err)
 523                         goto free_card;
 524         }
 525
 526         /*
 527          * Select card, as all following commands rely on that.
 528          */
 529         if (!mmc_host_is_spi(host)) {
 530                 err = mmc_select_card(card);
 531                 if (err)
 532                         goto free_card;
 533         }
 534
 535         if (!oldcard) {
 536                 /*
 537                  * Fetch and process extended CSD.
 538                  */
 539                 err = mmc_read_ext_csd(card);
 540                 if (err)
 541                         goto free_card;
 542
 543                 /* If doing byte addressing, check if required to do sector
 544                  * addressing.  Handle the case of <2GB cards needing sector
 545                  * addressing.  See section 8.1 JEDEC Standard JED84-A441;
 546                  * ocr register has bit 30 set for sector addressing.
 547                  */
 548                 if (!(mmc_card_blockaddr(card)) && (rocr & (1<<30)))
 549                         mmc_card_set_blockaddr(card);
 550
 551                 /* Erase size depends on CSD and Extended CSD */
 552                 mmc_set_erase_size(card);
 553         }
 554
 555         /*
 556          * If enhanced_area_en is TRUE, host needs to enable ERASE_GRP_DEF
 557          * bit.  This bit will be lost every time after a reset or power off.
 558          */
 559         if (card->ext_csd.enhanced_area_en) {
 560                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
 561                                  EXT_CSD_ERASE_GROUP_DEF, 1, 0);
 562
 563                 if (err && err != -EBADMSG)
 564                         goto free_card;
 565
 566                 if (err) {
 567                         err = 0;
 568                         /*
 569                          * Just disable enhanced area off & sz
 570                          * will try to enable ERASE_GROUP_DEF
 571                          * during next time reinit
 572                          */
 573                         card->ext_csd.enhanced_area_offset = -EINVAL;
 574                         card->ext_csd.enhanced_area_size = -EINVAL;
 575                 } else {
 576                         card->ext_csd.erase_group_def = 1;
 577                         /*
 578                          * enable ERASE_GRP_DEF successfully.
 579                          * This will affect the erase size, so
 580                          * here need to reset erase size
 581                          */
 582                         mmc_set_erase_size(card);
 583                 }
 584         }
 585
 586         /*
 587          * Ensure eMMC user default partition is enabled
 588          */
 589         if (card->ext_csd.part_config & EXT_CSD_PART_CONFIG_ACC_MASK) {
 590                 card->ext_csd.part_config &= ~EXT_CSD_PART_CONFIG_ACC_MASK;
 591                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONFIG,
 592                                  card->ext_csd.part_config,
 593                                  card->ext_csd.part_time);
 594                 if (err && err != -EBADMSG)
 595                         goto free_card;
 596         }
 597
 598         /*
 599          * Activate high speed (if supported)
 600          */
 601         if ((card->ext_csd.hs_max_dtr != 0) &&
 602                 (host->caps & MMC_CAP_MMC_HIGHSPEED)) {
 603                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
 604                                  EXT_CSD_HS_TIMING, 1, 0);
 605                 if (err && err != -EBADMSG)
 606                         goto free_card;
 607
 608                 if (err) {
 609                         printk(KERN_WARNING "%s: switch to highspeed failed\n",
 610                                mmc_hostname(card->host));
 611                         err = 0;
 612                 } else {
 613                         mmc_card_set_highspeed(card);
 614                         mmc_set_timing(card->host, MMC_TIMING_MMC_HS);
 615                 }
 616         }
 617
 618         /*
 619          * Compute bus speed.
 620          */
 621         max_dtr = (unsigned int)-1;
 622
 623         if (mmc_card_highspeed(card)) {
 624                 if (max_dtr > card->ext_csd.hs_max_dtr)
 625                         max_dtr = card->ext_csd.hs_max_dtr;
 626         } else if (max_dtr > card->csd.max_dtr) {
 627                 max_dtr = card->csd.max_dtr;
 628         }
 629
 630         mmc_set_clock(host, max_dtr);
 631
 632         /*
 633          * Indicate DDR mode (if supported).
 634          */
 635         if (mmc_card_highspeed(card)) {
 636                 if ((card->ext_csd.card_type & EXT_CSD_CARD_TYPE_DDR_1_8V)
 637                         && ((host->caps & (MMC_CAP_1_8V_DDR |
 638                              MMC_CAP_UHS_DDR50))
 639                                 == (MMC_CAP_1_8V_DDR | MMC_CAP_UHS_DDR50)))
 640                                 ddr = MMC_1_8V_DDR_MODE;
 641                 else if ((card->ext_csd.card_type & EXT_CSD_CARD_TYPE_DDR_1_2V)
 642                         && ((host->caps & (MMC_CAP_1_2V_DDR |
 643                              MMC_CAP_UHS_DDR50))
 644                                 == (MMC_CAP_1_2V_DDR | MMC_CAP_UHS_DDR50)))
 645                                 ddr = MMC_1_2V_DDR_MODE;
 646         }
 647
 648         /*
 649          * Activate wide bus and DDR (if supported).
 650          */
 651         if ((card->csd.mmca_vsn >= CSD_SPEC_VER_4) &&
 652             (host->caps & (MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA))) {
 653                 static unsigned ext_csd_bits[][2] = {
 654                         { EXT_CSD_BUS_WIDTH_8, EXT_CSD_DDR_BUS_WIDTH_8 },
 655                         { EXT_CSD_BUS_WIDTH_4, EXT_CSD_DDR_BUS_WIDTH_4 },
 656                         { EXT_CSD_BUS_WIDTH_1, EXT_CSD_BUS_WIDTH_1 },
 657                 };
 658                 static unsigned bus_widths[] = {
 659                         MMC_BUS_WIDTH_8,
 660                         MMC_BUS_WIDTH_4,
 661                         MMC_BUS_WIDTH_1
 662                 };
 663                 unsigned idx, bus_width = 0;
 664
 665                 if (host->caps & MMC_CAP_8_BIT_DATA)
 666                         idx = 0;
 667                 else
 668                         idx = 1;
 669                 for (; idx < ARRAY_SIZE(bus_widths); idx++) {
 670                         bus_width = bus_widths[idx];
 671                         if (bus_width == MMC_BUS_WIDTH_1)
 672                                 ddr = 0; /* no DDR for 1-bit width */
 673                         err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
 674                                          EXT_CSD_BUS_WIDTH,
 675                                          ext_csd_bits[idx][0],
 676                                          0);
 677                         if (!err) {
 678                                 mmc_set_bus_width(card->host, bus_width);
 679                                 /*
 680                                  * If controller can't handle bus width test,
 681                                  * use the highest bus width to maintain
 682                                  * compatibility with previous MMC behavior.
 683                                  */
 684                                 if (!(host->caps & MMC_CAP_BUS_WIDTH_TEST))
 685                                         break;
 686                                 err = mmc_bus_test(card, bus_width);
 687                                 if (!err)
 688                                         break;
 689                         }
 690                 }
 691
 692                 if (!err && ddr) {
 693                         err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
 694                                          EXT_CSD_BUS_WIDTH,
 695                                          ext_csd_bits[idx][1],
 696                                          0);
 697                 }
 698                 if (err) {
 699                         printk(KERN_WARNING "%s: switch to bus width %d ddr %d "
 700                                 "failed\n", mmc_hostname(card->host),
 701                                 1 << bus_width, ddr);
 702                         goto free_card;
 703                 } else if (ddr) {
 704                         /*
 705                          * eMMC cards can support 3.3V to 1.2V i/o (vccq)
 706                          * signaling.
 707                          *
 708                          * EXT_CSD_CARD_TYPE_DDR_1_8V means 3.3V or 1.8V vccq.
 709                          *
 710                          * 1.8V vccq at 3.3V core voltage (vcc) is not required
 711                          * in the JEDEC spec for DDR.
 712                          *
 713                          * Do not force change in vccq since we are obviously
 714                          * working and no change to vccq is needed.
 715                          *
 716                          * WARNING: eMMC rules are NOT the same as SD DDR
 717                          */
 718                         if (ddr == EXT_CSD_CARD_TYPE_DDR_1_2V) {
 719                                 err = mmc_set_signal_voltage(host,
 720                                         MMC_SIGNAL_VOLTAGE_120, 0);
 721                                 if (err)
 722                                         goto err;
 723                         }
 724                         mmc_card_set_ddr_mode(card);
 725                         mmc_set_timing(card->host, MMC_TIMING_UHS_DDR50);
 726                         mmc_set_bus_width(card->host, bus_width);
 727                 }
 728         }
 729
 730         if (!oldcard)
 731                 host->card = card;
 732
 733         return 0;
 734
 735 free_card:
 736         if (!oldcard)
 737                 mmc_remove_card(card);
 738 err:
 739
 740         return err;
 741 }
 742
 743 /*
 744  * Host is being removed. Free up the current card.
 745  */
 746 static void mmc_remove(struct mmc_host *host)
 747 {
 748         BUG_ON(!host);
 749         BUG_ON(!host->card);
 750
 751         mmc_remove_card(host->card);
 752         host->card = NULL;
 753 }
 754
 755 /*
 756  * Card detection callback from host.
 757  */
 758 static void mmc_detect(struct mmc_host *host)
 759 {
 760         int err;
 761
 762         BUG_ON(!host);
 763         BUG_ON(!host->card);
 764
 765         mmc_claim_host(host);
 766
 767         /*
 768          * Just check if our card has been removed.
 769          */
 770         err = mmc_send_status(host->card, NULL);
 771
 772         mmc_release_host(host);
 773
 774         if (err) {
 775                 mmc_remove(host);
 776
 777                 mmc_claim_host(host);
 778                 mmc_detach_bus(host);
 779                 mmc_release_host(host);
 780         }
 781 }
 782
 783 /*
 784  * Suspend callback from host.
 785  */
 786 static int mmc_suspend(struct mmc_host *host)
 787 {
 788         BUG_ON(!host);
 789         BUG_ON(!host->card);
 790
 791         mmc_claim_host(host);
 792         if (!mmc_host_is_spi(host))
 793                 mmc_deselect_cards(host);
 794         host->card->state &= ~MMC_STATE_HIGHSPEED;
 795         mmc_release_host(host);
 796
 797         return 0;
 798 }
 799
 800 /*
 801  * Resume callback from host.
 802  *
 803  * This function tries to determine if the same card is still present
 804  * and, if so, restore all state to it.
 805  */
 806 static int mmc_resume(struct mmc_host *host)
 807 {
 808         int err;
 809
 810         BUG_ON(!host);
 811         BUG_ON(!host->card);
 812
 813         mmc_claim_host(host);
 814         err = mmc_init_card(host, host->ocr, host->card);
 815         mmc_release_host(host);
 816
 817         return err;
 818 }
 819
 820 static int mmc_power_restore(struct mmc_host *host)
 821 {
 822         int ret;
 823
 824         host->card->state &= ~MMC_STATE_HIGHSPEED;
 825         mmc_claim_host(host);
 826         ret = mmc_init_card(host, host->ocr, host->card);
 827         mmc_release_host(host);
 828
 829         return ret;
 830 }
 831
 832 static int mmc_sleep(struct mmc_host *host)
 833 {
 834         struct mmc_card *card = host->card;
 835         int err = -ENOSYS;
 836
 837         if (card && card->ext_csd.rev >= 3) {
 838                 err = mmc_card_sleepawake(host, 1);
 839                 if (err < 0)
 840                         pr_debug("%s: Error %d while putting card into sleep",
 841                                  mmc_hostname(host), err);
 842         }
 843
 844         return err;
 845 }
 846
 847 static int mmc_awake(struct mmc_host *host)
 848 {
 849         struct mmc_card *card = host->card;
 850         int err = -ENOSYS;
 851
 852         if (card && card->ext_csd.rev >= 3) {
 853                 err = mmc_card_sleepawake(host, 0);
 854                 if (err < 0)
 855                         pr_debug("%s: Error %d while awaking sleeping card",
 856                                  mmc_hostname(host), err);
 857         }
 858
 859         return err;
 860 }
 861
 862 static const struct mmc_bus_ops mmc_ops = {
 863         .awake = mmc_awake,
 864         .sleep = mmc_sleep,
 865         .remove = mmc_remove,
 866         .detect = mmc_detect,
 867         .suspend = NULL,
 868         .resume = NULL,
 869         .power_restore = mmc_power_restore,
 870 };
 871
 872 static const struct mmc_bus_ops mmc_ops_unsafe = {
 873         .awake = mmc_awake,
 874         .sleep = mmc_sleep,
 875         .remove = mmc_remove,
 876         .detect = mmc_detect,
 877         .suspend = mmc_suspend,
 878         .resume = mmc_resume,
 879         .power_restore = mmc_power_restore,
 880 };
 881
 882 static void mmc_attach_bus_ops(struct mmc_host *host)
 883 {
 884         const struct mmc_bus_ops *bus_ops;
 885
 886         if (!mmc_card_is_removable(host))
 887                 bus_ops = &mmc_ops_unsafe;
 888         else
 889                 bus_ops = &mmc_ops;
 890         mmc_attach_bus(host, bus_ops);
 891 }
 892
 893 /*
 894  * Starting point for MMC card init.
 895  */
 896 int mmc_attach_mmc(struct mmc_host *host)
 897 {
 898         int err;
 899         u32 ocr;
 900
 901         BUG_ON(!host);
 902         WARN_ON(!host->claimed);
 903
 904         err = mmc_send_op_cond(host, 0, &ocr);
 905         if (err)
 906                 return err;
 907
 908         mmc_attach_bus_ops(host);
 909         if (host->ocr_avail_mmc)
 910                 host->ocr_avail = host->ocr_avail_mmc;
 911
 912         /*
 913          * We need to get OCR a different way for SPI.
 914          */
 915         if (mmc_host_is_spi(host)) {
 916                 err = mmc_spi_read_ocr(host, 1, &ocr);
 917                 if (err)
 918                         goto err;
 919         }
 920
 921         /*
 922          * Sanity check the voltages that the card claims to
 923          * support.
 924          */
 925         if (ocr & 0x7F) {
 926                 printk(KERN_WARNING "%s: card claims to support voltages "
 927                        "below the defined range. These will be ignored.\n",
 928                        mmc_hostname(host));
 929                 ocr &= ~0x7F;
 930         }
 931
 932         host->ocr = mmc_select_voltage(host, ocr);
 933
 934         /*
 935          * Can we support the voltage of the card?
 936          */
 937         if (!host->ocr) {
 938                 err = -EINVAL;
 939                 goto err;
 940         }
 941
 942         /*
 943          * Detect and init the card.
 944          */
 945         err = mmc_init_card(host, host->ocr, NULL);
 946         if (err)
 947                 goto err;
 948
 949         mmc_release_host(host);
 950         err = mmc_add_card(host->card);
 951         mmc_claim_host(host);
 952         if (err)
 953                 goto remove_card;
 954
 955         return 0;
 956
 957 remove_card:
 958         mmc_release_host(host);
 959         mmc_remove_card(host->card);
 960         mmc_claim_host(host);
 961         host->card = NULL;
 962 err:
 963         mmc_detach_bus(host);
 964
 965         printk(KERN_ERR "%s: error %d whilst initialising MMC card\n",
 966                 mmc_hostname(host), err);
 967
 968         return err;
 969 }