drivers/mmc/core/mmc.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *  linux/drivers/mmc/core/mmc.c
   4  *
   5  *  Copyright (C) 2003-2004 Russell King, All Rights Reserved.
   6  *  Copyright (C) 2005-2007 Pierre Ossman, All Rights Reserved.
   7  *  MMCv4 support Copyright (C) 2006 Philip Langdale, All Rights Reserved.
   8  */
   9
  10 #include <linux/err.h>
  11 #include <linux/of.h>
  12 #include <linux/slab.h>
  13 #include <linux/stat.h>
  14 #include <linux/pm_runtime.h>
  15 #include <linux/random.h>
  16 #include <linux/sysfs.h>
  17
  18 #include <linux/mmc/host.h>
  19 #include <linux/mmc/card.h>
  20 #include <linux/mmc/mmc.h>
  21
  22 #include "core.h"
  23 #include "card.h"
  24 #include "host.h"
  25 #include "bus.h"
  26 #include "mmc_ops.h"
  27 #include "quirks.h"
  28 #include "sd_ops.h"
  29 #include "pwrseq.h"
  30
  31 #define DEFAULT_CMD6_TIMEOUT_MS 500
  32 #define MIN_CACHE_EN_TIMEOUT_MS 1600
  33 #define CACHE_FLUSH_TIMEOUT_MS 30000 /* 30s */
  34
  35 static const unsigned int tran_exp[] = {
  36         10000,          100000,         1000000,        10000000,
  37         0,              0,              0,              0
  38 };
  39
  40 static const unsigned char tran_mant[] = {
  41         0,      10,     12,     13,     15,     20,     25,     30,
  42         35,     40,     45,     50,     55,     60,     70,     80,
  43 };
  44
  45 static const unsigned int taac_exp[] = {
  46         1,      10,     100,    1000,   10000,  100000, 1000000, 10000000,
  47 };
  48
  49 static const unsigned int taac_mant[] = {
  50         0,      10,     12,     13,     15,     20,     25,     30,
  51         35,     40,     45,     50,     55,     60,     70,     80,
  52 };
  53
  54 #define UNSTUFF_BITS(resp,start,size)                                   \
  55         ({                                                              \
  56                 const int __size = size;                                \
  57                 const u32 __mask = (__size < 32 ? 1 << __size : 0) - 1; \
  58                 const int __off = 3 - ((start) / 32);                   \
  59                 const int __shft = (start) & 31;                        \
  60                 u32 __res;                                              \
  61                                                                         \
  62                 __res = resp[__off] >> __shft;                          \
  63                 if (__size + __shft > 32)                               \
  64                         __res |= resp[__off-1] << ((32 - __shft) % 32); \
  65                 __res & __mask;                                         \
  66         })
  67
  68 /*
  69  * Given the decoded CSD structure, decode the raw CID to our CID structure.
  70  */
  71 static int mmc_decode_cid(struct mmc_card *card)
  72 {
  73         u32 *resp = card->raw_cid;
  74
  75         /*
  76          * Add the raw card ID (cid) data to the entropy pool. It doesn't
  77          * matter that not all of it is unique, it's just bonus entropy.
  78          */
  79         add_device_randomness(&card->raw_cid, sizeof(card->raw_cid));
  80
  81         /*
  82          * The selection of the format here is based upon published
  83          * specs from sandisk and from what people have reported.
  84          */
  85         switch (card->csd.mmca_vsn) {
  86         case 0: /* MMC v1.0 - v1.2 */
  87         case 1: /* MMC v1.4 */
  88                 card->cid.manfid        = UNSTUFF_BITS(resp, 104, 24);
  89                 card->cid.prod_name[0]  = UNSTUFF_BITS(resp, 96, 8);
  90                 card->cid.prod_name[1]  = UNSTUFF_BITS(resp, 88, 8);
  91                 card->cid.prod_name[2]  = UNSTUFF_BITS(resp, 80, 8);
  92                 card->cid.prod_name[3]  = UNSTUFF_BITS(resp, 72, 8);
  93                 card->cid.prod_name[4]  = UNSTUFF_BITS(resp, 64, 8);
  94                 card->cid.prod_name[5]  = UNSTUFF_BITS(resp, 56, 8);
  95                 card->cid.prod_name[6]  = UNSTUFF_BITS(resp, 48, 8);
  96                 card->cid.hwrev         = UNSTUFF_BITS(resp, 44, 4);
  97                 card->cid.fwrev         = UNSTUFF_BITS(resp, 40, 4);
  98                 card->cid.serial        = UNSTUFF_BITS(resp, 16, 24);
  99                 card->cid.month         = UNSTUFF_BITS(resp, 12, 4);
 100                 card->cid.year          = UNSTUFF_BITS(resp, 8, 4) + 1997;
 101                 break;
 102
 103         case 2: /* MMC v2.0 - v2.2 */
 104         case 3: /* MMC v3.1 - v3.3 */
 105         case 4: /* MMC v4 */
 106                 card->cid.manfid        = UNSTUFF_BITS(resp, 120, 8);
 107                 card->cid.oemid         = UNSTUFF_BITS(resp, 104, 16);
 108                 card->cid.prod_name[0]  = UNSTUFF_BITS(resp, 96, 8);
 109                 card->cid.prod_name[1]  = UNSTUFF_BITS(resp, 88, 8);
 110                 card->cid.prod_name[2]  = UNSTUFF_BITS(resp, 80, 8);
 111                 card->cid.prod_name[3]  = UNSTUFF_BITS(resp, 72, 8);
 112                 card->cid.prod_name[4]  = UNSTUFF_BITS(resp, 64, 8);
 113                 card->cid.prod_name[5]  = UNSTUFF_BITS(resp, 56, 8);
 114                 card->cid.prv           = UNSTUFF_BITS(resp, 48, 8);
 115                 card->cid.serial        = UNSTUFF_BITS(resp, 16, 32);
 116                 card->cid.month         = UNSTUFF_BITS(resp, 12, 4);
 117                 card->cid.year          = UNSTUFF_BITS(resp, 8, 4) + 1997;
 118                 break;
 119
 120         default:
 121                 pr_err("%s: card has unknown MMCA version %d\n",
 122                         mmc_hostname(card->host), card->csd.mmca_vsn);
 123                 return -EINVAL;
 124         }
 125
 126         return 0;
 127 }
 128
 129 static void mmc_set_erase_size(struct mmc_card *card)
 130 {
 131         if (card->ext_csd.erase_group_def & 1)
 132                 card->erase_size = card->ext_csd.hc_erase_size;
 133         else
 134                 card->erase_size = card->csd.erase_size;
 135
 136         mmc_init_erase(card);
 137 }
 138
 139 /*
 140  * Given a 128-bit response, decode to our card CSD structure.
 141  */
 142 static int mmc_decode_csd(struct mmc_card *card)
 143 {
 144         struct mmc_csd *csd = &card->csd;
 145         unsigned int e, m, a, b;
 146         u32 *resp = card->raw_csd;
 147
 148         /*
 149          * We only understand CSD structure v1.1 and v1.2.
 150          * v1.2 has extra information in bits 15, 11 and 10.
 151          * We also support eMMC v4.4 & v4.41.
 152          */
 153         csd->structure = UNSTUFF_BITS(resp, 126, 2);
 154         if (csd->structure == 0) {
 155                 pr_err("%s: unrecognised CSD structure version %d\n",
 156                         mmc_hostname(card->host), csd->structure);
 157                 return -EINVAL;
 158         }
 159
 160         csd->mmca_vsn    = UNSTUFF_BITS(resp, 122, 4);
 161         m = UNSTUFF_BITS(resp, 115, 4);
 162         e = UNSTUFF_BITS(resp, 112, 3);
 163         csd->taac_ns     = (taac_exp[e] * taac_mant[m] + 9) / 10;
 164         csd->taac_clks   = UNSTUFF_BITS(resp, 104, 8) * 100;
 165
 166         m = UNSTUFF_BITS(resp, 99, 4);
 167         e = UNSTUFF_BITS(resp, 96, 3);
 168         csd->max_dtr      = tran_exp[e] * tran_mant[m];
 169         csd->cmdclass     = UNSTUFF_BITS(resp, 84, 12);
 170
 171         e = UNSTUFF_BITS(resp, 47, 3);
 172         m = UNSTUFF_BITS(resp, 62, 12);
 173         csd->capacity     = (1 + m) << (e + 2);
 174
 175         csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4);
 176         csd->read_partial = UNSTUFF_BITS(resp, 79, 1);
 177         csd->write_misalign = UNSTUFF_BITS(resp, 78, 1);
 178         csd->read_misalign = UNSTUFF_BITS(resp, 77, 1);
 179         csd->dsr_imp = UNSTUFF_BITS(resp, 76, 1);
 180         csd->r2w_factor = UNSTUFF_BITS(resp, 26, 3);
 181         csd->write_blkbits = UNSTUFF_BITS(resp, 22, 4);
 182         csd->write_partial = UNSTUFF_BITS(resp, 21, 1);
 183
 184         if (csd->write_blkbits >= 9) {
 185                 a = UNSTUFF_BITS(resp, 42, 5);
 186                 b = UNSTUFF_BITS(resp, 37, 5);
 187                 csd->erase_size = (a + 1) * (b + 1);
 188                 csd->erase_size <<= csd->write_blkbits - 9;
 189         }
 190
 191         return 0;
 192 }
 193
 194 static void mmc_select_card_type(struct mmc_card *card)
 195 {
 196         struct mmc_host *host = card->host;
 197         u8 card_type = card->ext_csd.raw_card_type;
 198         u32 caps = host->caps, caps2 = host->caps2;
 199         unsigned int hs_max_dtr = 0, hs200_max_dtr = 0;
 200         unsigned int avail_type = 0;
 201
 202         if (caps & MMC_CAP_MMC_HIGHSPEED &&
 203             card_type & EXT_CSD_CARD_TYPE_HS_26) {
 204                 hs_max_dtr = MMC_HIGH_26_MAX_DTR;
 205                 avail_type |= EXT_CSD_CARD_TYPE_HS_26;
 206         }
 207
 208         if (caps & MMC_CAP_MMC_HIGHSPEED &&
 209             card_type & EXT_CSD_CARD_TYPE_HS_52) {
 210                 hs_max_dtr = MMC_HIGH_52_MAX_DTR;
 211                 avail_type |= EXT_CSD_CARD_TYPE_HS_52;
 212         }
 213
 214         if (caps & (MMC_CAP_1_8V_DDR | MMC_CAP_3_3V_DDR) &&
 215             card_type & EXT_CSD_CARD_TYPE_DDR_1_8V) {
 216                 hs_max_dtr = MMC_HIGH_DDR_MAX_DTR;
 217                 avail_type |= EXT_CSD_CARD_TYPE_DDR_1_8V;
 218         }
 219
 220         if (caps & MMC_CAP_1_2V_DDR &&
 221             card_type & EXT_CSD_CARD_TYPE_DDR_1_2V) {
 222                 hs_max_dtr = MMC_HIGH_DDR_MAX_DTR;
 223                 avail_type |= EXT_CSD_CARD_TYPE_DDR_1_2V;
 224         }
 225
 226         if (caps2 & MMC_CAP2_HS200_1_8V_SDR &&
 227             card_type & EXT_CSD_CARD_TYPE_HS200_1_8V) {
 228                 hs200_max_dtr = MMC_HS200_MAX_DTR;
 229                 avail_type |= EXT_CSD_CARD_TYPE_HS200_1_8V;
 230         }
 231
 232         if (caps2 & MMC_CAP2_HS200_1_2V_SDR &&
 233             card_type & EXT_CSD_CARD_TYPE_HS200_1_2V) {
 234                 hs200_max_dtr = MMC_HS200_MAX_DTR;
 235                 avail_type |= EXT_CSD_CARD_TYPE_HS200_1_2V;
 236         }
 237
 238         if (caps2 & MMC_CAP2_HS400_1_8V &&
 239             card_type & EXT_CSD_CARD_TYPE_HS400_1_8V) {
 240                 hs200_max_dtr = MMC_HS200_MAX_DTR;
 241                 avail_type |= EXT_CSD_CARD_TYPE_HS400_1_8V;
 242         }
 243
 244         if (caps2 & MMC_CAP2_HS400_1_2V &&
 245             card_type & EXT_CSD_CARD_TYPE_HS400_1_2V) {
 246                 hs200_max_dtr = MMC_HS200_MAX_DTR;
 247                 avail_type |= EXT_CSD_CARD_TYPE_HS400_1_2V;
 248         }
 249
 250         if ((caps2 & MMC_CAP2_HS400_ES) &&
 251             card->ext_csd.strobe_support &&
 252             (avail_type & EXT_CSD_CARD_TYPE_HS400))
 253                 avail_type |= EXT_CSD_CARD_TYPE_HS400ES;
 254
 255         card->ext_csd.hs_max_dtr = hs_max_dtr;
 256         card->ext_csd.hs200_max_dtr = hs200_max_dtr;
 257         card->mmc_avail_type = avail_type;
 258 }
 259
 260 static void mmc_manage_enhanced_area(struct mmc_card *card, u8 *ext_csd)
 261 {
 262         u8 hc_erase_grp_sz, hc_wp_grp_sz;
 263
 264         /*
 265          * Disable these attributes by default
 266          */
 267         card->ext_csd.enhanced_area_offset = -EINVAL;
 268         card->ext_csd.enhanced_area_size = -EINVAL;
 269
 270         /*
 271          * Enhanced area feature support -- check whether the eMMC
 272          * card has the Enhanced area enabled.  If so, export enhanced
 273          * area offset and size to user by adding sysfs interface.
 274          */
 275         if ((ext_csd[EXT_CSD_PARTITION_SUPPORT] & 0x2) &&
 276             (ext_csd[EXT_CSD_PARTITION_ATTRIBUTE] & 0x1)) {
 277                 if (card->ext_csd.partition_setting_completed) {
 278                         hc_erase_grp_sz =
 279                                 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
 280                         hc_wp_grp_sz =
 281                                 ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
 282
 283                         /*
 284                          * calculate the enhanced data area offset, in bytes
 285                          */
 286                         card->ext_csd.enhanced_area_offset =
 287                                 (((unsigned long long)ext_csd[139]) << 24) +
 288                                 (((unsigned long long)ext_csd[138]) << 16) +
 289                                 (((unsigned long long)ext_csd[137]) << 8) +
 290                                 (((unsigned long long)ext_csd[136]));
 291                         if (mmc_card_blockaddr(card))
 292                                 card->ext_csd.enhanced_area_offset <<= 9;
 293                         /*
 294                          * calculate the enhanced data area size, in kilobytes
 295                          */
 296                         card->ext_csd.enhanced_area_size =
 297                                 (ext_csd[142] << 16) + (ext_csd[141] << 8) +
 298                                 ext_csd[140];
 299                         card->ext_csd.enhanced_area_size *=
 300                                 (size_t)(hc_erase_grp_sz * hc_wp_grp_sz);
 301                         card->ext_csd.enhanced_area_size <<= 9;
 302                 } else {
 303                         pr_warn("%s: defines enhanced area without partition setting complete\n",
 304                                 mmc_hostname(card->host));
 305                 }
 306         }
 307 }
 308
 309 static void mmc_part_add(struct mmc_card *card, u64 size,
 310                          unsigned int part_cfg, char *name, int idx, bool ro,
 311                          int area_type)
 312 {
 313         card->part[card->nr_parts].size = size;
 314         card->part[card->nr_parts].part_cfg = part_cfg;
 315         sprintf(card->part[card->nr_parts].name, name, idx);
 316         card->part[card->nr_parts].force_ro = ro;
 317         card->part[card->nr_parts].area_type = area_type;
 318         card->nr_parts++;
 319 }
 320
 321 static void mmc_manage_gp_partitions(struct mmc_card *card, u8 *ext_csd)
 322 {
 323         int idx;
 324         u8 hc_erase_grp_sz, hc_wp_grp_sz;
 325         u64 part_size;
 326
 327         /*
 328          * General purpose partition feature support --
 329          * If ext_csd has the size of general purpose partitions,
 330          * set size, part_cfg, partition name in mmc_part.
 331          */
 332         if (ext_csd[EXT_CSD_PARTITION_SUPPORT] &
 333             EXT_CSD_PART_SUPPORT_PART_EN) {
 334                 hc_erase_grp_sz =
 335                         ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
 336                 hc_wp_grp_sz =
 337                         ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
 338
 339                 for (idx = 0; idx < MMC_NUM_GP_PARTITION; idx++) {
 340                         if (!ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3] &&
 341                             !ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 1] &&
 342                             !ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 2])
 343                                 continue;
 344                         if (card->ext_csd.partition_setting_completed == 0) {
 345                                 pr_warn("%s: has partition size defined without partition complete\n",
 346                                         mmc_hostname(card->host));
 347                                 break;
 348                         }
 349                         part_size =
 350                                 (ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 2]
 351                                 << 16) +
 352                                 (ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 1]
 353                                 << 8) +
 354                                 ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3];
 355                         part_size *= (hc_erase_grp_sz * hc_wp_grp_sz);
 356                         mmc_part_add(card, part_size << 19,
 357                                 EXT_CSD_PART_CONFIG_ACC_GP0 + idx,
 358                                 "gp%d", idx, false,
 359                                 MMC_BLK_DATA_AREA_GP);
 360                 }
 361         }
 362 }
 363
 364 /* Minimum partition switch timeout in milliseconds */
 365 #define MMC_MIN_PART_SWITCH_TIME        300
 366
 367 /*
 368  * Decode extended CSD.
 369  */
 370 static int mmc_decode_ext_csd(struct mmc_card *card, u8 *ext_csd)
 371 {
 372         int err = 0, idx;
 373         u64 part_size;
 374         struct device_node *np;
 375         bool broken_hpi = false;
 376
 377         /* Version is coded in the CSD_STRUCTURE byte in the EXT_CSD register */
 378         card->ext_csd.raw_ext_csd_structure = ext_csd[EXT_CSD_STRUCTURE];
 379         if (card->csd.structure == 3) {
 380                 if (card->ext_csd.raw_ext_csd_structure > 2) {
 381                         pr_err("%s: unrecognised EXT_CSD structure "
 382                                 "version %d\n", mmc_hostname(card->host),
 383                                         card->ext_csd.raw_ext_csd_structure);
 384                         err = -EINVAL;
 385                         goto out;
 386                 }
 387         }
 388
 389         np = mmc_of_find_child_device(card->host, 0);
 390         if (np && of_device_is_compatible(np, "mmc-card"))
 391                 broken_hpi = of_property_read_bool(np, "broken-hpi");
 392         of_node_put(np);
 393
 394         /*
 395          * The EXT_CSD format is meant to be forward compatible. As long
 396          * as CSD_STRUCTURE does not change, all values for EXT_CSD_REV
 397          * are authorized, see JEDEC JESD84-B50 section B.8.
 398          */
 399         card->ext_csd.rev = ext_csd[EXT_CSD_REV];
 400
 401         /* fixup device after ext_csd revision field is updated */
 402         mmc_fixup_device(card, mmc_ext_csd_fixups);
 403
 404         card->ext_csd.raw_sectors[0] = ext_csd[EXT_CSD_SEC_CNT + 0];
 405         card->ext_csd.raw_sectors[1] = ext_csd[EXT_CSD_SEC_CNT + 1];
 406         card->ext_csd.raw_sectors[2] = ext_csd[EXT_CSD_SEC_CNT + 2];
 407         card->ext_csd.raw_sectors[3] = ext_csd[EXT_CSD_SEC_CNT + 3];
 408         if (card->ext_csd.rev >= 2) {
 409                 card->ext_csd.sectors =
 410                         ext_csd[EXT_CSD_SEC_CNT + 0] << 0 |
 411                         ext_csd[EXT_CSD_SEC_CNT + 1] << 8 |
 412                         ext_csd[EXT_CSD_SEC_CNT + 2] << 16 |
 413                         ext_csd[EXT_CSD_SEC_CNT + 3] << 24;
 414
 415                 /* Cards with density > 2GiB are sector addressed */
 416                 if (card->ext_csd.sectors > (2u * 1024 * 1024 * 1024) / 512)
 417                         mmc_card_set_blockaddr(card);
 418         }
 419
 420         card->ext_csd.strobe_support = ext_csd[EXT_CSD_STROBE_SUPPORT];
 421         card->ext_csd.raw_card_type = ext_csd[EXT_CSD_CARD_TYPE];
 422
 423         card->ext_csd.raw_s_a_timeout = ext_csd[EXT_CSD_S_A_TIMEOUT];
 424         card->ext_csd.raw_erase_timeout_mult =
 425                 ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT];
 426         card->ext_csd.raw_hc_erase_grp_size =
 427                 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
 428         card->ext_csd.raw_boot_mult =
 429                 ext_csd[EXT_CSD_BOOT_MULT];
 430         if (card->ext_csd.rev >= 3) {
 431                 u8 sa_shift = ext_csd[EXT_CSD_S_A_TIMEOUT];
 432                 card->ext_csd.part_config = ext_csd[EXT_CSD_PART_CONFIG];
 433
 434                 /* EXT_CSD value is in units of 10ms, but we store in ms */
 435                 card->ext_csd.part_time = 10 * ext_csd[EXT_CSD_PART_SWITCH_TIME];
 436
 437                 /* Sleep / awake timeout in 100ns units */
 438                 if (sa_shift > 0 && sa_shift <= 0x17)
 439                         card->ext_csd.sa_timeout =
 440                                         1 << ext_csd[EXT_CSD_S_A_TIMEOUT];
 441                 card->ext_csd.erase_group_def =
 442                         ext_csd[EXT_CSD_ERASE_GROUP_DEF];
 443                 card->ext_csd.hc_erase_timeout = 300 *
 444                         ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT];
 445                 card->ext_csd.hc_erase_size =
 446                         ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] << 10;
 447
 448                 card->ext_csd.rel_sectors = ext_csd[EXT_CSD_REL_WR_SEC_C];
 449
 450                 /*
 451                  * There are two boot regions of equal size, defined in
 452                  * multiples of 128K.
 453                  */
 454                 if (ext_csd[EXT_CSD_BOOT_MULT] && mmc_boot_partition_access(card->host)) {
 455                         for (idx = 0; idx < MMC_NUM_BOOT_PARTITION; idx++) {
 456                                 part_size = ext_csd[EXT_CSD_BOOT_MULT] << 17;
 457                                 mmc_part_add(card, part_size,
 458                                         EXT_CSD_PART_CONFIG_ACC_BOOT0 + idx,
 459                                         "boot%d", idx, true,
 460                                         MMC_BLK_DATA_AREA_BOOT);
 461                         }
 462                 }
 463         }
 464
 465         card->ext_csd.raw_hc_erase_gap_size =
 466                 ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
 467         card->ext_csd.raw_sec_trim_mult =
 468                 ext_csd[EXT_CSD_SEC_TRIM_MULT];
 469         card->ext_csd.raw_sec_erase_mult =
 470                 ext_csd[EXT_CSD_SEC_ERASE_MULT];
 471         card->ext_csd.raw_sec_feature_support =
 472                 ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT];
 473         card->ext_csd.raw_trim_mult =
 474                 ext_csd[EXT_CSD_TRIM_MULT];
 475         card->ext_csd.raw_partition_support = ext_csd[EXT_CSD_PARTITION_SUPPORT];
 476         card->ext_csd.raw_driver_strength = ext_csd[EXT_CSD_DRIVER_STRENGTH];
 477         if (card->ext_csd.rev >= 4) {
 478                 if (ext_csd[EXT_CSD_PARTITION_SETTING_COMPLETED] &
 479                     EXT_CSD_PART_SETTING_COMPLETED)
 480                         card->ext_csd.partition_setting_completed = 1;
 481                 else
 482                         card->ext_csd.partition_setting_completed = 0;
 483
 484                 mmc_manage_enhanced_area(card, ext_csd);
 485
 486                 mmc_manage_gp_partitions(card, ext_csd);
 487
 488                 card->ext_csd.sec_trim_mult =
 489                         ext_csd[EXT_CSD_SEC_TRIM_MULT];
 490                 card->ext_csd.sec_erase_mult =
 491                         ext_csd[EXT_CSD_SEC_ERASE_MULT];
 492                 card->ext_csd.sec_feature_support =
 493                         ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT];
 494                 card->ext_csd.trim_timeout = 300 *
 495                         ext_csd[EXT_CSD_TRIM_MULT];
 496
 497                 /*
 498                  * Note that the call to mmc_part_add above defaults to read
 499                  * only. If this default assumption is changed, the call must
 500                  * take into account the value of boot_locked below.
 501                  */
 502                 card->ext_csd.boot_ro_lock = ext_csd[EXT_CSD_BOOT_WP];
 503                 card->ext_csd.boot_ro_lockable = true;
 504
 505                 /* Save power class values */
 506                 card->ext_csd.raw_pwr_cl_52_195 =
 507                         ext_csd[EXT_CSD_PWR_CL_52_195];
 508                 card->ext_csd.raw_pwr_cl_26_195 =
 509                         ext_csd[EXT_CSD_PWR_CL_26_195];
 510                 card->ext_csd.raw_pwr_cl_52_360 =
 511                         ext_csd[EXT_CSD_PWR_CL_52_360];
 512                 card->ext_csd.raw_pwr_cl_26_360 =
 513                         ext_csd[EXT_CSD_PWR_CL_26_360];
 514                 card->ext_csd.raw_pwr_cl_200_195 =
 515                         ext_csd[EXT_CSD_PWR_CL_200_195];
 516                 card->ext_csd.raw_pwr_cl_200_360 =
 517                         ext_csd[EXT_CSD_PWR_CL_200_360];
 518                 card->ext_csd.raw_pwr_cl_ddr_52_195 =
 519                         ext_csd[EXT_CSD_PWR_CL_DDR_52_195];
 520                 card->ext_csd.raw_pwr_cl_ddr_52_360 =
 521                         ext_csd[EXT_CSD_PWR_CL_DDR_52_360];
 522                 card->ext_csd.raw_pwr_cl_ddr_200_360 =
 523                         ext_csd[EXT_CSD_PWR_CL_DDR_200_360];
 524         }
 525
 526         if (card->ext_csd.rev >= 5) {
 527                 /* Adjust production date as per JEDEC JESD84-B451 */
 528                 if (card->cid.year < 2010)
 529                         card->cid.year += 16;
 530
 531                 /* check whether the eMMC card supports BKOPS */
 532                 if (ext_csd[EXT_CSD_BKOPS_SUPPORT] & 0x1) {
 533                         card->ext_csd.bkops = 1;
 534                         card->ext_csd.man_bkops_en =
 535                                         (ext_csd[EXT_CSD_BKOPS_EN] &
 536                                                 EXT_CSD_MANUAL_BKOPS_MASK);
 537                         card->ext_csd.raw_bkops_status =
 538                                 ext_csd[EXT_CSD_BKOPS_STATUS];
 539                         if (card->ext_csd.man_bkops_en)
 540                                 pr_debug("%s: MAN_BKOPS_EN bit is set\n",
 541                                         mmc_hostname(card->host));
 542                         card->ext_csd.auto_bkops_en =
 543                                         (ext_csd[EXT_CSD_BKOPS_EN] &
 544                                                 EXT_CSD_AUTO_BKOPS_MASK);
 545                         if (card->ext_csd.auto_bkops_en)
 546                                 pr_debug("%s: AUTO_BKOPS_EN bit is set\n",
 547                                         mmc_hostname(card->host));
 548                 }
 549
 550                 /* check whether the eMMC card supports HPI */
 551                 if (!mmc_card_broken_hpi(card) &&
 552                     !broken_hpi && (ext_csd[EXT_CSD_HPI_FEATURES] & 0x1)) {
 553                         card->ext_csd.hpi = 1;
 554                         if (ext_csd[EXT_CSD_HPI_FEATURES] & 0x2)
 555                                 card->ext_csd.hpi_cmd = MMC_STOP_TRANSMISSION;
 556                         else
 557                                 card->ext_csd.hpi_cmd = MMC_SEND_STATUS;
 558                         /*
 559                          * Indicate the maximum timeout to close
 560                          * a command interrupted by HPI
 561                          */
 562                         card->ext_csd.out_of_int_time =
 563                                 ext_csd[EXT_CSD_OUT_OF_INTERRUPT_TIME] * 10;
 564                 }
 565
 566                 card->ext_csd.rel_param = ext_csd[EXT_CSD_WR_REL_PARAM];
 567                 card->ext_csd.rst_n_function = ext_csd[EXT_CSD_RST_N_FUNCTION];
 568
 569                 /*
 570                  * RPMB regions are defined in multiples of 128K.
 571                  */
 572                 card->ext_csd.raw_rpmb_size_mult = ext_csd[EXT_CSD_RPMB_MULT];
 573                 if (ext_csd[EXT_CSD_RPMB_MULT] && mmc_host_cmd23(card->host)) {
 574                         mmc_part_add(card, ext_csd[EXT_CSD_RPMB_MULT] << 17,
 575                                 EXT_CSD_PART_CONFIG_ACC_RPMB,
 576                                 "rpmb", 0, false,
 577                                 MMC_BLK_DATA_AREA_RPMB);
 578                 }
 579         }
 580
 581         card->ext_csd.raw_erased_mem_count = ext_csd[EXT_CSD_ERASED_MEM_CONT];
 582         if (ext_csd[EXT_CSD_ERASED_MEM_CONT])
 583                 card->erased_byte = 0xFF;
 584         else
 585                 card->erased_byte = 0x0;
 586
 587         /* eMMC v4.5 or later */
 588         card->ext_csd.generic_cmd6_time = DEFAULT_CMD6_TIMEOUT_MS;
 589         if (card->ext_csd.rev >= 6) {
 590                 card->ext_csd.feature_support |= MMC_DISCARD_FEATURE;
 591
 592                 card->ext_csd.generic_cmd6_time = 10 *
 593                         ext_csd[EXT_CSD_GENERIC_CMD6_TIME];
 594                 card->ext_csd.power_off_longtime = 10 *
 595                         ext_csd[EXT_CSD_POWER_OFF_LONG_TIME];
 596
 597                 card->ext_csd.cache_size =
 598                         ext_csd[EXT_CSD_CACHE_SIZE + 0] << 0 |
 599                         ext_csd[EXT_CSD_CACHE_SIZE + 1] << 8 |
 600                         ext_csd[EXT_CSD_CACHE_SIZE + 2] << 16 |
 601                         ext_csd[EXT_CSD_CACHE_SIZE + 3] << 24;
 602
 603                 if (ext_csd[EXT_CSD_DATA_SECTOR_SIZE] == 1)
 604                         card->ext_csd.data_sector_size = 4096;
 605                 else
 606                         card->ext_csd.data_sector_size = 512;
 607
 608                 if ((ext_csd[EXT_CSD_DATA_TAG_SUPPORT] & 1) &&
 609                     (ext_csd[EXT_CSD_TAG_UNIT_SIZE] <= 8)) {
 610                         card->ext_csd.data_tag_unit_size =
 611                         ((unsigned int) 1 << ext_csd[EXT_CSD_TAG_UNIT_SIZE]) *
 612                         (card->ext_csd.data_sector_size);
 613                 } else {
 614                         card->ext_csd.data_tag_unit_size = 0;
 615                 }
 616
 617                 card->ext_csd.max_packed_writes =
 618                         ext_csd[EXT_CSD_MAX_PACKED_WRITES];
 619                 card->ext_csd.max_packed_reads =
 620                         ext_csd[EXT_CSD_MAX_PACKED_READS];
 621         } else {
 622                 card->ext_csd.data_sector_size = 512;
 623         }
 624
 625         /*
 626          * GENERIC_CMD6_TIME is to be used "unless a specific timeout is defined
 627          * when accessing a specific field", so use it here if there is no
 628          * PARTITION_SWITCH_TIME.
 629          */
 630         if (!card->ext_csd.part_time)
 631                 card->ext_csd.part_time = card->ext_csd.generic_cmd6_time;
 632         /* Some eMMC set the value too low so set a minimum */
 633         if (card->ext_csd.part_time < MMC_MIN_PART_SWITCH_TIME)
 634                 card->ext_csd.part_time = MMC_MIN_PART_SWITCH_TIME;
 635
 636         /* eMMC v5 or later */
 637         if (card->ext_csd.rev >= 7) {
 638                 memcpy(card->ext_csd.fwrev, &ext_csd[EXT_CSD_FIRMWARE_VERSION],
 639                        MMC_FIRMWARE_LEN);
 640                 card->ext_csd.ffu_capable =
 641                         (ext_csd[EXT_CSD_SUPPORTED_MODE] & 0x1) &&
 642                         !(ext_csd[EXT_CSD_FW_CONFIG] & 0x1);
 643
 644                 card->ext_csd.pre_eol_info = ext_csd[EXT_CSD_PRE_EOL_INFO];
 645                 card->ext_csd.device_life_time_est_typ_a =
 646                         ext_csd[EXT_CSD_DEVICE_LIFE_TIME_EST_TYP_A];
 647                 card->ext_csd.device_life_time_est_typ_b =
 648                         ext_csd[EXT_CSD_DEVICE_LIFE_TIME_EST_TYP_B];
 649         }
 650
 651         /* eMMC v5.1 or later */
 652         if (card->ext_csd.rev >= 8) {
 653                 card->ext_csd.cmdq_support = ext_csd[EXT_CSD_CMDQ_SUPPORT] &
 654                                              EXT_CSD_CMDQ_SUPPORTED;
 655                 card->ext_csd.cmdq_depth = (ext_csd[EXT_CSD_CMDQ_DEPTH] &
 656                                             EXT_CSD_CMDQ_DEPTH_MASK) + 1;
 657                 /* Exclude inefficiently small queue depths */
 658                 if (card->ext_csd.cmdq_depth <= 2) {
 659                         card->ext_csd.cmdq_support = false;
 660                         card->ext_csd.cmdq_depth = 0;
 661                 }
 662                 if (card->ext_csd.cmdq_support) {
 663                         pr_debug("%s: Command Queue supported depth %u\n",
 664                                  mmc_hostname(card->host),
 665                                  card->ext_csd.cmdq_depth);
 666                 }
 667                 card->ext_csd.enhanced_rpmb_supported =
 668                                         (card->ext_csd.rel_param &
 669                                          EXT_CSD_WR_REL_PARAM_EN_RPMB_REL_WR);
 670         }
 671 out:
 672         return err;
 673 }
 674
 675 static int mmc_read_ext_csd(struct mmc_card *card)
 676 {
 677         u8 *ext_csd;
 678         int err;
 679
 680         if (!mmc_can_ext_csd(card))
 681                 return 0;
 682
 683         err = mmc_get_ext_csd(card, &ext_csd);
 684         if (err) {
 685                 /* If the host or the card can't do the switch,
 686                  * fail more gracefully. */
 687                 if ((err != -EINVAL)
 688                  && (err != -ENOSYS)
 689                  && (err != -EFAULT))
 690                         return err;
 691
 692                 /*
 693                  * High capacity cards should have this "magic" size
 694                  * stored in their CSD.
 695                  */
 696                 if (card->csd.capacity == (4096 * 512)) {
 697                         pr_err("%s: unable to read EXT_CSD on a possible high capacity card. Card will be ignored.\n",
 698                                 mmc_hostname(card->host));
 699                 } else {
 700                         pr_warn("%s: unable to read EXT_CSD, performance might suffer\n",
 701                                 mmc_hostname(card->host));
 702                         err = 0;
 703                 }
 704
 705                 return err;
 706         }
 707
 708         err = mmc_decode_ext_csd(card, ext_csd);
 709         kfree(ext_csd);
 710         return err;
 711 }
 712
 713 static int mmc_compare_ext_csds(struct mmc_card *card, unsigned bus_width)
 714 {
 715         u8 *bw_ext_csd;
 716         int err;
 717
 718         if (bus_width == MMC_BUS_WIDTH_1)
 719                 return 0;
 720
 721         err = mmc_get_ext_csd(card, &bw_ext_csd);
 722         if (err)
 723                 return err;
 724
 725         /* only compare read only fields */
 726         err = !((card->ext_csd.raw_partition_support ==
 727                         bw_ext_csd[EXT_CSD_PARTITION_SUPPORT]) &&
 728                 (card->ext_csd.raw_erased_mem_count ==
 729                         bw_ext_csd[EXT_CSD_ERASED_MEM_CONT]) &&
 730                 (card->ext_csd.rev ==
 731                         bw_ext_csd[EXT_CSD_REV]) &&
 732                 (card->ext_csd.raw_ext_csd_structure ==
 733                         bw_ext_csd[EXT_CSD_STRUCTURE]) &&
 734                 (card->ext_csd.raw_card_type ==
 735                         bw_ext_csd[EXT_CSD_CARD_TYPE]) &&
 736                 (card->ext_csd.raw_s_a_timeout ==
 737                         bw_ext_csd[EXT_CSD_S_A_TIMEOUT]) &&
 738                 (card->ext_csd.raw_hc_erase_gap_size ==
 739                         bw_ext_csd[EXT_CSD_HC_WP_GRP_SIZE]) &&
 740                 (card->ext_csd.raw_erase_timeout_mult ==
 741                         bw_ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT]) &&
 742                 (card->ext_csd.raw_hc_erase_grp_size ==
 743                         bw_ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]) &&
 744                 (card->ext_csd.raw_sec_trim_mult ==
 745                         bw_ext_csd[EXT_CSD_SEC_TRIM_MULT]) &&
 746                 (card->ext_csd.raw_sec_erase_mult ==
 747                         bw_ext_csd[EXT_CSD_SEC_ERASE_MULT]) &&
 748                 (card->ext_csd.raw_sec_feature_support ==
 749                         bw_ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT]) &&
 750                 (card->ext_csd.raw_trim_mult ==
 751                         bw_ext_csd[EXT_CSD_TRIM_MULT]) &&
 752                 (card->ext_csd.raw_sectors[0] ==
 753                         bw_ext_csd[EXT_CSD_SEC_CNT + 0]) &&
 754                 (card->ext_csd.raw_sectors[1] ==
 755                         bw_ext_csd[EXT_CSD_SEC_CNT + 1]) &&
 756                 (card->ext_csd.raw_sectors[2] ==
 757                         bw_ext_csd[EXT_CSD_SEC_CNT + 2]) &&
 758                 (card->ext_csd.raw_sectors[3] ==
 759                         bw_ext_csd[EXT_CSD_SEC_CNT + 3]) &&
 760                 (card->ext_csd.raw_pwr_cl_52_195 ==
 761                         bw_ext_csd[EXT_CSD_PWR_CL_52_195]) &&
 762                 (card->ext_csd.raw_pwr_cl_26_195 ==
 763                         bw_ext_csd[EXT_CSD_PWR_CL_26_195]) &&
 764                 (card->ext_csd.raw_pwr_cl_52_360 ==
 765                         bw_ext_csd[EXT_CSD_PWR_CL_52_360]) &&
 766                 (card->ext_csd.raw_pwr_cl_26_360 ==
 767                         bw_ext_csd[EXT_CSD_PWR_CL_26_360]) &&
 768                 (card->ext_csd.raw_pwr_cl_200_195 ==
 769                         bw_ext_csd[EXT_CSD_PWR_CL_200_195]) &&
 770                 (card->ext_csd.raw_pwr_cl_200_360 ==
 771                         bw_ext_csd[EXT_CSD_PWR_CL_200_360]) &&
 772                 (card->ext_csd.raw_pwr_cl_ddr_52_195 ==
 773                         bw_ext_csd[EXT_CSD_PWR_CL_DDR_52_195]) &&
 774                 (card->ext_csd.raw_pwr_cl_ddr_52_360 ==
 775                         bw_ext_csd[EXT_CSD_PWR_CL_DDR_52_360]) &&
 776                 (card->ext_csd.raw_pwr_cl_ddr_200_360 ==
 777                         bw_ext_csd[EXT_CSD_PWR_CL_DDR_200_360]));
 778
 779         if (err)
 780                 err = -EINVAL;
 781
 782         kfree(bw_ext_csd);
 783         return err;
 784 }
 785
 786 MMC_DEV_ATTR(cid, "%08x%08x%08x%08x\n", card->raw_cid[0], card->raw_cid[1],
 787         card->raw_cid[2], card->raw_cid[3]);
 788 MMC_DEV_ATTR(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1],
 789         card->raw_csd[2], card->raw_csd[3]);
 790 MMC_DEV_ATTR(date, "%02d/%04d\n", card->cid.month, card->cid.year);
 791 MMC_DEV_ATTR(erase_size, "%u\n", card->erase_size << 9);
 792 MMC_DEV_ATTR(preferred_erase_size, "%u\n", card->pref_erase << 9);
 793 MMC_DEV_ATTR(ffu_capable, "%d\n", card->ext_csd.ffu_capable);
 794 MMC_DEV_ATTR(hwrev, "0x%x\n", card->cid.hwrev);
 795 MMC_DEV_ATTR(manfid, "0x%06x\n", card->cid.manfid);
 796 MMC_DEV_ATTR(name, "%s\n", card->cid.prod_name);
 797 MMC_DEV_ATTR(oemid, "0x%04x\n", card->cid.oemid);
 798 MMC_DEV_ATTR(prv, "0x%x\n", card->cid.prv);
 799 MMC_DEV_ATTR(rev, "0x%x\n", card->ext_csd.rev);
 800 MMC_DEV_ATTR(pre_eol_info, "0x%02x\n", card->ext_csd.pre_eol_info);
 801 MMC_DEV_ATTR(life_time, "0x%02x 0x%02x\n",
 802         card->ext_csd.device_life_time_est_typ_a,
 803         card->ext_csd.device_life_time_est_typ_b);
 804 MMC_DEV_ATTR(serial, "0x%08x\n", card->cid.serial);
 805 MMC_DEV_ATTR(enhanced_area_offset, "%llu\n",
 806                 card->ext_csd.enhanced_area_offset);
 807 MMC_DEV_ATTR(enhanced_area_size, "%u\n", card->ext_csd.enhanced_area_size);
 808 MMC_DEV_ATTR(raw_rpmb_size_mult, "%#x\n", card->ext_csd.raw_rpmb_size_mult);
 809 MMC_DEV_ATTR(enhanced_rpmb_supported, "%#x\n",
 810         card->ext_csd.enhanced_rpmb_supported);
 811 MMC_DEV_ATTR(rel_sectors, "%#x\n", card->ext_csd.rel_sectors);
 812 MMC_DEV_ATTR(ocr, "0x%08x\n", card->ocr);
 813 MMC_DEV_ATTR(rca, "0x%04x\n", card->rca);
 814 MMC_DEV_ATTR(cmdq_en, "%d\n", card->ext_csd.cmdq_en);
 815
 816 static ssize_t mmc_fwrev_show(struct device *dev,
 817                               struct device_attribute *attr,
 818                               char *buf)
 819 {
 820         struct mmc_card *card = mmc_dev_to_card(dev);
 821
 822         if (card->ext_csd.rev < 7)
 823                 return sysfs_emit(buf, "0x%x\n", card->cid.fwrev);
 824         else
 825                 return sysfs_emit(buf, "0x%*phN\n", MMC_FIRMWARE_LEN,
 826                                   card->ext_csd.fwrev);
 827 }
 828
 829 static DEVICE_ATTR(fwrev, S_IRUGO, mmc_fwrev_show, NULL);
 830
 831 static ssize_t mmc_dsr_show(struct device *dev,
 832                             struct device_attribute *attr,
 833                             char *buf)
 834 {
 835         struct mmc_card *card = mmc_dev_to_card(dev);
 836         struct mmc_host *host = card->host;
 837
 838         if (card->csd.dsr_imp && host->dsr_req)
 839                 return sysfs_emit(buf, "0x%x\n", host->dsr);
 840         else
 841                 /* return default DSR value */
 842                 return sysfs_emit(buf, "0x%x\n", 0x404);
 843 }
 844
 845 static DEVICE_ATTR(dsr, S_IRUGO, mmc_dsr_show, NULL);
 846
 847 static struct attribute *mmc_std_attrs[] = {
 848         &dev_attr_cid.attr,
 849         &dev_attr_csd.attr,
 850         &dev_attr_date.attr,
 851         &dev_attr_erase_size.attr,
 852         &dev_attr_preferred_erase_size.attr,
 853         &dev_attr_fwrev.attr,
 854         &dev_attr_ffu_capable.attr,
 855         &dev_attr_hwrev.attr,
 856         &dev_attr_manfid.attr,
 857         &dev_attr_name.attr,
 858         &dev_attr_oemid.attr,
 859         &dev_attr_prv.attr,
 860         &dev_attr_rev.attr,
 861         &dev_attr_pre_eol_info.attr,
 862         &dev_attr_life_time.attr,
 863         &dev_attr_serial.attr,
 864         &dev_attr_enhanced_area_offset.attr,
 865         &dev_attr_enhanced_area_size.attr,
 866         &dev_attr_raw_rpmb_size_mult.attr,
 867         &dev_attr_enhanced_rpmb_supported.attr,
 868         &dev_attr_rel_sectors.attr,
 869         &dev_attr_ocr.attr,
 870         &dev_attr_rca.attr,
 871         &dev_attr_dsr.attr,
 872         &dev_attr_cmdq_en.attr,
 873         NULL,
 874 };
 875 ATTRIBUTE_GROUPS(mmc_std);
 876
 877 static struct device_type mmc_type = {
 878         .groups = mmc_std_groups,
 879 };
 880
 881 /*
 882  * Select the PowerClass for the current bus width
 883  * If power class is defined for 4/8 bit bus in the
 884  * extended CSD register, select it by executing the
 885  * mmc_switch command.
 886  */
 887 static int __mmc_select_powerclass(struct mmc_card *card,
 888                                    unsigned int bus_width)
 889 {
 890         struct mmc_host *host = card->host;
 891         struct mmc_ext_csd *ext_csd = &card->ext_csd;
 892         unsigned int pwrclass_val = 0;
 893         int err = 0;
 894
 895         switch (1 << host->ios.vdd) {
 896         case MMC_VDD_165_195:
 897                 if (host->ios.clock <= MMC_HIGH_26_MAX_DTR)
 898                         pwrclass_val = ext_csd->raw_pwr_cl_26_195;
 899                 else if (host->ios.clock <= MMC_HIGH_52_MAX_DTR)
 900                         pwrclass_val = (bus_width <= EXT_CSD_BUS_WIDTH_8) ?
 901                                 ext_csd->raw_pwr_cl_52_195 :
 902                                 ext_csd->raw_pwr_cl_ddr_52_195;
 903                 else if (host->ios.clock <= MMC_HS200_MAX_DTR)
 904                         pwrclass_val = ext_csd->raw_pwr_cl_200_195;
 905                 break;
 906         case MMC_VDD_27_28:
 907         case MMC_VDD_28_29:
 908         case MMC_VDD_29_30:
 909         case MMC_VDD_30_31:
 910         case MMC_VDD_31_32:
 911         case MMC_VDD_32_33:
 912         case MMC_VDD_33_34:
 913         case MMC_VDD_34_35:
 914         case MMC_VDD_35_36:
 915                 if (host->ios.clock <= MMC_HIGH_26_MAX_DTR)
 916                         pwrclass_val = ext_csd->raw_pwr_cl_26_360;
 917                 else if (host->ios.clock <= MMC_HIGH_52_MAX_DTR)
 918                         pwrclass_val = (bus_width <= EXT_CSD_BUS_WIDTH_8) ?
 919                                 ext_csd->raw_pwr_cl_52_360 :
 920                                 ext_csd->raw_pwr_cl_ddr_52_360;
 921                 else if (host->ios.clock <= MMC_HS200_MAX_DTR)
 922                         pwrclass_val = (bus_width == EXT_CSD_DDR_BUS_WIDTH_8) ?
 923                                 ext_csd->raw_pwr_cl_ddr_200_360 :
 924                                 ext_csd->raw_pwr_cl_200_360;
 925                 break;
 926         default:
 927                 pr_warn("%s: Voltage range not supported for power class\n",
 928                         mmc_hostname(host));
 929                 return -EINVAL;
 930         }
 931
 932         if (bus_width & (EXT_CSD_BUS_WIDTH_8 | EXT_CSD_DDR_BUS_WIDTH_8))
 933                 pwrclass_val = (pwrclass_val & EXT_CSD_PWR_CL_8BIT_MASK) >>
 934                                 EXT_CSD_PWR_CL_8BIT_SHIFT;
 935         else
 936                 pwrclass_val = (pwrclass_val & EXT_CSD_PWR_CL_4BIT_MASK) >>
 937                                 EXT_CSD_PWR_CL_4BIT_SHIFT;
 938
 939         /* If the power class is different from the default value */
 940         if (pwrclass_val > 0) {
 941                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
 942                                  EXT_CSD_POWER_CLASS,
 943                                  pwrclass_val,
 944                                  card->ext_csd.generic_cmd6_time);
 945         }
 946
 947         return err;
 948 }
 949
 950 static int mmc_select_powerclass(struct mmc_card *card)
 951 {
 952         struct mmc_host *host = card->host;
 953         u32 bus_width, ext_csd_bits;
 954         int err, ddr;
 955
 956         /* Power class selection is supported for versions >= 4.0 */
 957         if (!mmc_can_ext_csd(card))
 958                 return 0;
 959
 960         bus_width = host->ios.bus_width;
 961         /* Power class values are defined only for 4/8 bit bus */
 962         if (bus_width == MMC_BUS_WIDTH_1)
 963                 return 0;
 964
 965         ddr = card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_52;
 966         if (ddr)
 967                 ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ?
 968                         EXT_CSD_DDR_BUS_WIDTH_8 : EXT_CSD_DDR_BUS_WIDTH_4;
 969         else
 970                 ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ?
 971                         EXT_CSD_BUS_WIDTH_8 :  EXT_CSD_BUS_WIDTH_4;
 972
 973         err = __mmc_select_powerclass(card, ext_csd_bits);
 974         if (err)
 975                 pr_warn("%s: power class selection to bus width %d ddr %d failed\n",
 976                         mmc_hostname(host), 1 << bus_width, ddr);
 977
 978         return err;
 979 }
 980
 981 /*
 982  * Set the bus speed for the selected speed mode.
 983  */
 984 static void mmc_set_bus_speed(struct mmc_card *card)
 985 {
 986         unsigned int max_dtr = (unsigned int)-1;
 987
 988         if ((mmc_card_hs200(card) || mmc_card_hs400(card)) &&
 989              max_dtr > card->ext_csd.hs200_max_dtr)
 990                 max_dtr = card->ext_csd.hs200_max_dtr;
 991         else if (mmc_card_hs(card) && max_dtr > card->ext_csd.hs_max_dtr)
 992                 max_dtr = card->ext_csd.hs_max_dtr;
 993         else if (max_dtr > card->csd.max_dtr)
 994                 max_dtr = card->csd.max_dtr;
 995
 996         mmc_set_clock(card->host, max_dtr);
 997 }
 998
 999 /*
1000  * Select the bus width amoung 4-bit and 8-bit(SDR).
1001  * If the bus width is changed successfully, return the selected width value.
1002  * Zero is returned instead of error value if the wide width is not supported.
1003  */
1004 static int mmc_select_bus_width(struct mmc_card *card)
1005 {
1006         static unsigned ext_csd_bits[] = {
1007                 EXT_CSD_BUS_WIDTH_8,
1008                 EXT_CSD_BUS_WIDTH_4,
1009         };
1010         static unsigned bus_widths[] = {
1011                 MMC_BUS_WIDTH_8,
1012                 MMC_BUS_WIDTH_4,
1013         };
1014         struct mmc_host *host = card->host;
1015         unsigned idx, bus_width = 0;
1016         int err = 0;
1017
1018         if (!mmc_can_ext_csd(card) ||
1019             !(host->caps & (MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA)))
1020                 return 0;
1021
1022         idx = (host->caps & MMC_CAP_8_BIT_DATA) ? 0 : 1;
1023
1024         /*
1025          * Unlike SD, MMC cards dont have a configuration register to notify
1026          * supported bus width. So bus test command should be run to identify
1027          * the supported bus width or compare the ext csd values of current
1028          * bus width and ext csd values of 1 bit mode read earlier.
1029          */
1030         for (; idx < ARRAY_SIZE(bus_widths); idx++) {
1031                 /*
1032                  * Host is capable of 8bit transfer, then switch
1033                  * the device to work in 8bit transfer mode. If the
1034                  * mmc switch command returns error then switch to
1035                  * 4bit transfer mode. On success set the corresponding
1036                  * bus width on the host.
1037                  */
1038                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1039                                  EXT_CSD_BUS_WIDTH,
1040                                  ext_csd_bits[idx],
1041                                  card->ext_csd.generic_cmd6_time);
1042                 if (err)
1043                         continue;
1044
1045                 bus_width = bus_widths[idx];
1046                 mmc_set_bus_width(host, bus_width);
1047
1048                 /*
1049                  * If controller can't handle bus width test,
1050                  * compare ext_csd previously read in 1 bit mode
1051                  * against ext_csd at new bus width
1052                  */
1053                 if (!(host->caps & MMC_CAP_BUS_WIDTH_TEST))
1054                         err = mmc_compare_ext_csds(card, bus_width);
1055                 else
1056                         err = mmc_bus_test(card, bus_width);
1057
1058                 if (!err) {
1059                         err = bus_width;
1060                         break;
1061                 } else {
1062                         pr_warn("%s: switch to bus width %d failed\n",
1063                                 mmc_hostname(host), 1 << bus_width);
1064                 }
1065         }
1066
1067         return err;
1068 }
1069
1070 /*
1071  * Switch to the high-speed mode
1072  */
1073 static int mmc_select_hs(struct mmc_card *card)
1074 {
1075         int err;
1076
1077         err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1078                            EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS,
1079                            card->ext_csd.generic_cmd6_time, MMC_TIMING_MMC_HS,
1080                            true, true, MMC_CMD_RETRIES);
1081         if (err)
1082                 pr_warn("%s: switch to high-speed failed, err:%d\n",
1083                         mmc_hostname(card->host), err);
1084
1085         return err;
1086 }
1087
1088 /*
1089  * Activate wide bus and DDR if supported.
1090  */
1091 static int mmc_select_hs_ddr(struct mmc_card *card)
1092 {
1093         struct mmc_host *host = card->host;
1094         u32 bus_width, ext_csd_bits;
1095         int err = 0;
1096
1097         if (!(card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_52))
1098                 return 0;
1099
1100         bus_width = host->ios.bus_width;
1101         if (bus_width == MMC_BUS_WIDTH_1)
1102                 return 0;
1103
1104         ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ?
1105                 EXT_CSD_DDR_BUS_WIDTH_8 : EXT_CSD_DDR_BUS_WIDTH_4;
1106
1107         err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1108                            EXT_CSD_BUS_WIDTH,
1109                            ext_csd_bits,
1110                            card->ext_csd.generic_cmd6_time,
1111                            MMC_TIMING_MMC_DDR52,
1112                            true, true, MMC_CMD_RETRIES);
1113         if (err) {
1114                 pr_err("%s: switch to bus width %d ddr failed\n",
1115                         mmc_hostname(host), 1 << bus_width);
1116                 return err;
1117         }
1118
1119         /*
1120          * eMMC cards can support 3.3V to 1.2V i/o (vccq)
1121          * signaling.
1122          *
1123          * EXT_CSD_CARD_TYPE_DDR_1_8V means 3.3V or 1.8V vccq.
1124          *
1125          * 1.8V vccq at 3.3V core voltage (vcc) is not required
1126          * in the JEDEC spec for DDR.
1127          *
1128          * Even (e)MMC card can support 3.3v to 1.2v vccq, but not all
1129          * host controller can support this, like some of the SDHCI
1130          * controller which connect to an eMMC device. Some of these
1131          * host controller still needs to use 1.8v vccq for supporting
1132          * DDR mode.
1133          *
1134          * So the sequence will be:
1135          * if (host and device can both support 1.2v IO)
1136          *      use 1.2v IO;
1137          * else if (host and device can both support 1.8v IO)
1138          *      use 1.8v IO;
1139          * so if host and device can only support 3.3v IO, this is the
1140          * last choice.
1141          *
1142          * WARNING: eMMC rules are NOT the same as SD DDR
1143          */
1144         if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_1_2V) {
1145                 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120);
1146                 if (!err)
1147                         return 0;
1148         }
1149
1150         if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_1_8V &&
1151             host->caps & MMC_CAP_1_8V_DDR)
1152                 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180);
1153
1154         /* make sure vccq is 3.3v after switching disaster */
1155         if (err)
1156                 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330);
1157
1158         return err;
1159 }
1160
1161 static int mmc_select_hs400(struct mmc_card *card)
1162 {
1163         struct mmc_host *host = card->host;
1164         unsigned int max_dtr;
1165         int err = 0;
1166         u8 val;
1167
1168         /*
1169          * HS400 mode requires 8-bit bus width
1170          */
1171         if (!(card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400 &&
1172               host->ios.bus_width == MMC_BUS_WIDTH_8))
1173                 return 0;
1174
1175         /* Switch card to HS mode */
1176         val = EXT_CSD_TIMING_HS;
1177         err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1178                            EXT_CSD_HS_TIMING, val,
1179                            card->ext_csd.generic_cmd6_time, 0,
1180                            false, true, MMC_CMD_RETRIES);
1181         if (err) {
1182                 pr_err("%s: switch to high-speed from hs200 failed, err:%d\n",
1183                         mmc_hostname(host), err);
1184                 return err;
1185         }
1186
1187         /* Prepare host to downgrade to HS timing */
1188         if (host->ops->hs400_downgrade)
1189                 host->ops->hs400_downgrade(host);
1190
1191         /* Set host controller to HS timing */
1192         mmc_set_timing(host, MMC_TIMING_MMC_HS);
1193
1194         /* Reduce frequency to HS frequency */
1195         max_dtr = card->ext_csd.hs_max_dtr;
1196         mmc_set_clock(host, max_dtr);
1197
1198         err = mmc_switch_status(card, true);
1199         if (err)
1200                 goto out_err;
1201
1202         if (host->ops->hs400_prepare_ddr)
1203                 host->ops->hs400_prepare_ddr(host);
1204
1205         /* Switch card to DDR */
1206         err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1207                          EXT_CSD_BUS_WIDTH,
1208                          EXT_CSD_DDR_BUS_WIDTH_8,
1209                          card->ext_csd.generic_cmd6_time);
1210         if (err) {
1211                 pr_err("%s: switch to bus width for hs400 failed, err:%d\n",
1212                         mmc_hostname(host), err);
1213                 return err;
1214         }
1215
1216         /* Switch card to HS400 */
1217         val = EXT_CSD_TIMING_HS400 |
1218               card->drive_strength << EXT_CSD_DRV_STR_SHIFT;
1219         err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1220                            EXT_CSD_HS_TIMING, val,
1221                            card->ext_csd.generic_cmd6_time, 0,
1222                            false, true, MMC_CMD_RETRIES);
1223         if (err) {
1224                 pr_err("%s: switch to hs400 failed, err:%d\n",
1225                          mmc_hostname(host), err);
1226                 return err;
1227         }
1228
1229         /* Set host controller to HS400 timing and frequency */
1230         mmc_set_timing(host, MMC_TIMING_MMC_HS400);
1231         mmc_set_bus_speed(card);
1232
1233         if (host->ops->execute_hs400_tuning) {
1234                 mmc_retune_disable(host);
1235                 err = host->ops->execute_hs400_tuning(host, card);
1236                 mmc_retune_enable(host);
1237                 if (err)
1238                         goto out_err;
1239         }
1240
1241         if (host->ops->hs400_complete)
1242                 host->ops->hs400_complete(host);
1243
1244         err = mmc_switch_status(card, true);
1245         if (err)
1246                 goto out_err;
1247
1248         return 0;
1249
1250 out_err:
1251         pr_err("%s: %s failed, error %d\n", mmc_hostname(card->host),
1252                __func__, err);
1253         return err;
1254 }
1255
1256 int mmc_hs200_to_hs400(struct mmc_card *card)
1257 {
1258         return mmc_select_hs400(card);
1259 }
1260
1261 int mmc_hs400_to_hs200(struct mmc_card *card)
1262 {
1263         struct mmc_host *host = card->host;
1264         unsigned int max_dtr;
1265         int err;
1266         u8 val;
1267
1268         /* Reduce frequency to HS */
1269         max_dtr = card->ext_csd.hs_max_dtr;
1270         mmc_set_clock(host, max_dtr);
1271
1272         /* Switch HS400 to HS DDR */
1273         val = EXT_CSD_TIMING_HS;
1274         err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING,
1275                            val, card->ext_csd.generic_cmd6_time, 0,
1276                            false, true, MMC_CMD_RETRIES);
1277         if (err)
1278                 goto out_err;
1279
1280         if (host->ops->hs400_downgrade)
1281                 host->ops->hs400_downgrade(host);
1282
1283         mmc_set_timing(host, MMC_TIMING_MMC_DDR52);
1284
1285         err = mmc_switch_status(card, true);
1286         if (err)
1287                 goto out_err;
1288
1289         /* Switch HS DDR to HS */
1290         err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_BUS_WIDTH,
1291                            EXT_CSD_BUS_WIDTH_8, card->ext_csd.generic_cmd6_time,
1292                            0, false, true, MMC_CMD_RETRIES);
1293         if (err)
1294                 goto out_err;
1295
1296         mmc_set_timing(host, MMC_TIMING_MMC_HS);
1297
1298         err = mmc_switch_status(card, true);
1299         if (err)
1300                 goto out_err;
1301
1302         /* Switch HS to HS200 */
1303         val = EXT_CSD_TIMING_HS200 |
1304               card->drive_strength << EXT_CSD_DRV_STR_SHIFT;
1305         err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING,
1306                            val, card->ext_csd.generic_cmd6_time, 0,
1307                            false, true, MMC_CMD_RETRIES);
1308         if (err)
1309                 goto out_err;
1310
1311         mmc_set_timing(host, MMC_TIMING_MMC_HS200);
1312
1313         /*
1314          * For HS200, CRC errors are not a reliable way to know the switch
1315          * failed. If there really is a problem, we would expect tuning will
1316          * fail and the result ends up the same.
1317          */
1318         err = mmc_switch_status(card, false);
1319         if (err)
1320                 goto out_err;
1321
1322         mmc_set_bus_speed(card);
1323
1324         /* Prepare tuning for HS400 mode. */
1325         if (host->ops->prepare_hs400_tuning)
1326                 host->ops->prepare_hs400_tuning(host, &host->ios);
1327
1328         return 0;
1329
1330 out_err:
1331         pr_err("%s: %s failed, error %d\n", mmc_hostname(card->host),
1332                __func__, err);
1333         return err;
1334 }
1335
1336 static void mmc_select_driver_type(struct mmc_card *card)
1337 {
1338         int card_drv_type, drive_strength, drv_type = 0;
1339         int fixed_drv_type = card->host->fixed_drv_type;
1340
1341         card_drv_type = card->ext_csd.raw_driver_strength |
1342                         mmc_driver_type_mask(0);
1343
1344         if (fixed_drv_type >= 0)
1345                 drive_strength = card_drv_type & mmc_driver_type_mask(fixed_drv_type)
1346                                  ? fixed_drv_type : 0;
1347         else
1348                 drive_strength = mmc_select_drive_strength(card,
1349                                                            card->ext_csd.hs200_max_dtr,
1350                                                            card_drv_type, &drv_type);
1351
1352         card->drive_strength = drive_strength;
1353
1354         if (drv_type)
1355                 mmc_set_driver_type(card->host, drv_type);
1356 }
1357
1358 static int mmc_select_hs400es(struct mmc_card *card)
1359 {
1360         struct mmc_host *host = card->host;
1361         int err = -EINVAL;
1362         u8 val;
1363
1364         if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400_1_2V)
1365                 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120);
1366
1367         if (err && card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400_1_8V)
1368                 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180);
1369
1370         /* If fails try again during next card power cycle */
1371         if (err)
1372                 goto out_err;
1373
1374         err = mmc_select_bus_width(card);
1375         if (err != MMC_BUS_WIDTH_8) {
1376                 pr_err("%s: switch to 8bit bus width failed, err:%d\n",
1377                         mmc_hostname(host), err);
1378                 err = err < 0 ? err : -ENOTSUPP;
1379                 goto out_err;
1380         }
1381
1382         /* Switch card to HS mode */
1383         err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1384                            EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS,
1385                            card->ext_csd.generic_cmd6_time, 0,
1386                            false, true, MMC_CMD_RETRIES);
1387         if (err) {
1388                 pr_err("%s: switch to hs for hs400es failed, err:%d\n",
1389                         mmc_hostname(host), err);
1390                 goto out_err;
1391         }
1392
1393         /*
1394          * Bump to HS timing and frequency. Some cards don't handle
1395          * SEND_STATUS reliably at the initial frequency.
1396          */
1397         mmc_set_timing(host, MMC_TIMING_MMC_HS);
1398         mmc_set_bus_speed(card);
1399
1400         err = mmc_switch_status(card, true);
1401         if (err)
1402                 goto out_err;
1403
1404         /* Switch card to DDR with strobe bit */
1405         val = EXT_CSD_DDR_BUS_WIDTH_8 | EXT_CSD_BUS_WIDTH_STROBE;
1406         err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1407                          EXT_CSD_BUS_WIDTH,
1408                          val,
1409                          card->ext_csd.generic_cmd6_time);
1410         if (err) {
1411                 pr_err("%s: switch to bus width for hs400es failed, err:%d\n",
1412                         mmc_hostname(host), err);
1413                 goto out_err;
1414         }
1415
1416         mmc_select_driver_type(card);
1417
1418         /* Switch card to HS400 */
1419         val = EXT_CSD_TIMING_HS400 |
1420               card->drive_strength << EXT_CSD_DRV_STR_SHIFT;
1421         err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1422                            EXT_CSD_HS_TIMING, val,
1423                            card->ext_csd.generic_cmd6_time, 0,
1424                            false, true, MMC_CMD_RETRIES);
1425         if (err) {
1426                 pr_err("%s: switch to hs400es failed, err:%d\n",
1427                         mmc_hostname(host), err);
1428                 goto out_err;
1429         }
1430
1431         /* Set host controller to HS400 timing and frequency */
1432         mmc_set_timing(host, MMC_TIMING_MMC_HS400);
1433
1434         /* Controller enable enhanced strobe function */
1435         host->ios.enhanced_strobe = true;
1436         if (host->ops->hs400_enhanced_strobe)
1437                 host->ops->hs400_enhanced_strobe(host, &host->ios);
1438
1439         err = mmc_switch_status(card, true);
1440         if (err)
1441                 goto out_err;
1442
1443         return 0;
1444
1445 out_err:
1446         pr_err("%s: %s failed, error %d\n", mmc_hostname(card->host),
1447                __func__, err);
1448         return err;
1449 }
1450
1451 /*
1452  * For device supporting HS200 mode, the following sequence
1453  * should be done before executing the tuning process.
1454  * 1. set the desired bus width(4-bit or 8-bit, 1-bit is not supported)
1455  * 2. switch to HS200 mode
1456  * 3. set the clock to > 52Mhz and <=200MHz
1457  */
1458 static int mmc_select_hs200(struct mmc_card *card)
1459 {
1460         struct mmc_host *host = card->host;
1461         unsigned int old_timing, old_signal_voltage, old_clock;
1462         int err = -EINVAL;
1463         u8 val;
1464
1465         old_signal_voltage = host->ios.signal_voltage;
1466         if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS200_1_2V)
1467                 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120);
1468
1469         if (err && card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS200_1_8V)
1470                 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180);
1471
1472         /* If fails try again during next card power cycle */
1473         if (err)
1474                 return err;
1475
1476         mmc_select_driver_type(card);
1477
1478         /*
1479          * Set the bus width(4 or 8) with host's support and
1480          * switch to HS200 mode if bus width is set successfully.
1481          */
1482         err = mmc_select_bus_width(card);
1483         if (err > 0) {
1484                 val = EXT_CSD_TIMING_HS200 |
1485                       card->drive_strength << EXT_CSD_DRV_STR_SHIFT;
1486                 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1487                                    EXT_CSD_HS_TIMING, val,
1488                                    card->ext_csd.generic_cmd6_time, 0,
1489                                    false, true, MMC_CMD_RETRIES);
1490                 if (err)
1491                         goto err;
1492
1493                 /*
1494                  * Bump to HS timing and frequency. Some cards don't handle
1495                  * SEND_STATUS reliably at the initial frequency.
1496                  * NB: We can't move to full (HS200) speeds until after we've
1497                  * successfully switched over.
1498                  */
1499                 old_timing = host->ios.timing;
1500                 old_clock = host->ios.clock;
1501                 mmc_set_timing(host, MMC_TIMING_MMC_HS200);
1502                 mmc_set_clock(card->host, card->ext_csd.hs_max_dtr);
1503
1504                 /*
1505                  * For HS200, CRC errors are not a reliable way to know the
1506                  * switch failed. If there really is a problem, we would expect
1507                  * tuning will fail and the result ends up the same.
1508                  */
1509                 err = mmc_switch_status(card, false);
1510
1511                 /*
1512                  * mmc_select_timing() assumes timing has not changed if
1513                  * it is a switch error.
1514                  */
1515                 if (err == -EBADMSG) {
1516                         mmc_set_clock(host, old_clock);
1517                         mmc_set_timing(host, old_timing);
1518                 }
1519         }
1520 err:
1521         if (err) {
1522                 /* fall back to the old signal voltage, if fails report error */
1523                 if (mmc_set_signal_voltage(host, old_signal_voltage))
1524                         err = -EIO;
1525
1526                 pr_err("%s: %s failed, error %d\n", mmc_hostname(card->host),
1527                        __func__, err);
1528         }
1529         return err;
1530 }
1531
1532 /*
1533  * Activate High Speed, HS200 or HS400ES mode if supported.
1534  */
1535 static int mmc_select_timing(struct mmc_card *card)
1536 {
1537         int err = 0;
1538
1539         if (!mmc_can_ext_csd(card))
1540                 goto bus_speed;
1541
1542         if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400ES) {
1543                 err = mmc_select_hs400es(card);
1544                 goto out;
1545         }
1546
1547         if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS200) {
1548                 err = mmc_select_hs200(card);
1549                 if (err == -EBADMSG)
1550                         card->mmc_avail_type &= ~EXT_CSD_CARD_TYPE_HS200;
1551                 else
1552                         goto out;
1553         }
1554
1555         if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS)
1556                 err = mmc_select_hs(card);
1557
1558 out:
1559         if (err && err != -EBADMSG)
1560                 return err;
1561
1562 bus_speed:
1563         /*
1564          * Set the bus speed to the selected bus timing.
1565          * If timing is not selected, backward compatible is the default.
1566          */
1567         mmc_set_bus_speed(card);
1568         return 0;
1569 }
1570
1571 /*
1572  * Execute tuning sequence to seek the proper bus operating
1573  * conditions for HS200 and HS400, which sends CMD21 to the device.
1574  */
1575 static int mmc_hs200_tuning(struct mmc_card *card)
1576 {
1577         struct mmc_host *host = card->host;
1578
1579         /*
1580          * Timing should be adjusted to the HS400 target
1581          * operation frequency for tuning process
1582          */
1583         if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400 &&
1584             host->ios.bus_width == MMC_BUS_WIDTH_8)
1585                 if (host->ops->prepare_hs400_tuning)
1586                         host->ops->prepare_hs400_tuning(host, &host->ios);
1587
1588         return mmc_execute_tuning(card);
1589 }
1590
1591 /*
1592  * Handle the detection and initialisation of a card.
1593  *
1594  * In the case of a resume, "oldcard" will contain the card
1595  * we're trying to reinitialise.
1596  */
1597 static int mmc_init_card(struct mmc_host *host, u32 ocr,
1598         struct mmc_card *oldcard)
1599 {
1600         struct mmc_card *card;
1601         int err;
1602         u32 cid[4];
1603         u32 rocr;
1604
1605         WARN_ON(!host->claimed);
1606
1607         /* Set correct bus mode for MMC before attempting init */
1608         if (!mmc_host_is_spi(host))
1609                 mmc_set_bus_mode(host, MMC_BUSMODE_OPENDRAIN);
1610
1611         /*
1612          * Since we're changing the OCR value, we seem to
1613          * need to tell some cards to go back to the idle
1614          * state.  We wait 1ms to give cards time to
1615          * respond.
1616          * mmc_go_idle is needed for eMMC that are asleep
1617          */
1618         mmc_go_idle(host);
1619
1620         /* The extra bit indicates that we support high capacity */
1621         err = mmc_send_op_cond(host, ocr | (1 << 30), &rocr);
1622         if (err)
1623                 goto err;
1624
1625         /*
1626          * For SPI, enable CRC as appropriate.
1627          */
1628         if (mmc_host_is_spi(host)) {
1629                 err = mmc_spi_set_crc(host, use_spi_crc);
1630                 if (err)
1631                         goto err;
1632         }
1633
1634         /*
1635          * Fetch CID from card.
1636          */
1637         err = mmc_send_cid(host, cid);
1638         if (err)
1639                 goto err;
1640
1641         if (oldcard) {
1642                 if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0) {
1643                         pr_debug("%s: Perhaps the card was replaced\n",
1644                                 mmc_hostname(host));
1645                         err = -ENOENT;
1646                         goto err;
1647                 }
1648
1649                 card = oldcard;
1650         } else {
1651                 /*
1652                  * Allocate card structure.
1653                  */
1654                 card = mmc_alloc_card(host, &mmc_type);
1655                 if (IS_ERR(card)) {
1656                         err = PTR_ERR(card);
1657                         goto err;
1658                 }
1659
1660                 card->ocr = ocr;
1661                 card->type = MMC_TYPE_MMC;
1662                 card->rca = 1;
1663                 memcpy(card->raw_cid, cid, sizeof(card->raw_cid));
1664         }
1665
1666         /*
1667          * Call the optional HC's init_card function to handle quirks.
1668          */
1669         if (host->ops->init_card)
1670                 host->ops->init_card(host, card);
1671
1672         /*
1673          * For native busses:  set card RCA and quit open drain mode.
1674          */
1675         if (!mmc_host_is_spi(host)) {
1676                 err = mmc_set_relative_addr(card);
1677                 if (err)
1678                         goto free_card;
1679
1680                 mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL);
1681         }
1682
1683         if (!oldcard) {
1684                 /*
1685                  * Fetch CSD from card.
1686                  */
1687                 err = mmc_send_csd(card, card->raw_csd);
1688                 if (err)
1689                         goto free_card;
1690
1691                 err = mmc_decode_csd(card);
1692                 if (err)
1693                         goto free_card;
1694                 err = mmc_decode_cid(card);
1695                 if (err)
1696                         goto free_card;
1697         }
1698
1699         /*
1700          * handling only for cards supporting DSR and hosts requesting
1701          * DSR configuration
1702          */
1703         if (card->csd.dsr_imp && host->dsr_req)
1704                 mmc_set_dsr(host);
1705
1706         /*
1707          * Select card, as all following commands rely on that.
1708          */
1709         if (!mmc_host_is_spi(host)) {
1710                 err = mmc_select_card(card);
1711                 if (err)
1712                         goto free_card;
1713         }
1714
1715         if (!oldcard) {
1716                 /* Read extended CSD. */
1717                 err = mmc_read_ext_csd(card);
1718                 if (err)
1719                         goto free_card;
1720
1721                 /*
1722                  * If doing byte addressing, check if required to do sector
1723                  * addressing.  Handle the case of <2GB cards needing sector
1724                  * addressing.  See section 8.1 JEDEC Standard JED84-A441;
1725                  * ocr register has bit 30 set for sector addressing.
1726                  */
1727                 if (rocr & BIT(30))
1728                         mmc_card_set_blockaddr(card);
1729
1730                 /* Erase size depends on CSD and Extended CSD */
1731                 mmc_set_erase_size(card);
1732         }
1733
1734         /*
1735          * Reselect the card type since host caps could have been changed when
1736          * debugging even if the card is not new.
1737          */
1738         mmc_select_card_type(card);
1739
1740         /* Enable ERASE_GRP_DEF. This bit is lost after a reset or power off. */
1741         if (card->ext_csd.rev >= 3) {
1742                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1743                                  EXT_CSD_ERASE_GROUP_DEF, 1,
1744                                  card->ext_csd.generic_cmd6_time);
1745
1746                 if (err && err != -EBADMSG)
1747                         goto free_card;
1748
1749                 if (err) {
1750                         /*
1751                          * Just disable enhanced area off & sz
1752                          * will try to enable ERASE_GROUP_DEF
1753                          * during next time reinit
1754                          */
1755                         card->ext_csd.enhanced_area_offset = -EINVAL;
1756                         card->ext_csd.enhanced_area_size = -EINVAL;
1757                 } else {
1758                         card->ext_csd.erase_group_def = 1;
1759                         /*
1760                          * enable ERASE_GRP_DEF successfully.
1761                          * This will affect the erase size, so
1762                          * here need to reset erase size
1763                          */
1764                         mmc_set_erase_size(card);
1765                 }
1766         }
1767
1768         /*
1769          * Ensure eMMC user default partition is enabled
1770          */
1771         if (card->ext_csd.part_config & EXT_CSD_PART_CONFIG_ACC_MASK) {
1772                 card->ext_csd.part_config &= ~EXT_CSD_PART_CONFIG_ACC_MASK;
1773                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONFIG,
1774                                  card->ext_csd.part_config,
1775                                  card->ext_csd.part_time);
1776                 if (err && err != -EBADMSG)
1777                         goto free_card;
1778         }
1779
1780         /*
1781          * Enable power_off_notification byte in the ext_csd register
1782          */
1783         if (card->ext_csd.rev >= 6) {
1784                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1785                                  EXT_CSD_POWER_OFF_NOTIFICATION,
1786                                  EXT_CSD_POWER_ON,
1787                                  card->ext_csd.generic_cmd6_time);
1788                 if (err && err != -EBADMSG)
1789                         goto free_card;
1790
1791                 /*
1792                  * The err can be -EBADMSG or 0,
1793                  * so check for success and update the flag
1794                  */
1795                 if (!err)
1796                         card->ext_csd.power_off_notification = EXT_CSD_POWER_ON;
1797         }
1798
1799         /* set erase_arg */
1800         if (mmc_can_discard(card))
1801                 card->erase_arg = MMC_DISCARD_ARG;
1802         else if (mmc_can_trim(card))
1803                 card->erase_arg = MMC_TRIM_ARG;
1804         else
1805                 card->erase_arg = MMC_ERASE_ARG;
1806
1807         /*
1808          * Select timing interface
1809          */
1810         err = mmc_select_timing(card);
1811         if (err)
1812                 goto free_card;
1813
1814         if (mmc_card_hs200(card)) {
1815                 host->doing_init_tune = 1;
1816
1817                 err = mmc_hs200_tuning(card);
1818                 if (!err)
1819                         err = mmc_select_hs400(card);
1820
1821                 host->doing_init_tune = 0;
1822
1823                 if (err)
1824                         goto free_card;
1825
1826         } else if (!mmc_card_hs400es(card)) {
1827                 /* Select the desired bus width optionally */
1828                 err = mmc_select_bus_width(card);
1829                 if (err > 0 && mmc_card_hs(card)) {
1830                         err = mmc_select_hs_ddr(card);
1831                         if (err)
1832                                 goto free_card;
1833                 }
1834         }
1835
1836         /*
1837          * Choose the power class with selected bus interface
1838          */
1839         mmc_select_powerclass(card);
1840
1841         /*
1842          * Enable HPI feature (if supported)
1843          */
1844         if (card->ext_csd.hpi) {
1845                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1846                                 EXT_CSD_HPI_MGMT, 1,
1847                                 card->ext_csd.generic_cmd6_time);
1848                 if (err && err != -EBADMSG)
1849                         goto free_card;
1850                 if (err) {
1851                         pr_warn("%s: Enabling HPI failed\n",
1852                                 mmc_hostname(card->host));
1853                         card->ext_csd.hpi_en = 0;
1854                 } else {
1855                         card->ext_csd.hpi_en = 1;
1856                 }
1857         }
1858
1859         /*
1860          * If cache size is higher than 0, this indicates the existence of cache
1861          * and it can be turned on. Note that some eMMCs from Micron has been
1862          * reported to need ~800 ms timeout, while enabling the cache after
1863          * sudden power failure tests. Let's extend the timeout to a minimum of
1864          * DEFAULT_CACHE_EN_TIMEOUT_MS and do it for all cards.
1865          */
1866         if (card->ext_csd.cache_size > 0) {
1867                 unsigned int timeout_ms = MIN_CACHE_EN_TIMEOUT_MS;
1868
1869                 timeout_ms = max(card->ext_csd.generic_cmd6_time, timeout_ms);
1870                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1871                                 EXT_CSD_CACHE_CTRL, 1, timeout_ms);
1872                 if (err && err != -EBADMSG)
1873                         goto free_card;
1874
1875                 /*
1876                  * Only if no error, cache is turned on successfully.
1877                  */
1878                 if (err) {
1879                         pr_warn("%s: Cache is supported, but failed to turn on (%d)\n",
1880                                 mmc_hostname(card->host), err);
1881                         card->ext_csd.cache_ctrl = 0;
1882                 } else {
1883                         card->ext_csd.cache_ctrl = 1;
1884                 }
1885         }
1886
1887         /*
1888          * Enable Command Queue if supported. Note that Packed Commands cannot
1889          * be used with Command Queue.
1890          */
1891         card->ext_csd.cmdq_en = false;
1892         if (card->ext_csd.cmdq_support && host->caps2 & MMC_CAP2_CQE) {
1893                 err = mmc_cmdq_enable(card);
1894                 if (err && err != -EBADMSG)
1895                         goto free_card;
1896                 if (err) {
1897                         pr_warn("%s: Enabling CMDQ failed\n",
1898                                 mmc_hostname(card->host));
1899                         card->ext_csd.cmdq_support = false;
1900                         card->ext_csd.cmdq_depth = 0;
1901                 }
1902         }
1903         /*
1904          * In some cases (e.g. RPMB or mmc_test), the Command Queue must be
1905          * disabled for a time, so a flag is needed to indicate to re-enable the
1906          * Command Queue.
1907          */
1908         card->reenable_cmdq = card->ext_csd.cmdq_en;
1909
1910         if (host->cqe_ops && !host->cqe_enabled) {
1911                 err = host->cqe_ops->cqe_enable(host, card);
1912                 if (!err) {
1913                         host->cqe_enabled = true;
1914
1915                         if (card->ext_csd.cmdq_en) {
1916                                 pr_info("%s: Command Queue Engine enabled\n",
1917                                         mmc_hostname(host));
1918                         } else {
1919                                 host->hsq_enabled = true;
1920                                 pr_info("%s: Host Software Queue enabled\n",
1921                                         mmc_hostname(host));
1922                         }
1923                 }
1924         }
1925
1926         if (host->caps2 & MMC_CAP2_AVOID_3_3V &&
1927             host->ios.signal_voltage == MMC_SIGNAL_VOLTAGE_330) {
1928                 pr_err("%s: Host failed to negotiate down from 3.3V\n",
1929                         mmc_hostname(host));
1930                 err = -EINVAL;
1931                 goto free_card;
1932         }
1933
1934         if (!oldcard)
1935                 host->card = card;
1936
1937         return 0;
1938
1939 free_card:
1940         if (!oldcard)
1941                 mmc_remove_card(card);
1942 err:
1943         return err;
1944 }
1945
1946 static int mmc_can_sleep(struct mmc_card *card)
1947 {
1948         return card->ext_csd.rev >= 3;
1949 }
1950
1951 static int mmc_sleep_busy_cb(void *cb_data, bool *busy)
1952 {
1953         struct mmc_host *host = cb_data;
1954
1955         *busy = host->ops->card_busy(host);
1956         return 0;
1957 }
1958
1959 static int mmc_sleep(struct mmc_host *host)
1960 {
1961         struct mmc_command cmd = {};
1962         struct mmc_card *card = host->card;
1963         unsigned int timeout_ms = DIV_ROUND_UP(card->ext_csd.sa_timeout, 10000);
1964         bool use_r1b_resp;
1965         int err;
1966
1967         /* Re-tuning can't be done once the card is deselected */
1968         mmc_retune_hold(host);
1969
1970         err = mmc_deselect_cards(host);
1971         if (err)
1972                 goto out_release;
1973
1974         cmd.opcode = MMC_SLEEP_AWAKE;
1975         cmd.arg = card->rca << 16;
1976         cmd.arg |= 1 << 15;
1977         use_r1b_resp = mmc_prepare_busy_cmd(host, &cmd, timeout_ms);
1978
1979         err = mmc_wait_for_cmd(host, &cmd, 0);
1980         if (err)
1981                 goto out_release;
1982
1983         /*
1984          * If the host does not wait while the card signals busy, then we can
1985          * try to poll, but only if the host supports HW polling, as the
1986          * SEND_STATUS cmd is not allowed. If we can't poll, then we simply need
1987          * to wait the sleep/awake timeout.
1988          */
1989         if (host->caps & MMC_CAP_WAIT_WHILE_BUSY && use_r1b_resp)
1990                 goto out_release;
1991
1992         if (!host->ops->card_busy) {
1993                 mmc_delay(timeout_ms);
1994                 goto out_release;
1995         }
1996
1997         err = __mmc_poll_for_busy(host, 0, timeout_ms, &mmc_sleep_busy_cb, host);
1998
1999 out_release:
2000         mmc_retune_release(host);
2001         return err;
2002 }
2003
2004 static int mmc_can_poweroff_notify(const struct mmc_card *card)
2005 {
2006         return card &&
2007                 mmc_card_mmc(card) &&
2008                 (card->ext_csd.power_off_notification == EXT_CSD_POWER_ON);
2009 }
2010
2011 static int mmc_poweroff_notify(struct mmc_card *card, unsigned int notify_type)
2012 {
2013         unsigned int timeout = card->ext_csd.generic_cmd6_time;
2014         int err;
2015
2016         /* Use EXT_CSD_POWER_OFF_SHORT as default notification type. */
2017         if (notify_type == EXT_CSD_POWER_OFF_LONG)
2018                 timeout = card->ext_csd.power_off_longtime;
2019
2020         err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
2021                         EXT_CSD_POWER_OFF_NOTIFICATION,
2022                         notify_type, timeout, 0, false, false, MMC_CMD_RETRIES);
2023         if (err)
2024                 pr_err("%s: Power Off Notification timed out, %u\n",
2025                        mmc_hostname(card->host), timeout);
2026
2027         /* Disable the power off notification after the switch operation. */
2028         card->ext_csd.power_off_notification = EXT_CSD_NO_POWER_NOTIFICATION;
2029
2030         return err;
2031 }
2032
2033 /*
2034  * Host is being removed. Free up the current card.
2035  */
2036 static void mmc_remove(struct mmc_host *host)
2037 {
2038         mmc_remove_card(host->card);
2039         host->card = NULL;
2040 }
2041
2042 /*
2043  * Card detection - card is alive.
2044  */
2045 static int mmc_alive(struct mmc_host *host)
2046 {
2047         return mmc_send_status(host->card, NULL);
2048 }
2049
2050 /*
2051  * Card detection callback from host.
2052  */
2053 static void mmc_detect(struct mmc_host *host)
2054 {
2055         int err;
2056
2057         mmc_get_card(host->card, NULL);
2058
2059         /*
2060          * Just check if our card has been removed.
2061          */
2062         err = _mmc_detect_card_removed(host);
2063
2064         mmc_put_card(host->card, NULL);
2065
2066         if (err) {
2067                 mmc_remove(host);
2068
2069                 mmc_claim_host(host);
2070                 mmc_detach_bus(host);
2071                 mmc_power_off(host);
2072                 mmc_release_host(host);
2073         }
2074 }
2075
2076 static bool _mmc_cache_enabled(struct mmc_host *host)
2077 {
2078         return host->card->ext_csd.cache_size > 0 &&
2079                host->card->ext_csd.cache_ctrl & 1;
2080 }
2081
2082 /*
2083  * Flush the internal cache of the eMMC to non-volatile storage.
2084  */
2085 static int _mmc_flush_cache(struct mmc_host *host)
2086 {
2087         int err = 0;
2088
2089         if (mmc_card_broken_cache_flush(host->card) && !host->card->written_flag)
2090                 return 0;
2091
2092         if (_mmc_cache_enabled(host)) {
2093                 err = mmc_switch(host->card, EXT_CSD_CMD_SET_NORMAL,
2094                                  EXT_CSD_FLUSH_CACHE, 1,
2095                                  CACHE_FLUSH_TIMEOUT_MS);
2096                 if (err)
2097                         pr_err("%s: cache flush error %d\n", mmc_hostname(host), err);
2098                 else
2099                         host->card->written_flag = false;
2100         }
2101
2102         return err;
2103 }
2104
2105 static int _mmc_suspend(struct mmc_host *host, bool is_suspend)
2106 {
2107         int err = 0;
2108         unsigned int notify_type = is_suspend ? EXT_CSD_POWER_OFF_SHORT :
2109                                         EXT_CSD_POWER_OFF_LONG;
2110
2111         mmc_claim_host(host);
2112
2113         if (mmc_card_suspended(host->card))
2114                 goto out;
2115
2116         err = _mmc_flush_cache(host);
2117         if (err)
2118                 goto out;
2119
2120         if (mmc_can_poweroff_notify(host->card) &&
2121             ((host->caps2 & MMC_CAP2_FULL_PWR_CYCLE) || !is_suspend ||
2122              (host->caps2 & MMC_CAP2_FULL_PWR_CYCLE_IN_SUSPEND)))
2123                 err = mmc_poweroff_notify(host->card, notify_type);
2124         else if (mmc_can_sleep(host->card))
2125                 err = mmc_sleep(host);
2126         else if (!mmc_host_is_spi(host))
2127                 err = mmc_deselect_cards(host);
2128
2129         if (!err) {
2130                 mmc_power_off(host);
2131                 mmc_card_set_suspended(host->card);
2132         }
2133 out:
2134         mmc_release_host(host);
2135         return err;
2136 }
2137
2138 /*
2139  * Suspend callback
2140  */
2141 static int mmc_suspend(struct mmc_host *host)
2142 {
2143         int err;
2144
2145         err = _mmc_suspend(host, true);
2146         if (!err) {
2147                 pm_runtime_disable(&host->card->dev);
2148                 pm_runtime_set_suspended(&host->card->dev);
2149         }
2150
2151         return err;
2152 }
2153
2154 /*
2155  * This function tries to determine if the same card is still present
2156  * and, if so, restore all state to it.
2157  */
2158 static int _mmc_resume(struct mmc_host *host)
2159 {
2160         int err = 0;
2161
2162         mmc_claim_host(host);
2163
2164         if (!mmc_card_suspended(host->card))
2165                 goto out;
2166
2167         mmc_power_up(host, host->card->ocr);
2168         err = mmc_init_card(host, host->card->ocr, host->card);
2169         mmc_card_clr_suspended(host->card);
2170
2171 out:
2172         mmc_release_host(host);
2173         return err;
2174 }
2175
2176 /*
2177  * Shutdown callback
2178  */
2179 static int mmc_shutdown(struct mmc_host *host)
2180 {
2181         int err = 0;
2182
2183         /*
2184          * In a specific case for poweroff notify, we need to resume the card
2185          * before we can shutdown it properly.
2186          */
2187         if (mmc_can_poweroff_notify(host->card) &&
2188                 !(host->caps2 & MMC_CAP2_FULL_PWR_CYCLE))
2189                 err = _mmc_resume(host);
2190
2191         if (!err)
2192                 err = _mmc_suspend(host, false);
2193
2194         return err;
2195 }
2196
2197 /*
2198  * Callback for resume.
2199  */
2200 static int mmc_resume(struct mmc_host *host)
2201 {
2202         pm_runtime_enable(&host->card->dev);
2203         return 0;
2204 }
2205
2206 /*
2207  * Callback for runtime_suspend.
2208  */
2209 static int mmc_runtime_suspend(struct mmc_host *host)
2210 {
2211         int err;
2212
2213         if (!(host->caps & MMC_CAP_AGGRESSIVE_PM))
2214                 return 0;
2215
2216         err = _mmc_suspend(host, true);
2217         if (err)
2218                 pr_err("%s: error %d doing aggressive suspend\n",
2219                         mmc_hostname(host), err);
2220
2221         return err;
2222 }
2223
2224 /*
2225  * Callback for runtime_resume.
2226  */
2227 static int mmc_runtime_resume(struct mmc_host *host)
2228 {
2229         int err;
2230
2231         err = _mmc_resume(host);
2232         if (err && err != -ENOMEDIUM)
2233                 pr_err("%s: error %d doing runtime resume\n",
2234                         mmc_hostname(host), err);
2235
2236         return 0;
2237 }
2238
2239 static int mmc_can_reset(struct mmc_card *card)
2240 {
2241         u8 rst_n_function;
2242
2243         rst_n_function = card->ext_csd.rst_n_function;
2244         if ((rst_n_function & EXT_CSD_RST_N_EN_MASK) != EXT_CSD_RST_N_ENABLED)
2245                 return 0;
2246         return 1;
2247 }
2248
2249 static int _mmc_hw_reset(struct mmc_host *host)
2250 {
2251         struct mmc_card *card = host->card;
2252
2253         /*
2254          * In the case of recovery, we can't expect flushing the cache to work
2255          * always, but we have a go and ignore errors.
2256          */
2257         _mmc_flush_cache(host);
2258
2259         if ((host->caps & MMC_CAP_HW_RESET) && host->ops->card_hw_reset &&
2260              mmc_can_reset(card)) {
2261                 /* If the card accept RST_n signal, send it. */
2262                 mmc_set_clock(host, host->f_init);
2263                 host->ops->card_hw_reset(host);
2264                 /* Set initial state and call mmc_set_ios */
2265                 mmc_set_initial_state(host);
2266         } else {
2267                 /* Do a brute force power cycle */
2268                 mmc_power_cycle(host, card->ocr);
2269                 mmc_pwrseq_reset(host);
2270         }
2271         return mmc_init_card(host, card->ocr, card);
2272 }
2273
2274 static const struct mmc_bus_ops mmc_ops = {
2275         .remove = mmc_remove,
2276         .detect = mmc_detect,
2277         .suspend = mmc_suspend,
2278         .resume = mmc_resume,
2279         .runtime_suspend = mmc_runtime_suspend,
2280         .runtime_resume = mmc_runtime_resume,
2281         .alive = mmc_alive,
2282         .shutdown = mmc_shutdown,
2283         .hw_reset = _mmc_hw_reset,
2284         .cache_enabled = _mmc_cache_enabled,
2285         .flush_cache = _mmc_flush_cache,
2286 };
2287
2288 /*
2289  * Starting point for MMC card init.
2290  */
2291 int mmc_attach_mmc(struct mmc_host *host)
2292 {
2293         int err;
2294         u32 ocr, rocr;
2295
2296         WARN_ON(!host->claimed);
2297
2298         /* Set correct bus mode for MMC before attempting attach */
2299         if (!mmc_host_is_spi(host))
2300                 mmc_set_bus_mode(host, MMC_BUSMODE_OPENDRAIN);
2301
2302         err = mmc_send_op_cond(host, 0, &ocr);
2303         if (err)
2304                 return err;
2305
2306         mmc_attach_bus(host, &mmc_ops);
2307         if (host->ocr_avail_mmc)
2308                 host->ocr_avail = host->ocr_avail_mmc;
2309
2310         /*
2311          * We need to get OCR a different way for SPI.
2312          */
2313         if (mmc_host_is_spi(host)) {
2314                 err = mmc_spi_read_ocr(host, 1, &ocr);
2315                 if (err)
2316                         goto err;
2317         }
2318
2319         rocr = mmc_select_voltage(host, ocr);
2320
2321         /*
2322          * Can we support the voltage of the card?
2323          */
2324         if (!rocr) {
2325                 err = -EINVAL;
2326                 goto err;
2327         }
2328
2329         /*
2330          * Detect and init the card.
2331          */
2332         err = mmc_init_card(host, rocr, NULL);
2333         if (err)
2334                 goto err;
2335
2336         mmc_release_host(host);
2337         err = mmc_add_card(host->card);
2338         if (err)
2339                 goto remove_card;
2340
2341         mmc_claim_host(host);
2342         return 0;
2343
2344 remove_card:
2345         mmc_remove_card(host->card);
2346         mmc_claim_host(host);
2347         host->card = NULL;
2348 err:
2349         mmc_detach_bus(host);
2350
2351         pr_err("%s: error %d whilst initialising MMC card\n",
2352                 mmc_hostname(host), err);
2353
2354         return err;
2355 }