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