drivers/mmc/core/mmc.c

   1 /*
   2  *  linux/drivers/mmc/core/mmc.c
   3  *
   4  *  Copyright (C) 2003-2004 Russell King, All Rights Reserved.
   5  *  Copyright (C) 2005-2007 Pierre Ossman, All Rights Reserved.
   6  *  MMCv4 support Copyright (C) 2006 Philip Langdale, All Rights Reserved.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  */
  12
  13 #include <linux/err.h>
  14 #include <linux/of.h>
  15 #include <linux/slab.h>
  16 #include <linux/stat.h>
  17 #include <linux/pm_runtime.h>
  18
  19 #include <linux/mmc/host.h>
  20 #include <linux/mmc/card.h>
  21 #include <linux/mmc/mmc.h>
  22
  23 #include "core.h"
  24 #include "bus.h"
  25 #include "mmc_ops.h"
  26 #include "sd_ops.h"
  27
  28 static const unsigned int tran_exp[] = {
  29         10000,          100000,         1000000,        10000000,
  30         0,              0,              0,              0
  31 };
  32
  33 static const unsigned char tran_mant[] = {
  34         0,      10,     12,     13,     15,     20,     25,     30,
  35         35,     40,     45,     50,     55,     60,     70,     80,
  36 };
  37
  38 static const unsigned int tacc_exp[] = {
  39         1,      10,     100,    1000,   10000,  100000, 1000000, 10000000,
  40 };
  41
  42 static const unsigned int tacc_mant[] = {
  43         0,      10,     12,     13,     15,     20,     25,     30,
  44         35,     40,     45,     50,     55,     60,     70,     80,
  45 };
  46
  47 #define UNSTUFF_BITS(resp,start,size)                                   \
  48         ({                                                              \
  49                 const int __size = size;                                \
  50                 const u32 __mask = (__size < 32 ? 1 << __size : 0) - 1; \
  51                 const int __off = 3 - ((start) / 32);                   \
  52                 const int __shft = (start) & 31;                        \
  53                 u32 __res;                                              \
  54                                                                         \
  55                 __res = resp[__off] >> __shft;                          \
  56                 if (__size + __shft > 32)                               \
  57                         __res |= resp[__off-1] << ((32 - __shft) % 32); \
  58                 __res & __mask;                                         \
  59         })
  60
  61 /*
  62  * Given the decoded CSD structure, decode the raw CID to our CID structure.
  63  */
  64 static int mmc_decode_cid(struct mmc_card *card)
  65 {
  66         u32 *resp = card->raw_cid;
  67
  68         /*
  69          * The selection of the format here is based upon published
  70          * specs from sandisk and from what people have reported.
  71          */
  72         switch (card->csd.mmca_vsn) {
  73         case 0: /* MMC v1.0 - v1.2 */
  74         case 1: /* MMC v1.4 */
  75                 card->cid.manfid        = UNSTUFF_BITS(resp, 104, 24);
  76                 card->cid.prod_name[0]  = UNSTUFF_BITS(resp, 96, 8);
  77                 card->cid.prod_name[1]  = UNSTUFF_BITS(resp, 88, 8);
  78                 card->cid.prod_name[2]  = UNSTUFF_BITS(resp, 80, 8);
  79                 card->cid.prod_name[3]  = UNSTUFF_BITS(resp, 72, 8);
  80                 card->cid.prod_name[4]  = UNSTUFF_BITS(resp, 64, 8);
  81                 card->cid.prod_name[5]  = UNSTUFF_BITS(resp, 56, 8);
  82                 card->cid.prod_name[6]  = UNSTUFF_BITS(resp, 48, 8);
  83                 card->cid.hwrev         = UNSTUFF_BITS(resp, 44, 4);
  84                 card->cid.fwrev         = UNSTUFF_BITS(resp, 40, 4);
  85                 card->cid.serial        = UNSTUFF_BITS(resp, 16, 24);
  86                 card->cid.month         = UNSTUFF_BITS(resp, 12, 4);
  87                 card->cid.year          = UNSTUFF_BITS(resp, 8, 4) + 1997;
  88                 break;
  89
  90         case 2: /* MMC v2.0 - v2.2 */
  91         case 3: /* MMC v3.1 - v3.3 */
  92         case 4: /* MMC v4 */
  93                 card->cid.manfid        = UNSTUFF_BITS(resp, 120, 8);
  94                 card->cid.oemid         = UNSTUFF_BITS(resp, 104, 16);
  95                 card->cid.prod_name[0]  = UNSTUFF_BITS(resp, 96, 8);
  96                 card->cid.prod_name[1]  = UNSTUFF_BITS(resp, 88, 8);
  97                 card->cid.prod_name[2]  = UNSTUFF_BITS(resp, 80, 8);
  98                 card->cid.prod_name[3]  = UNSTUFF_BITS(resp, 72, 8);
  99                 card->cid.prod_name[4]  = UNSTUFF_BITS(resp, 64, 8);
 100                 card->cid.prod_name[5]  = UNSTUFF_BITS(resp, 56, 8);
 101                 card->cid.prv           = UNSTUFF_BITS(resp, 48, 8);
 102                 card->cid.serial        = UNSTUFF_BITS(resp, 16, 32);
 103                 card->cid.month         = UNSTUFF_BITS(resp, 12, 4);
 104                 card->cid.year          = UNSTUFF_BITS(resp, 8, 4) + 1997;
 105                 break;
 106
 107         default:
 108                 pr_err("%s: card has unknown MMCA version %d\n",
 109                         mmc_hostname(card->host), card->csd.mmca_vsn);
 110                 return -EINVAL;
 111         }
 112
 113         return 0;
 114 }
 115
 116 static void mmc_set_erase_size(struct mmc_card *card)
 117 {
 118         if (card->ext_csd.erase_group_def & 1)
 119                 card->erase_size = card->ext_csd.hc_erase_size;
 120         else
 121                 card->erase_size = card->csd.erase_size;
 122
 123         mmc_init_erase(card);
 124 }
 125
 126 /*
 127  * Given a 128-bit response, decode to our card CSD structure.
 128  */
 129 static int mmc_decode_csd(struct mmc_card *card)
 130 {
 131         struct mmc_csd *csd = &card->csd;
 132         unsigned int e, m, a, b;
 133         u32 *resp = card->raw_csd;
 134
 135         /*
 136          * We only understand CSD structure v1.1 and v1.2.
 137          * v1.2 has extra information in bits 15, 11 and 10.
 138          * We also support eMMC v4.4 & v4.41.
 139          */
 140         csd->structure = UNSTUFF_BITS(resp, 126, 2);
 141         if (csd->structure == 0) {
 142                 pr_err("%s: unrecognised CSD structure version %d\n",
 143                         mmc_hostname(card->host), csd->structure);
 144                 return -EINVAL;
 145         }
 146
 147         csd->mmca_vsn    = UNSTUFF_BITS(resp, 122, 4);
 148         m = UNSTUFF_BITS(resp, 115, 4);
 149         e = UNSTUFF_BITS(resp, 112, 3);
 150         csd->tacc_ns     = (tacc_exp[e] * tacc_mant[m] + 9) / 10;
 151         csd->tacc_clks   = UNSTUFF_BITS(resp, 104, 8) * 100;
 152
 153         m = UNSTUFF_BITS(resp, 99, 4);
 154         e = UNSTUFF_BITS(resp, 96, 3);
 155         csd->max_dtr      = tran_exp[e] * tran_mant[m];
 156         csd->cmdclass     = UNSTUFF_BITS(resp, 84, 12);
 157
 158         e = UNSTUFF_BITS(resp, 47, 3);
 159         m = UNSTUFF_BITS(resp, 62, 12);
 160         csd->capacity     = (1 + m) << (e + 2);
 161
 162         csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4);
 163         csd->read_partial = UNSTUFF_BITS(resp, 79, 1);
 164         csd->write_misalign = UNSTUFF_BITS(resp, 78, 1);
 165         csd->read_misalign = UNSTUFF_BITS(resp, 77, 1);
 166         csd->dsr_imp = UNSTUFF_BITS(resp, 76, 1);
 167         csd->r2w_factor = UNSTUFF_BITS(resp, 26, 3);
 168         csd->write_blkbits = UNSTUFF_BITS(resp, 22, 4);
 169         csd->write_partial = UNSTUFF_BITS(resp, 21, 1);
 170
 171         if (csd->write_blkbits >= 9) {
 172                 a = UNSTUFF_BITS(resp, 42, 5);
 173                 b = UNSTUFF_BITS(resp, 37, 5);
 174                 csd->erase_size = (a + 1) * (b + 1);
 175                 csd->erase_size <<= csd->write_blkbits - 9;
 176         }
 177
 178         return 0;
 179 }
 180
 181 static void mmc_select_card_type(struct mmc_card *card)
 182 {
 183         struct mmc_host *host = card->host;
 184         u8 card_type = card->ext_csd.raw_card_type;
 185         u32 caps = host->caps, caps2 = host->caps2;
 186         unsigned int hs_max_dtr = 0, hs200_max_dtr = 0;
 187         unsigned int avail_type = 0;
 188
 189         if (caps & MMC_CAP_MMC_HIGHSPEED &&
 190             card_type & EXT_CSD_CARD_TYPE_HS_26) {
 191                 hs_max_dtr = MMC_HIGH_26_MAX_DTR;
 192                 avail_type |= EXT_CSD_CARD_TYPE_HS_26;
 193         }
 194
 195         if (caps & MMC_CAP_MMC_HIGHSPEED &&
 196             card_type & EXT_CSD_CARD_TYPE_HS_52) {
 197                 hs_max_dtr = MMC_HIGH_52_MAX_DTR;
 198                 avail_type |= EXT_CSD_CARD_TYPE_HS_52;
 199         }
 200
 201         if (caps & MMC_CAP_1_8V_DDR &&
 202             card_type & EXT_CSD_CARD_TYPE_DDR_1_8V) {
 203                 hs_max_dtr = MMC_HIGH_DDR_MAX_DTR;
 204                 avail_type |= EXT_CSD_CARD_TYPE_DDR_1_8V;
 205         }
 206
 207         if (caps & MMC_CAP_1_2V_DDR &&
 208             card_type & EXT_CSD_CARD_TYPE_DDR_1_2V) {
 209                 hs_max_dtr = MMC_HIGH_DDR_MAX_DTR;
 210                 avail_type |= EXT_CSD_CARD_TYPE_DDR_1_2V;
 211         }
 212
 213         if (caps2 & MMC_CAP2_HS200_1_8V_SDR &&
 214             card_type & EXT_CSD_CARD_TYPE_HS200_1_8V) {
 215                 hs200_max_dtr = MMC_HS200_MAX_DTR;
 216                 avail_type |= EXT_CSD_CARD_TYPE_HS200_1_8V;
 217         }
 218
 219         if (caps2 & MMC_CAP2_HS200_1_2V_SDR &&
 220             card_type & EXT_CSD_CARD_TYPE_HS200_1_2V) {
 221                 hs200_max_dtr = MMC_HS200_MAX_DTR;
 222                 avail_type |= EXT_CSD_CARD_TYPE_HS200_1_2V;
 223         }
 224
 225         if (caps2 & MMC_CAP2_HS400_1_8V &&
 226             card_type & EXT_CSD_CARD_TYPE_HS400_1_8V) {
 227                 hs200_max_dtr = MMC_HS200_MAX_DTR;
 228                 avail_type |= EXT_CSD_CARD_TYPE_HS400_1_8V;
 229         }
 230
 231         if (caps2 & MMC_CAP2_HS400_1_2V &&
 232             card_type & EXT_CSD_CARD_TYPE_HS400_1_2V) {
 233                 hs200_max_dtr = MMC_HS200_MAX_DTR;
 234                 avail_type |= EXT_CSD_CARD_TYPE_HS400_1_2V;
 235         }
 236
 237         card->ext_csd.hs_max_dtr = hs_max_dtr;
 238         card->ext_csd.hs200_max_dtr = hs200_max_dtr;
 239         card->mmc_avail_type = avail_type;
 240 }
 241
 242 static void mmc_manage_enhanced_area(struct mmc_card *card, u8 *ext_csd)
 243 {
 244         u8 hc_erase_grp_sz, hc_wp_grp_sz;
 245
 246         /*
 247          * Disable these attributes by default
 248          */
 249         card->ext_csd.enhanced_area_offset = -EINVAL;
 250         card->ext_csd.enhanced_area_size = -EINVAL;
 251
 252         /*
 253          * Enhanced area feature support -- check whether the eMMC
 254          * card has the Enhanced area enabled.  If so, export enhanced
 255          * area offset and size to user by adding sysfs interface.
 256          */
 257         if ((ext_csd[EXT_CSD_PARTITION_SUPPORT] & 0x2) &&
 258             (ext_csd[EXT_CSD_PARTITION_ATTRIBUTE] & 0x1)) {
 259                 if (card->ext_csd.partition_setting_completed) {
 260                         hc_erase_grp_sz =
 261                                 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
 262                         hc_wp_grp_sz =
 263                                 ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
 264
 265                         /*
 266                          * calculate the enhanced data area offset, in bytes
 267                          */
 268                         card->ext_csd.enhanced_area_offset =
 269                                 (ext_csd[139] << 24) + (ext_csd[138] << 16) +
 270                                 (ext_csd[137] << 8) + ext_csd[136];
 271                         if (mmc_card_blockaddr(card))
 272                                 card->ext_csd.enhanced_area_offset <<= 9;
 273                         /*
 274                          * calculate the enhanced data area size, in kilobytes
 275                          */
 276                         card->ext_csd.enhanced_area_size =
 277                                 (ext_csd[142] << 16) + (ext_csd[141] << 8) +
 278                                 ext_csd[140];
 279                         card->ext_csd.enhanced_area_size *=
 280                                 (size_t)(hc_erase_grp_sz * hc_wp_grp_sz);
 281                         card->ext_csd.enhanced_area_size <<= 9;
 282                 } else {
 283                         pr_warn("%s: defines enhanced area without partition setting complete\n",
 284                                 mmc_hostname(card->host));
 285                 }
 286         }
 287 }
 288
 289 static void mmc_manage_gp_partitions(struct mmc_card *card, u8 *ext_csd)
 290 {
 291         int idx;
 292         u8 hc_erase_grp_sz, hc_wp_grp_sz;
 293         unsigned int part_size;
 294
 295         /*
 296          * General purpose partition feature support --
 297          * If ext_csd has the size of general purpose partitions,
 298          * set size, part_cfg, partition name in mmc_part.
 299          */
 300         if (ext_csd[EXT_CSD_PARTITION_SUPPORT] &
 301             EXT_CSD_PART_SUPPORT_PART_EN) {
 302                 hc_erase_grp_sz =
 303                         ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
 304                 hc_wp_grp_sz =
 305                         ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
 306
 307                 for (idx = 0; idx < MMC_NUM_GP_PARTITION; idx++) {
 308                         if (!ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3] &&
 309                             !ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 1] &&
 310                             !ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 2])
 311                                 continue;
 312                         if (card->ext_csd.partition_setting_completed == 0) {
 313                                 pr_warn("%s: has partition size defined without partition complete\n",
 314                                         mmc_hostname(card->host));
 315                                 break;
 316                         }
 317                         part_size =
 318                                 (ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 2]
 319                                 << 16) +
 320                                 (ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 1]
 321                                 << 8) +
 322                                 ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3];
 323                         part_size *= (size_t)(hc_erase_grp_sz *
 324                                 hc_wp_grp_sz);
 325                         mmc_part_add(card, part_size << 19,
 326                                 EXT_CSD_PART_CONFIG_ACC_GP0 + idx,
 327                                 "gp%d", idx, false,
 328                                 MMC_BLK_DATA_AREA_GP);
 329                 }
 330         }
 331 }
 332
 333 /*
 334  * Decode extended CSD.
 335  */
 336 static int mmc_decode_ext_csd(struct mmc_card *card, u8 *ext_csd)
 337 {
 338         int err = 0, idx;
 339         unsigned int part_size;
 340         struct device_node *np;
 341         bool broken_hpi = false;
 342
 343         /* Version is coded in the CSD_STRUCTURE byte in the EXT_CSD register */
 344         card->ext_csd.raw_ext_csd_structure = ext_csd[EXT_CSD_STRUCTURE];
 345         if (card->csd.structure == 3) {
 346                 if (card->ext_csd.raw_ext_csd_structure > 2) {
 347                         pr_err("%s: unrecognised EXT_CSD structure "
 348                                 "version %d\n", mmc_hostname(card->host),
 349                                         card->ext_csd.raw_ext_csd_structure);
 350                         err = -EINVAL;
 351                         goto out;
 352                 }
 353         }
 354
 355         np = mmc_of_find_child_device(card->host, 0);
 356         if (np && of_device_is_compatible(np, "mmc-card"))
 357                 broken_hpi = of_property_read_bool(np, "broken-hpi");
 358         of_node_put(np);
 359
 360         /*
 361          * The EXT_CSD format is meant to be forward compatible. As long
 362          * as CSD_STRUCTURE does not change, all values for EXT_CSD_REV
 363          * are authorized, see JEDEC JESD84-B50 section B.8.
 364          */
 365         card->ext_csd.rev = ext_csd[EXT_CSD_REV];
 366
 367         card->ext_csd.raw_sectors[0] = ext_csd[EXT_CSD_SEC_CNT + 0];
 368         card->ext_csd.raw_sectors[1] = ext_csd[EXT_CSD_SEC_CNT + 1];
 369         card->ext_csd.raw_sectors[2] = ext_csd[EXT_CSD_SEC_CNT + 2];
 370         card->ext_csd.raw_sectors[3] = ext_csd[EXT_CSD_SEC_CNT + 3];
 371         if (card->ext_csd.rev >= 2) {
 372                 card->ext_csd.sectors =
 373                         ext_csd[EXT_CSD_SEC_CNT + 0] << 0 |
 374                         ext_csd[EXT_CSD_SEC_CNT + 1] << 8 |
 375                         ext_csd[EXT_CSD_SEC_CNT + 2] << 16 |
 376                         ext_csd[EXT_CSD_SEC_CNT + 3] << 24;
 377
 378                 /* Cards with density > 2GiB are sector addressed */
 379                 if (card->ext_csd.sectors > (2u * 1024 * 1024 * 1024) / 512)
 380                         mmc_card_set_blockaddr(card);
 381         }
 382
 383         card->ext_csd.raw_card_type = ext_csd[EXT_CSD_CARD_TYPE];
 384         mmc_select_card_type(card);
 385
 386         card->ext_csd.raw_s_a_timeout = ext_csd[EXT_CSD_S_A_TIMEOUT];
 387         card->ext_csd.raw_erase_timeout_mult =
 388                 ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT];
 389         card->ext_csd.raw_hc_erase_grp_size =
 390                 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
 391         if (card->ext_csd.rev >= 3) {
 392                 u8 sa_shift = ext_csd[EXT_CSD_S_A_TIMEOUT];
 393                 card->ext_csd.part_config = ext_csd[EXT_CSD_PART_CONFIG];
 394
 395                 /* EXT_CSD value is in units of 10ms, but we store in ms */
 396                 card->ext_csd.part_time = 10 * ext_csd[EXT_CSD_PART_SWITCH_TIME];
 397
 398                 /* Sleep / awake timeout in 100ns units */
 399                 if (sa_shift > 0 && sa_shift <= 0x17)
 400                         card->ext_csd.sa_timeout =
 401                                         1 << ext_csd[EXT_CSD_S_A_TIMEOUT];
 402                 card->ext_csd.erase_group_def =
 403                         ext_csd[EXT_CSD_ERASE_GROUP_DEF];
 404                 card->ext_csd.hc_erase_timeout = 300 *
 405                         ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT];
 406                 card->ext_csd.hc_erase_size =
 407                         ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] << 10;
 408
 409                 card->ext_csd.rel_sectors = ext_csd[EXT_CSD_REL_WR_SEC_C];
 410
 411                 /*
 412                  * There are two boot regions of equal size, defined in
 413                  * multiples of 128K.
 414                  */
 415                 if (ext_csd[EXT_CSD_BOOT_MULT] && mmc_boot_partition_access(card->host)) {
 416                         for (idx = 0; idx < MMC_NUM_BOOT_PARTITION; idx++) {
 417                                 part_size = ext_csd[EXT_CSD_BOOT_MULT] << 17;
 418                                 mmc_part_add(card, part_size,
 419                                         EXT_CSD_PART_CONFIG_ACC_BOOT0 + idx,
 420                                         "boot%d", idx, true,
 421                                         MMC_BLK_DATA_AREA_BOOT);
 422                         }
 423                 }
 424         }
 425
 426         card->ext_csd.raw_hc_erase_gap_size =
 427                 ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
 428         card->ext_csd.raw_sec_trim_mult =
 429                 ext_csd[EXT_CSD_SEC_TRIM_MULT];
 430         card->ext_csd.raw_sec_erase_mult =
 431                 ext_csd[EXT_CSD_SEC_ERASE_MULT];
 432         card->ext_csd.raw_sec_feature_support =
 433                 ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT];
 434         card->ext_csd.raw_trim_mult =
 435                 ext_csd[EXT_CSD_TRIM_MULT];
 436         card->ext_csd.raw_partition_support = ext_csd[EXT_CSD_PARTITION_SUPPORT];
 437         if (card->ext_csd.rev >= 4) {
 438                 if (ext_csd[EXT_CSD_PARTITION_SETTING_COMPLETED] &
 439                     EXT_CSD_PART_SETTING_COMPLETED)
 440                         card->ext_csd.partition_setting_completed = 1;
 441                 else
 442                         card->ext_csd.partition_setting_completed = 0;
 443
 444                 mmc_manage_enhanced_area(card, ext_csd);
 445
 446                 mmc_manage_gp_partitions(card, ext_csd);
 447
 448                 card->ext_csd.sec_trim_mult =
 449                         ext_csd[EXT_CSD_SEC_TRIM_MULT];
 450                 card->ext_csd.sec_erase_mult =
 451                         ext_csd[EXT_CSD_SEC_ERASE_MULT];
 452                 card->ext_csd.sec_feature_support =
 453                         ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT];
 454                 card->ext_csd.trim_timeout = 300 *
 455                         ext_csd[EXT_CSD_TRIM_MULT];
 456
 457                 /*
 458                  * Note that the call to mmc_part_add above defaults to read
 459                  * only. If this default assumption is changed, the call must
 460                  * take into account the value of boot_locked below.
 461                  */
 462                 card->ext_csd.boot_ro_lock = ext_csd[EXT_CSD_BOOT_WP];
 463                 card->ext_csd.boot_ro_lockable = true;
 464
 465                 /* Save power class values */
 466                 card->ext_csd.raw_pwr_cl_52_195 =
 467                         ext_csd[EXT_CSD_PWR_CL_52_195];
 468                 card->ext_csd.raw_pwr_cl_26_195 =
 469                         ext_csd[EXT_CSD_PWR_CL_26_195];
 470                 card->ext_csd.raw_pwr_cl_52_360 =
 471                         ext_csd[EXT_CSD_PWR_CL_52_360];
 472                 card->ext_csd.raw_pwr_cl_26_360 =
 473                         ext_csd[EXT_CSD_PWR_CL_26_360];
 474                 card->ext_csd.raw_pwr_cl_200_195 =
 475                         ext_csd[EXT_CSD_PWR_CL_200_195];
 476                 card->ext_csd.raw_pwr_cl_200_360 =
 477                         ext_csd[EXT_CSD_PWR_CL_200_360];
 478                 card->ext_csd.raw_pwr_cl_ddr_52_195 =
 479                         ext_csd[EXT_CSD_PWR_CL_DDR_52_195];
 480                 card->ext_csd.raw_pwr_cl_ddr_52_360 =
 481                         ext_csd[EXT_CSD_PWR_CL_DDR_52_360];
 482                 card->ext_csd.raw_pwr_cl_ddr_200_360 =
 483                         ext_csd[EXT_CSD_PWR_CL_DDR_200_360];
 484         }
 485
 486         if (card->ext_csd.rev >= 5) {
 487                 /* Adjust production date as per JEDEC JESD84-B451 */
 488                 if (card->cid.year < 2010)
 489                         card->cid.year += 16;
 490
 491                 /* check whether the eMMC card supports BKOPS */
 492                 if (ext_csd[EXT_CSD_BKOPS_SUPPORT] & 0x1) {
 493                         card->ext_csd.bkops = 1;
 494                         card->ext_csd.man_bkops_en =
 495                                         (ext_csd[EXT_CSD_BKOPS_EN] &
 496                                                 EXT_CSD_MANUAL_BKOPS_MASK);
 497                         card->ext_csd.raw_bkops_status =
 498                                 ext_csd[EXT_CSD_BKOPS_STATUS];
 499                         if (!card->ext_csd.man_bkops_en)
 500                                 pr_info("%s: MAN_BKOPS_EN bit is not set\n",
 501                                         mmc_hostname(card->host));
 502                 }
 503
 504                 /* check whether the eMMC card supports HPI */
 505                 if (!broken_hpi && (ext_csd[EXT_CSD_HPI_FEATURES] & 0x1)) {
 506                         card->ext_csd.hpi = 1;
 507                         if (ext_csd[EXT_CSD_HPI_FEATURES] & 0x2)
 508                                 card->ext_csd.hpi_cmd = MMC_STOP_TRANSMISSION;
 509                         else
 510                                 card->ext_csd.hpi_cmd = MMC_SEND_STATUS;
 511                         /*
 512                          * Indicate the maximum timeout to close
 513                          * a command interrupted by HPI
 514                          */
 515                         card->ext_csd.out_of_int_time =
 516                                 ext_csd[EXT_CSD_OUT_OF_INTERRUPT_TIME] * 10;
 517                 }
 518
 519                 card->ext_csd.rel_param = ext_csd[EXT_CSD_WR_REL_PARAM];
 520                 card->ext_csd.rst_n_function = ext_csd[EXT_CSD_RST_N_FUNCTION];
 521
 522                 /*
 523                  * RPMB regions are defined in multiples of 128K.
 524                  */
 525                 card->ext_csd.raw_rpmb_size_mult = ext_csd[EXT_CSD_RPMB_MULT];
 526                 if (ext_csd[EXT_CSD_RPMB_MULT] && mmc_host_cmd23(card->host)) {
 527                         mmc_part_add(card, ext_csd[EXT_CSD_RPMB_MULT] << 17,
 528                                 EXT_CSD_PART_CONFIG_ACC_RPMB,
 529                                 "rpmb", 0, false,
 530                                 MMC_BLK_DATA_AREA_RPMB);
 531                 }
 532         }
 533
 534         card->ext_csd.raw_erased_mem_count = ext_csd[EXT_CSD_ERASED_MEM_CONT];
 535         if (ext_csd[EXT_CSD_ERASED_MEM_CONT])
 536                 card->erased_byte = 0xFF;
 537         else
 538                 card->erased_byte = 0x0;
 539
 540         /* eMMC v4.5 or later */
 541         if (card->ext_csd.rev >= 6) {
 542                 card->ext_csd.feature_support |= MMC_DISCARD_FEATURE;
 543
 544                 card->ext_csd.generic_cmd6_time = 10 *
 545                         ext_csd[EXT_CSD_GENERIC_CMD6_TIME];
 546                 card->ext_csd.power_off_longtime = 10 *
 547                         ext_csd[EXT_CSD_POWER_OFF_LONG_TIME];
 548
 549                 card->ext_csd.cache_size =
 550                         ext_csd[EXT_CSD_CACHE_SIZE + 0] << 0 |
 551                         ext_csd[EXT_CSD_CACHE_SIZE + 1] << 8 |
 552                         ext_csd[EXT_CSD_CACHE_SIZE + 2] << 16 |
 553                         ext_csd[EXT_CSD_CACHE_SIZE + 3] << 24;
 554
 555                 if (ext_csd[EXT_CSD_DATA_SECTOR_SIZE] == 1)
 556                         card->ext_csd.data_sector_size = 4096;
 557                 else
 558                         card->ext_csd.data_sector_size = 512;
 559
 560                 if ((ext_csd[EXT_CSD_DATA_TAG_SUPPORT] & 1) &&
 561                     (ext_csd[EXT_CSD_TAG_UNIT_SIZE] <= 8)) {
 562                         card->ext_csd.data_tag_unit_size =
 563                         ((unsigned int) 1 << ext_csd[EXT_CSD_TAG_UNIT_SIZE]) *
 564                         (card->ext_csd.data_sector_size);
 565                 } else {
 566                         card->ext_csd.data_tag_unit_size = 0;
 567                 }
 568
 569                 card->ext_csd.max_packed_writes =
 570                         ext_csd[EXT_CSD_MAX_PACKED_WRITES];
 571                 card->ext_csd.max_packed_reads =
 572                         ext_csd[EXT_CSD_MAX_PACKED_READS];
 573         } else {
 574                 card->ext_csd.data_sector_size = 512;
 575         }
 576
 577         /* eMMC v5 or later */
 578         if (card->ext_csd.rev >= 7) {
 579                 memcpy(card->ext_csd.fwrev, &ext_csd[EXT_CSD_FIRMWARE_VERSION],
 580                        MMC_FIRMWARE_LEN);
 581                 card->ext_csd.ffu_capable =
 582                         (ext_csd[EXT_CSD_SUPPORTED_MODE] & 0x1) &&
 583                         !(ext_csd[EXT_CSD_FW_CONFIG] & 0x1);
 584         }
 585 out:
 586         return err;
 587 }
 588
 589 static int mmc_read_ext_csd(struct mmc_card *card)
 590 {
 591         u8 *ext_csd;
 592         int err;
 593
 594         if (!mmc_can_ext_csd(card))
 595                 return 0;
 596
 597         err = mmc_get_ext_csd(card, &ext_csd);
 598         if (err) {
 599                 /* If the host or the card can't do the switch,
 600                  * fail more gracefully. */
 601                 if ((err != -EINVAL)
 602                  && (err != -ENOSYS)
 603                  && (err != -EFAULT))
 604                         return err;
 605
 606                 /*
 607                  * High capacity cards should have this "magic" size
 608                  * stored in their CSD.
 609                  */
 610                 if (card->csd.capacity == (4096 * 512)) {
 611                         pr_err("%s: unable to read EXT_CSD on a possible high capacity card. Card will be ignored.\n",
 612                                 mmc_hostname(card->host));
 613                 } else {
 614                         pr_warn("%s: unable to read EXT_CSD, performance might suffer\n",
 615                                 mmc_hostname(card->host));
 616                         err = 0;
 617                 }
 618
 619                 return err;
 620         }
 621
 622         err = mmc_decode_ext_csd(card, ext_csd);
 623         kfree(ext_csd);
 624         return err;
 625 }
 626
 627 static int mmc_compare_ext_csds(struct mmc_card *card, unsigned bus_width)
 628 {
 629         u8 *bw_ext_csd;
 630         int err;
 631
 632         if (bus_width == MMC_BUS_WIDTH_1)
 633                 return 0;
 634
 635         err = mmc_get_ext_csd(card, &bw_ext_csd);
 636         if (err)
 637                 return err;
 638
 639         /* only compare read only fields */
 640         err = !((card->ext_csd.raw_partition_support ==
 641                         bw_ext_csd[EXT_CSD_PARTITION_SUPPORT]) &&
 642                 (card->ext_csd.raw_erased_mem_count ==
 643                         bw_ext_csd[EXT_CSD_ERASED_MEM_CONT]) &&
 644                 (card->ext_csd.rev ==
 645                         bw_ext_csd[EXT_CSD_REV]) &&
 646                 (card->ext_csd.raw_ext_csd_structure ==
 647                         bw_ext_csd[EXT_CSD_STRUCTURE]) &&
 648                 (card->ext_csd.raw_card_type ==
 649                         bw_ext_csd[EXT_CSD_CARD_TYPE]) &&
 650                 (card->ext_csd.raw_s_a_timeout ==
 651                         bw_ext_csd[EXT_CSD_S_A_TIMEOUT]) &&
 652                 (card->ext_csd.raw_hc_erase_gap_size ==
 653                         bw_ext_csd[EXT_CSD_HC_WP_GRP_SIZE]) &&
 654                 (card->ext_csd.raw_erase_timeout_mult ==
 655                         bw_ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT]) &&
 656                 (card->ext_csd.raw_hc_erase_grp_size ==
 657                         bw_ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]) &&
 658                 (card->ext_csd.raw_sec_trim_mult ==
 659                         bw_ext_csd[EXT_CSD_SEC_TRIM_MULT]) &&
 660                 (card->ext_csd.raw_sec_erase_mult ==
 661                         bw_ext_csd[EXT_CSD_SEC_ERASE_MULT]) &&
 662                 (card->ext_csd.raw_sec_feature_support ==
 663                         bw_ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT]) &&
 664                 (card->ext_csd.raw_trim_mult ==
 665                         bw_ext_csd[EXT_CSD_TRIM_MULT]) &&
 666                 (card->ext_csd.raw_sectors[0] ==
 667                         bw_ext_csd[EXT_CSD_SEC_CNT + 0]) &&
 668                 (card->ext_csd.raw_sectors[1] ==
 669                         bw_ext_csd[EXT_CSD_SEC_CNT + 1]) &&
 670                 (card->ext_csd.raw_sectors[2] ==
 671                         bw_ext_csd[EXT_CSD_SEC_CNT + 2]) &&
 672                 (card->ext_csd.raw_sectors[3] ==
 673                         bw_ext_csd[EXT_CSD_SEC_CNT + 3]) &&
 674                 (card->ext_csd.raw_pwr_cl_52_195 ==
 675                         bw_ext_csd[EXT_CSD_PWR_CL_52_195]) &&
 676                 (card->ext_csd.raw_pwr_cl_26_195 ==
 677                         bw_ext_csd[EXT_CSD_PWR_CL_26_195]) &&
 678                 (card->ext_csd.raw_pwr_cl_52_360 ==
 679                         bw_ext_csd[EXT_CSD_PWR_CL_52_360]) &&
 680                 (card->ext_csd.raw_pwr_cl_26_360 ==
 681                         bw_ext_csd[EXT_CSD_PWR_CL_26_360]) &&
 682                 (card->ext_csd.raw_pwr_cl_200_195 ==
 683                         bw_ext_csd[EXT_CSD_PWR_CL_200_195]) &&
 684                 (card->ext_csd.raw_pwr_cl_200_360 ==
 685                         bw_ext_csd[EXT_CSD_PWR_CL_200_360]) &&
 686                 (card->ext_csd.raw_pwr_cl_ddr_52_195 ==
 687                         bw_ext_csd[EXT_CSD_PWR_CL_DDR_52_195]) &&
 688                 (card->ext_csd.raw_pwr_cl_ddr_52_360 ==
 689                         bw_ext_csd[EXT_CSD_PWR_CL_DDR_52_360]) &&
 690                 (card->ext_csd.raw_pwr_cl_ddr_200_360 ==
 691                         bw_ext_csd[EXT_CSD_PWR_CL_DDR_200_360]));
 692
 693         if (err)
 694                 err = -EINVAL;
 695
 696         kfree(bw_ext_csd);
 697         return err;
 698 }
 699
 700 MMC_DEV_ATTR(cid, "%08x%08x%08x%08x\n", card->raw_cid[0], card->raw_cid[1],
 701         card->raw_cid[2], card->raw_cid[3]);
 702 MMC_DEV_ATTR(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1],
 703         card->raw_csd[2], card->raw_csd[3]);
 704 MMC_DEV_ATTR(date, "%02d/%04d\n", card->cid.month, card->cid.year);
 705 MMC_DEV_ATTR(erase_size, "%u\n", card->erase_size << 9);
 706 MMC_DEV_ATTR(preferred_erase_size, "%u\n", card->pref_erase << 9);
 707 MMC_DEV_ATTR(ffu_capable, "%d\n", card->ext_csd.ffu_capable);
 708 MMC_DEV_ATTR(hwrev, "0x%x\n", card->cid.hwrev);
 709 MMC_DEV_ATTR(manfid, "0x%06x\n", card->cid.manfid);
 710 MMC_DEV_ATTR(name, "%s\n", card->cid.prod_name);
 711 MMC_DEV_ATTR(oemid, "0x%04x\n", card->cid.oemid);
 712 MMC_DEV_ATTR(prv, "0x%x\n", card->cid.prv);
 713 MMC_DEV_ATTR(serial, "0x%08x\n", card->cid.serial);
 714 MMC_DEV_ATTR(enhanced_area_offset, "%llu\n",
 715                 card->ext_csd.enhanced_area_offset);
 716 MMC_DEV_ATTR(enhanced_area_size, "%u\n", card->ext_csd.enhanced_area_size);
 717 MMC_DEV_ATTR(raw_rpmb_size_mult, "%#x\n", card->ext_csd.raw_rpmb_size_mult);
 718 MMC_DEV_ATTR(rel_sectors, "%#x\n", card->ext_csd.rel_sectors);
 719
 720 static ssize_t mmc_fwrev_show(struct device *dev,
 721                               struct device_attribute *attr,
 722                               char *buf)
 723 {
 724         struct mmc_card *card = mmc_dev_to_card(dev);
 725
 726         if (card->ext_csd.rev < 7) {
 727                 return sprintf(buf, "0x%x\n", card->cid.fwrev);
 728         } else {
 729                 return sprintf(buf, "0x%*phN\n", MMC_FIRMWARE_LEN,
 730                                card->ext_csd.fwrev);
 731         }
 732 }
 733
 734 static DEVICE_ATTR(fwrev, S_IRUGO, mmc_fwrev_show, NULL);
 735
 736 static struct attribute *mmc_std_attrs[] = {
 737         &dev_attr_cid.attr,
 738         &dev_attr_csd.attr,
 739         &dev_attr_date.attr,
 740         &dev_attr_erase_size.attr,
 741         &dev_attr_preferred_erase_size.attr,
 742         &dev_attr_fwrev.attr,
 743         &dev_attr_ffu_capable.attr,
 744         &dev_attr_hwrev.attr,
 745         &dev_attr_manfid.attr,
 746         &dev_attr_name.attr,
 747         &dev_attr_oemid.attr,
 748         &dev_attr_prv.attr,
 749         &dev_attr_serial.attr,
 750         &dev_attr_enhanced_area_offset.attr,
 751         &dev_attr_enhanced_area_size.attr,
 752         &dev_attr_raw_rpmb_size_mult.attr,
 753         &dev_attr_rel_sectors.attr,
 754         NULL,
 755 };
 756 ATTRIBUTE_GROUPS(mmc_std);
 757
 758 static struct device_type mmc_type = {
 759         .groups = mmc_std_groups,
 760 };
 761
 762 /*
 763  * Select the PowerClass for the current bus width
 764  * If power class is defined for 4/8 bit bus in the
 765  * extended CSD register, select it by executing the
 766  * mmc_switch command.
 767  */
 768 static int __mmc_select_powerclass(struct mmc_card *card,
 769                                    unsigned int bus_width)
 770 {
 771         struct mmc_host *host = card->host;
 772         struct mmc_ext_csd *ext_csd = &card->ext_csd;
 773         unsigned int pwrclass_val = 0;
 774         int err = 0;
 775
 776         switch (1 << host->ios.vdd) {
 777         case MMC_VDD_165_195:
 778                 if (host->ios.clock <= MMC_HIGH_26_MAX_DTR)
 779                         pwrclass_val = ext_csd->raw_pwr_cl_26_195;
 780                 else if (host->ios.clock <= MMC_HIGH_52_MAX_DTR)
 781                         pwrclass_val = (bus_width <= EXT_CSD_BUS_WIDTH_8) ?
 782                                 ext_csd->raw_pwr_cl_52_195 :
 783                                 ext_csd->raw_pwr_cl_ddr_52_195;
 784                 else if (host->ios.clock <= MMC_HS200_MAX_DTR)
 785                         pwrclass_val = ext_csd->raw_pwr_cl_200_195;
 786                 break;
 787         case MMC_VDD_27_28:
 788         case MMC_VDD_28_29:
 789         case MMC_VDD_29_30:
 790         case MMC_VDD_30_31:
 791         case MMC_VDD_31_32:
 792         case MMC_VDD_32_33:
 793         case MMC_VDD_33_34:
 794         case MMC_VDD_34_35:
 795         case MMC_VDD_35_36:
 796                 if (host->ios.clock <= MMC_HIGH_26_MAX_DTR)
 797                         pwrclass_val = ext_csd->raw_pwr_cl_26_360;
 798                 else if (host->ios.clock <= MMC_HIGH_52_MAX_DTR)
 799                         pwrclass_val = (bus_width <= EXT_CSD_BUS_WIDTH_8) ?
 800                                 ext_csd->raw_pwr_cl_52_360 :
 801                                 ext_csd->raw_pwr_cl_ddr_52_360;
 802                 else if (host->ios.clock <= MMC_HS200_MAX_DTR)
 803                         pwrclass_val = (bus_width == EXT_CSD_DDR_BUS_WIDTH_8) ?
 804                                 ext_csd->raw_pwr_cl_ddr_200_360 :
 805                                 ext_csd->raw_pwr_cl_200_360;
 806                 break;
 807         default:
 808                 pr_warn("%s: Voltage range not supported for power class\n",
 809                         mmc_hostname(host));
 810                 return -EINVAL;
 811         }
 812
 813         if (bus_width & (EXT_CSD_BUS_WIDTH_8 | EXT_CSD_DDR_BUS_WIDTH_8))
 814                 pwrclass_val = (pwrclass_val & EXT_CSD_PWR_CL_8BIT_MASK) >>
 815                                 EXT_CSD_PWR_CL_8BIT_SHIFT;
 816         else
 817                 pwrclass_val = (pwrclass_val & EXT_CSD_PWR_CL_4BIT_MASK) >>
 818                                 EXT_CSD_PWR_CL_4BIT_SHIFT;
 819
 820         /* If the power class is different from the default value */
 821         if (pwrclass_val > 0) {
 822                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
 823                                  EXT_CSD_POWER_CLASS,
 824                                  pwrclass_val,
 825                                  card->ext_csd.generic_cmd6_time);
 826         }
 827
 828         return err;
 829 }
 830
 831 static int mmc_select_powerclass(struct mmc_card *card)
 832 {
 833         struct mmc_host *host = card->host;
 834         u32 bus_width, ext_csd_bits;
 835         int err, ddr;
 836
 837         /* Power class selection is supported for versions >= 4.0 */
 838         if (!mmc_can_ext_csd(card))
 839                 return 0;
 840
 841         bus_width = host->ios.bus_width;
 842         /* Power class values are defined only for 4/8 bit bus */
 843         if (bus_width == MMC_BUS_WIDTH_1)
 844                 return 0;
 845
 846         ddr = card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_52;
 847         if (ddr)
 848                 ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ?
 849                         EXT_CSD_DDR_BUS_WIDTH_8 : EXT_CSD_DDR_BUS_WIDTH_4;
 850         else
 851                 ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ?
 852                         EXT_CSD_BUS_WIDTH_8 :  EXT_CSD_BUS_WIDTH_4;
 853
 854         err = __mmc_select_powerclass(card, ext_csd_bits);
 855         if (err)
 856                 pr_warn("%s: power class selection to bus width %d ddr %d failed\n",
 857                         mmc_hostname(host), 1 << bus_width, ddr);
 858
 859         return err;
 860 }
 861
 862 /*
 863  * Set the bus speed for the selected speed mode.
 864  */
 865 static void mmc_set_bus_speed(struct mmc_card *card)
 866 {
 867         unsigned int max_dtr = (unsigned int)-1;
 868
 869         if ((mmc_card_hs200(card) || mmc_card_hs400(card)) &&
 870              max_dtr > card->ext_csd.hs200_max_dtr)
 871                 max_dtr = card->ext_csd.hs200_max_dtr;
 872         else if (mmc_card_hs(card) && max_dtr > card->ext_csd.hs_max_dtr)
 873                 max_dtr = card->ext_csd.hs_max_dtr;
 874         else if (max_dtr > card->csd.max_dtr)
 875                 max_dtr = card->csd.max_dtr;
 876
 877         mmc_set_clock(card->host, max_dtr);
 878 }
 879
 880 /*
 881  * Select the bus width amoung 4-bit and 8-bit(SDR).
 882  * If the bus width is changed successfully, return the selected width value.
 883  * Zero is returned instead of error value if the wide width is not supported.
 884  */
 885 static int mmc_select_bus_width(struct mmc_card *card)
 886 {
 887         static unsigned ext_csd_bits[] = {
 888                 EXT_CSD_BUS_WIDTH_8,
 889                 EXT_CSD_BUS_WIDTH_4,
 890         };
 891         static unsigned bus_widths[] = {
 892                 MMC_BUS_WIDTH_8,
 893                 MMC_BUS_WIDTH_4,
 894         };
 895         struct mmc_host *host = card->host;
 896         unsigned idx, bus_width = 0;
 897         int err = 0;
 898
 899         if (!mmc_can_ext_csd(card) ||
 900             !(host->caps & (MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA)))
 901                 return 0;
 902
 903         idx = (host->caps & MMC_CAP_8_BIT_DATA) ? 0 : 1;
 904
 905         /*
 906          * Unlike SD, MMC cards dont have a configuration register to notify
 907          * supported bus width. So bus test command should be run to identify
 908          * the supported bus width or compare the ext csd values of current
 909          * bus width and ext csd values of 1 bit mode read earlier.
 910          */
 911         for (; idx < ARRAY_SIZE(bus_widths); idx++) {
 912                 /*
 913                  * Host is capable of 8bit transfer, then switch
 914                  * the device to work in 8bit transfer mode. If the
 915                  * mmc switch command returns error then switch to
 916                  * 4bit transfer mode. On success set the corresponding
 917                  * bus width on the host.
 918                  */
 919                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
 920                                  EXT_CSD_BUS_WIDTH,
 921                                  ext_csd_bits[idx],
 922                                  card->ext_csd.generic_cmd6_time);
 923                 if (err)
 924                         continue;
 925
 926                 bus_width = bus_widths[idx];
 927                 mmc_set_bus_width(host, bus_width);
 928
 929                 /*
 930                  * If controller can't handle bus width test,
 931                  * compare ext_csd previously read in 1 bit mode
 932                  * against ext_csd at new bus width
 933                  */
 934                 if (!(host->caps & MMC_CAP_BUS_WIDTH_TEST))
 935                         err = mmc_compare_ext_csds(card, bus_width);
 936                 else
 937                         err = mmc_bus_test(card, bus_width);
 938
 939                 if (!err) {
 940                         err = bus_width;
 941                         break;
 942                 } else {
 943                         pr_warn("%s: switch to bus width %d failed\n",
 944                                 mmc_hostname(host), ext_csd_bits[idx]);
 945                 }
 946         }
 947
 948         return err;
 949 }
 950
 951 /*
 952  * Switch to the high-speed mode
 953  */
 954 static int mmc_select_hs(struct mmc_card *card)
 955 {
 956         int err;
 957
 958         err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
 959                            EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS,
 960                            card->ext_csd.generic_cmd6_time,
 961                            true, true, true);
 962         if (!err)
 963                 mmc_set_timing(card->host, MMC_TIMING_MMC_HS);
 964
 965         return err;
 966 }
 967
 968 /*
 969  * Activate wide bus and DDR if supported.
 970  */
 971 static int mmc_select_hs_ddr(struct mmc_card *card)
 972 {
 973         struct mmc_host *host = card->host;
 974         u32 bus_width, ext_csd_bits;
 975         int err = 0;
 976
 977         if (!(card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_52))
 978                 return 0;
 979
 980         bus_width = host->ios.bus_width;
 981         if (bus_width == MMC_BUS_WIDTH_1)
 982                 return 0;
 983
 984         ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ?
 985                 EXT_CSD_DDR_BUS_WIDTH_8 : EXT_CSD_DDR_BUS_WIDTH_4;
 986
 987         err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
 988                         EXT_CSD_BUS_WIDTH,
 989                         ext_csd_bits,
 990                         card->ext_csd.generic_cmd6_time);
 991         if (err) {
 992                 pr_err("%s: switch to bus width %d ddr failed\n",
 993                         mmc_hostname(host), 1 << bus_width);
 994                 return err;
 995         }
 996
 997         /*
 998          * eMMC cards can support 3.3V to 1.2V i/o (vccq)
 999          * signaling.
1000          *
1001          * EXT_CSD_CARD_TYPE_DDR_1_8V means 3.3V or 1.8V vccq.
1002          *
1003          * 1.8V vccq at 3.3V core voltage (vcc) is not required
1004          * in the JEDEC spec for DDR.
1005          *
1006          * Even (e)MMC card can support 3.3v to 1.2v vccq, but not all
1007          * host controller can support this, like some of the SDHCI
1008          * controller which connect to an eMMC device. Some of these
1009          * host controller still needs to use 1.8v vccq for supporting
1010          * DDR mode.
1011          *
1012          * So the sequence will be:
1013          * if (host and device can both support 1.2v IO)
1014          *      use 1.2v IO;
1015          * else if (host and device can both support 1.8v IO)
1016          *      use 1.8v IO;
1017          * so if host and device can only support 3.3v IO, this is the
1018          * last choice.
1019          *
1020          * WARNING: eMMC rules are NOT the same as SD DDR
1021          */
1022         err = -EINVAL;
1023         if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_1_2V)
1024                 err = __mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120);
1025
1026         if (err && (card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_1_8V))
1027                 err = __mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180);
1028
1029         /* make sure vccq is 3.3v after switching disaster */
1030         if (err)
1031                 err = __mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330);
1032
1033         if (!err)
1034                 mmc_set_timing(host, MMC_TIMING_MMC_DDR52);
1035
1036         return err;
1037 }
1038
1039 static int mmc_select_hs400(struct mmc_card *card)
1040 {
1041         struct mmc_host *host = card->host;
1042         int err = 0;
1043
1044         /*
1045          * HS400 mode requires 8-bit bus width
1046          */
1047         if (!(card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400 &&
1048               host->ios.bus_width == MMC_BUS_WIDTH_8))
1049                 return 0;
1050
1051         /*
1052          * Before switching to dual data rate operation for HS400,
1053          * it is required to convert from HS200 mode to HS mode.
1054          */
1055         mmc_set_timing(card->host, MMC_TIMING_MMC_HS);
1056         mmc_set_bus_speed(card);
1057
1058         err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1059                            EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS,
1060                            card->ext_csd.generic_cmd6_time,
1061                            true, true, true);
1062         if (err) {
1063                 pr_err("%s: switch to high-speed from hs200 failed, err:%d\n",
1064                         mmc_hostname(host), err);
1065                 return err;
1066         }
1067
1068         err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1069                          EXT_CSD_BUS_WIDTH,
1070                          EXT_CSD_DDR_BUS_WIDTH_8,
1071                          card->ext_csd.generic_cmd6_time);
1072         if (err) {
1073                 pr_err("%s: switch to bus width for hs400 failed, err:%d\n",
1074                         mmc_hostname(host), err);
1075                 return err;
1076         }
1077
1078         err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1079                            EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS400,
1080                            card->ext_csd.generic_cmd6_time,
1081                            true, true, true);
1082         if (err) {
1083                 pr_err("%s: switch to hs400 failed, err:%d\n",
1084                          mmc_hostname(host), err);
1085                 return err;
1086         }
1087
1088         mmc_set_timing(host, MMC_TIMING_MMC_HS400);
1089         mmc_set_bus_speed(card);
1090
1091         return 0;
1092 }
1093
1094 /*
1095  * For device supporting HS200 mode, the following sequence
1096  * should be done before executing the tuning process.
1097  * 1. set the desired bus width(4-bit or 8-bit, 1-bit is not supported)
1098  * 2. switch to HS200 mode
1099  * 3. set the clock to > 52Mhz and <=200MHz
1100  */
1101 static int mmc_select_hs200(struct mmc_card *card)
1102 {
1103         struct mmc_host *host = card->host;
1104         int err = -EINVAL;
1105
1106         if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS200_1_2V)
1107                 err = __mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120);
1108
1109         if (err && card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS200_1_8V)
1110                 err = __mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180);
1111
1112         /* If fails try again during next card power cycle */
1113         if (err)
1114                 goto err;
1115
1116         /*
1117          * Set the bus width(4 or 8) with host's support and
1118          * switch to HS200 mode if bus width is set successfully.
1119          */
1120         err = mmc_select_bus_width(card);
1121         if (!IS_ERR_VALUE(err)) {
1122                 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1123                                    EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS200,
1124                                    card->ext_csd.generic_cmd6_time,
1125                                    true, true, true);
1126                 if (!err)
1127                         mmc_set_timing(host, MMC_TIMING_MMC_HS200);
1128         }
1129 err:
1130         return err;
1131 }
1132
1133 /*
1134  * Activate High Speed or HS200 mode if supported.
1135  */
1136 static int mmc_select_timing(struct mmc_card *card)
1137 {
1138         int err = 0;
1139
1140         if (!mmc_can_ext_csd(card))
1141                 goto bus_speed;
1142
1143         if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS200)
1144                 err = mmc_select_hs200(card);
1145         else if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS)
1146                 err = mmc_select_hs(card);
1147
1148         if (err && err != -EBADMSG)
1149                 return err;
1150
1151         if (err) {
1152                 pr_warn("%s: switch to %s failed\n",
1153                         mmc_card_hs(card) ? "high-speed" :
1154                         (mmc_card_hs200(card) ? "hs200" : ""),
1155                         mmc_hostname(card->host));
1156                 err = 0;
1157         }
1158
1159 bus_speed:
1160         /*
1161          * Set the bus speed to the selected bus timing.
1162          * If timing is not selected, backward compatible is the default.
1163          */
1164         mmc_set_bus_speed(card);
1165         return err;
1166 }
1167
1168 /*
1169  * Execute tuning sequence to seek the proper bus operating
1170  * conditions for HS200 and HS400, which sends CMD21 to the device.
1171  */
1172 static int mmc_hs200_tuning(struct mmc_card *card)
1173 {
1174         struct mmc_host *host = card->host;
1175
1176         /*
1177          * Timing should be adjusted to the HS400 target
1178          * operation frequency for tuning process
1179          */
1180         if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400 &&
1181             host->ios.bus_width == MMC_BUS_WIDTH_8)
1182                 if (host->ops->prepare_hs400_tuning)
1183                         host->ops->prepare_hs400_tuning(host, &host->ios);
1184
1185         return mmc_execute_tuning(card);
1186 }
1187
1188 /*
1189  * Handle the detection and initialisation of a card.
1190  *
1191  * In the case of a resume, "oldcard" will contain the card
1192  * we're trying to reinitialise.
1193  */
1194 static int mmc_init_card(struct mmc_host *host, u32 ocr,
1195         struct mmc_card *oldcard)
1196 {
1197         struct mmc_card *card;
1198         int err;
1199         u32 cid[4];
1200         u32 rocr;
1201
1202         BUG_ON(!host);
1203         WARN_ON(!host->claimed);
1204
1205         /* Set correct bus mode for MMC before attempting init */
1206         if (!mmc_host_is_spi(host))
1207                 mmc_set_bus_mode(host, MMC_BUSMODE_OPENDRAIN);
1208
1209         /*
1210          * Since we're changing the OCR value, we seem to
1211          * need to tell some cards to go back to the idle
1212          * state.  We wait 1ms to give cards time to
1213          * respond.
1214          * mmc_go_idle is needed for eMMC that are asleep
1215          */
1216         mmc_go_idle(host);
1217
1218         /* The extra bit indicates that we support high capacity */
1219         err = mmc_send_op_cond(host, ocr | (1 << 30), &rocr);
1220         if (err)
1221                 goto err;
1222
1223         /*
1224          * For SPI, enable CRC as appropriate.
1225          */
1226         if (mmc_host_is_spi(host)) {
1227                 err = mmc_spi_set_crc(host, use_spi_crc);
1228                 if (err)
1229                         goto err;
1230         }
1231
1232         /*
1233          * Fetch CID from card.
1234          */
1235         if (mmc_host_is_spi(host))
1236                 err = mmc_send_cid(host, cid);
1237         else
1238                 err = mmc_all_send_cid(host, cid);
1239         if (err)
1240                 goto err;
1241
1242         if (oldcard) {
1243                 if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0) {
1244                         err = -ENOENT;
1245                         goto err;
1246                 }
1247
1248                 card = oldcard;
1249         } else {
1250                 /*
1251                  * Allocate card structure.
1252                  */
1253                 card = mmc_alloc_card(host, &mmc_type);
1254                 if (IS_ERR(card)) {
1255                         err = PTR_ERR(card);
1256                         goto err;
1257                 }
1258
1259                 card->ocr = ocr;
1260                 card->type = MMC_TYPE_MMC;
1261                 card->rca = 1;
1262                 memcpy(card->raw_cid, cid, sizeof(card->raw_cid));
1263         }
1264
1265         /*
1266          * Call the optional HC's init_card function to handle quirks.
1267          */
1268         if (host->ops->init_card)
1269                 host->ops->init_card(host, card);
1270
1271         /*
1272          * For native busses:  set card RCA and quit open drain mode.
1273          */
1274         if (!mmc_host_is_spi(host)) {
1275                 err = mmc_set_relative_addr(card);
1276                 if (err)
1277                         goto free_card;
1278
1279                 mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL);
1280         }
1281
1282         if (!oldcard) {
1283                 /*
1284                  * Fetch CSD from card.
1285                  */
1286                 err = mmc_send_csd(card, card->raw_csd);
1287                 if (err)
1288                         goto free_card;
1289
1290                 err = mmc_decode_csd(card);
1291                 if (err)
1292                         goto free_card;
1293                 err = mmc_decode_cid(card);
1294                 if (err)
1295                         goto free_card;
1296         }
1297
1298         /*
1299          * handling only for cards supporting DSR and hosts requesting
1300          * DSR configuration
1301          */
1302         if (card->csd.dsr_imp && host->dsr_req)
1303                 mmc_set_dsr(host);
1304
1305         /*
1306          * Select card, as all following commands rely on that.
1307          */
1308         if (!mmc_host_is_spi(host)) {
1309                 err = mmc_select_card(card);
1310                 if (err)
1311                         goto free_card;
1312         }
1313
1314         if (!oldcard) {
1315                 /* Read extended CSD. */
1316                 err = mmc_read_ext_csd(card);
1317                 if (err)
1318                         goto free_card;
1319
1320                 /* If doing byte addressing, check if required to do sector
1321                  * addressing.  Handle the case of <2GB cards needing sector
1322                  * addressing.  See section 8.1 JEDEC Standard JED84-A441;
1323                  * ocr register has bit 30 set for sector addressing.
1324                  */
1325                 if (!(mmc_card_blockaddr(card)) && (rocr & (1<<30)))
1326                         mmc_card_set_blockaddr(card);
1327
1328                 /* Erase size depends on CSD and Extended CSD */
1329                 mmc_set_erase_size(card);
1330         }
1331
1332         /*
1333          * If enhanced_area_en is TRUE, host needs to enable ERASE_GRP_DEF
1334          * bit.  This bit will be lost every time after a reset or power off.
1335          */
1336         if (card->ext_csd.partition_setting_completed ||
1337             (card->ext_csd.rev >= 3 && (host->caps2 & MMC_CAP2_HC_ERASE_SZ))) {
1338                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1339                                  EXT_CSD_ERASE_GROUP_DEF, 1,
1340                                  card->ext_csd.generic_cmd6_time);
1341
1342                 if (err && err != -EBADMSG)
1343                         goto free_card;
1344
1345                 if (err) {
1346                         err = 0;
1347                         /*
1348                          * Just disable enhanced area off & sz
1349                          * will try to enable ERASE_GROUP_DEF
1350                          * during next time reinit
1351                          */
1352                         card->ext_csd.enhanced_area_offset = -EINVAL;
1353                         card->ext_csd.enhanced_area_size = -EINVAL;
1354                 } else {
1355                         card->ext_csd.erase_group_def = 1;
1356                         /*
1357                          * enable ERASE_GRP_DEF successfully.
1358                          * This will affect the erase size, so
1359                          * here need to reset erase size
1360                          */
1361                         mmc_set_erase_size(card);
1362                 }
1363         }
1364
1365         /*
1366          * Ensure eMMC user default partition is enabled
1367          */
1368         if (card->ext_csd.part_config & EXT_CSD_PART_CONFIG_ACC_MASK) {
1369                 card->ext_csd.part_config &= ~EXT_CSD_PART_CONFIG_ACC_MASK;
1370                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONFIG,
1371                                  card->ext_csd.part_config,
1372                                  card->ext_csd.part_time);
1373                 if (err && err != -EBADMSG)
1374                         goto free_card;
1375         }
1376
1377         /*
1378          * Enable power_off_notification byte in the ext_csd register
1379          */
1380         if (card->ext_csd.rev >= 6) {
1381                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1382                                  EXT_CSD_POWER_OFF_NOTIFICATION,
1383                                  EXT_CSD_POWER_ON,
1384                                  card->ext_csd.generic_cmd6_time);
1385                 if (err && err != -EBADMSG)
1386                         goto free_card;
1387
1388                 /*
1389                  * The err can be -EBADMSG or 0,
1390                  * so check for success and update the flag
1391                  */
1392                 if (!err)
1393                         card->ext_csd.power_off_notification = EXT_CSD_POWER_ON;
1394         }
1395
1396         /*
1397          * Select timing interface
1398          */
1399         err = mmc_select_timing(card);
1400         if (err)
1401                 goto free_card;
1402
1403         if (mmc_card_hs200(card)) {
1404                 err = mmc_hs200_tuning(card);
1405                 if (err)
1406                         goto free_card;
1407
1408                 err = mmc_select_hs400(card);
1409                 if (err)
1410                         goto free_card;
1411         } else if (mmc_card_hs(card)) {
1412                 /* Select the desired bus width optionally */
1413                 err = mmc_select_bus_width(card);
1414                 if (!IS_ERR_VALUE(err)) {
1415                         err = mmc_select_hs_ddr(card);
1416                         if (err)
1417                                 goto free_card;
1418                 }
1419         }
1420
1421         /*
1422          * Choose the power class with selected bus interface
1423          */
1424         mmc_select_powerclass(card);
1425
1426         /*
1427          * Enable HPI feature (if supported)
1428          */
1429         if (card->ext_csd.hpi) {
1430                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1431                                 EXT_CSD_HPI_MGMT, 1,
1432                                 card->ext_csd.generic_cmd6_time);
1433                 if (err && err != -EBADMSG)
1434                         goto free_card;
1435                 if (err) {
1436                         pr_warn("%s: Enabling HPI failed\n",
1437                                 mmc_hostname(card->host));
1438                         err = 0;
1439                 } else
1440                         card->ext_csd.hpi_en = 1;
1441         }
1442
1443         /*
1444          * If cache size is higher than 0, this indicates
1445          * the existence of cache and it can be turned on.
1446          */
1447         if (card->ext_csd.cache_size > 0) {
1448                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1449                                 EXT_CSD_CACHE_CTRL, 1,
1450                                 card->ext_csd.generic_cmd6_time);
1451                 if (err && err != -EBADMSG)
1452                         goto free_card;
1453
1454                 /*
1455                  * Only if no error, cache is turned on successfully.
1456                  */
1457                 if (err) {
1458                         pr_warn("%s: Cache is supported, but failed to turn on (%d)\n",
1459                                 mmc_hostname(card->host), err);
1460                         card->ext_csd.cache_ctrl = 0;
1461                         err = 0;
1462                 } else {
1463                         card->ext_csd.cache_ctrl = 1;
1464                 }
1465         }
1466
1467         /*
1468          * The mandatory minimum values are defined for packed command.
1469          * read: 5, write: 3
1470          */
1471         if (card->ext_csd.max_packed_writes >= 3 &&
1472             card->ext_csd.max_packed_reads >= 5 &&
1473             host->caps2 & MMC_CAP2_PACKED_CMD) {
1474                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1475                                 EXT_CSD_EXP_EVENTS_CTRL,
1476                                 EXT_CSD_PACKED_EVENT_EN,
1477                                 card->ext_csd.generic_cmd6_time);
1478                 if (err && err != -EBADMSG)
1479                         goto free_card;
1480                 if (err) {
1481                         pr_warn("%s: Enabling packed event failed\n",
1482                                 mmc_hostname(card->host));
1483                         card->ext_csd.packed_event_en = 0;
1484                         err = 0;
1485                 } else {
1486                         card->ext_csd.packed_event_en = 1;
1487                 }
1488         }
1489
1490         if (!oldcard)
1491                 host->card = card;
1492
1493         return 0;
1494
1495 free_card:
1496         if (!oldcard)
1497                 mmc_remove_card(card);
1498 err:
1499         return err;
1500 }
1501
1502 static int mmc_can_sleep(struct mmc_card *card)
1503 {
1504         return (card && card->ext_csd.rev >= 3);
1505 }
1506
1507 static int mmc_sleep(struct mmc_host *host)
1508 {
1509         struct mmc_command cmd = {0};
1510         struct mmc_card *card = host->card;
1511         unsigned int timeout_ms = DIV_ROUND_UP(card->ext_csd.sa_timeout, 10000);
1512         int err;
1513
1514         err = mmc_deselect_cards(host);
1515         if (err)
1516                 return err;
1517
1518         cmd.opcode = MMC_SLEEP_AWAKE;
1519         cmd.arg = card->rca << 16;
1520         cmd.arg |= 1 << 15;
1521
1522         /*
1523          * If the max_busy_timeout of the host is specified, validate it against
1524          * the sleep cmd timeout. A failure means we need to prevent the host
1525          * from doing hw busy detection, which is done by converting to a R1
1526          * response instead of a R1B.
1527          */
1528         if (host->max_busy_timeout && (timeout_ms > host->max_busy_timeout)) {
1529                 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
1530         } else {
1531                 cmd.flags = MMC_RSP_R1B | MMC_CMD_AC;
1532                 cmd.busy_timeout = timeout_ms;
1533         }
1534
1535         err = mmc_wait_for_cmd(host, &cmd, 0);
1536         if (err)
1537                 return err;
1538
1539         /*
1540          * If the host does not wait while the card signals busy, then we will
1541          * will have to wait the sleep/awake timeout.  Note, we cannot use the
1542          * SEND_STATUS command to poll the status because that command (and most
1543          * others) is invalid while the card sleeps.
1544          */
1545         if (!cmd.busy_timeout || !(host->caps & MMC_CAP_WAIT_WHILE_BUSY))
1546                 mmc_delay(timeout_ms);
1547
1548         return err;
1549 }
1550
1551 static int mmc_can_poweroff_notify(const struct mmc_card *card)
1552 {
1553         return card &&
1554                 mmc_card_mmc(card) &&
1555                 (card->ext_csd.power_off_notification == EXT_CSD_POWER_ON);
1556 }
1557
1558 static int mmc_poweroff_notify(struct mmc_card *card, unsigned int notify_type)
1559 {
1560         unsigned int timeout = card->ext_csd.generic_cmd6_time;
1561         int err;
1562
1563         /* Use EXT_CSD_POWER_OFF_SHORT as default notification type. */
1564         if (notify_type == EXT_CSD_POWER_OFF_LONG)
1565                 timeout = card->ext_csd.power_off_longtime;
1566
1567         err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1568                         EXT_CSD_POWER_OFF_NOTIFICATION,
1569                         notify_type, timeout, true, false, false);
1570         if (err)
1571                 pr_err("%s: Power Off Notification timed out, %u\n",
1572                        mmc_hostname(card->host), timeout);
1573
1574         /* Disable the power off notification after the switch operation. */
1575         card->ext_csd.power_off_notification = EXT_CSD_NO_POWER_NOTIFICATION;
1576
1577         return err;
1578 }
1579
1580 /*
1581  * Host is being removed. Free up the current card.
1582  */
1583 static void mmc_remove(struct mmc_host *host)
1584 {
1585         BUG_ON(!host);
1586         BUG_ON(!host->card);
1587
1588         mmc_remove_card(host->card);
1589         host->card = NULL;
1590 }
1591
1592 /*
1593  * Card detection - card is alive.
1594  */
1595 static int mmc_alive(struct mmc_host *host)
1596 {
1597         return mmc_send_status(host->card, NULL);
1598 }
1599
1600 /*
1601  * Card detection callback from host.
1602  */
1603 static void mmc_detect(struct mmc_host *host)
1604 {
1605         int err;
1606
1607         BUG_ON(!host);
1608         BUG_ON(!host->card);
1609
1610         mmc_get_card(host->card);
1611
1612         /*
1613          * Just check if our card has been removed.
1614          */
1615         err = _mmc_detect_card_removed(host);
1616
1617         mmc_put_card(host->card);
1618
1619         if (err) {
1620                 mmc_remove(host);
1621
1622                 mmc_claim_host(host);
1623                 mmc_detach_bus(host);
1624                 mmc_power_off(host);
1625                 mmc_release_host(host);
1626         }
1627 }
1628
1629 static int _mmc_suspend(struct mmc_host *host, bool is_suspend)
1630 {
1631         int err = 0;
1632         unsigned int notify_type = is_suspend ? EXT_CSD_POWER_OFF_SHORT :
1633                                         EXT_CSD_POWER_OFF_LONG;
1634
1635         BUG_ON(!host);
1636         BUG_ON(!host->card);
1637
1638         mmc_claim_host(host);
1639
1640         if (mmc_card_suspended(host->card))
1641                 goto out;
1642
1643         if (mmc_card_doing_bkops(host->card)) {
1644                 err = mmc_stop_bkops(host->card);
1645                 if (err)
1646                         goto out;
1647         }
1648
1649         err = mmc_flush_cache(host->card);
1650         if (err)
1651                 goto out;
1652
1653         if (mmc_can_poweroff_notify(host->card) &&
1654                 ((host->caps2 & MMC_CAP2_FULL_PWR_CYCLE) || !is_suspend))
1655                 err = mmc_poweroff_notify(host->card, notify_type);
1656         else if (mmc_can_sleep(host->card))
1657                 err = mmc_sleep(host);
1658         else if (!mmc_host_is_spi(host))
1659                 err = mmc_deselect_cards(host);
1660
1661         if (!err) {
1662                 mmc_power_off(host);
1663                 mmc_card_set_suspended(host->card);
1664         }
1665 out:
1666         mmc_release_host(host);
1667         return err;
1668 }
1669
1670 /*
1671  * Suspend callback
1672  */
1673 static int mmc_suspend(struct mmc_host *host)
1674 {
1675         int err;
1676
1677         err = _mmc_suspend(host, true);
1678         if (!err) {
1679                 pm_runtime_disable(&host->card->dev);
1680                 pm_runtime_set_suspended(&host->card->dev);
1681         }
1682
1683         return err;
1684 }
1685
1686 /*
1687  * This function tries to determine if the same card is still present
1688  * and, if so, restore all state to it.
1689  */
1690 static int _mmc_resume(struct mmc_host *host)
1691 {
1692         int err = 0;
1693
1694         BUG_ON(!host);
1695         BUG_ON(!host->card);
1696
1697         mmc_claim_host(host);
1698
1699         if (!mmc_card_suspended(host->card))
1700                 goto out;
1701
1702         mmc_power_up(host, host->card->ocr);
1703         err = mmc_init_card(host, host->card->ocr, host->card);
1704         mmc_card_clr_suspended(host->card);
1705
1706 out:
1707         mmc_release_host(host);
1708         return err;
1709 }
1710
1711 /*
1712  * Shutdown callback
1713  */
1714 static int mmc_shutdown(struct mmc_host *host)
1715 {
1716         int err = 0;
1717
1718         /*
1719          * In a specific case for poweroff notify, we need to resume the card
1720          * before we can shutdown it properly.
1721          */
1722         if (mmc_can_poweroff_notify(host->card) &&
1723                 !(host->caps2 & MMC_CAP2_FULL_PWR_CYCLE))
1724                 err = _mmc_resume(host);
1725
1726         if (!err)
1727                 err = _mmc_suspend(host, false);
1728
1729         return err;
1730 }
1731
1732 /*
1733  * Callback for resume.
1734  */
1735 static int mmc_resume(struct mmc_host *host)
1736 {
1737         int err = 0;
1738
1739         if (!(host->caps & MMC_CAP_RUNTIME_RESUME)) {
1740                 err = _mmc_resume(host);
1741                 pm_runtime_set_active(&host->card->dev);
1742                 pm_runtime_mark_last_busy(&host->card->dev);
1743         }
1744         pm_runtime_enable(&host->card->dev);
1745
1746         return err;
1747 }
1748
1749 /*
1750  * Callback for runtime_suspend.
1751  */
1752 static int mmc_runtime_suspend(struct mmc_host *host)
1753 {
1754         int err;
1755
1756         if (!(host->caps & MMC_CAP_AGGRESSIVE_PM))
1757                 return 0;
1758
1759         err = _mmc_suspend(host, true);
1760         if (err)
1761                 pr_err("%s: error %d doing aggressive suspend\n",
1762                         mmc_hostname(host), err);
1763
1764         return err;
1765 }
1766
1767 /*
1768  * Callback for runtime_resume.
1769  */
1770 static int mmc_runtime_resume(struct mmc_host *host)
1771 {
1772         int err;
1773
1774         if (!(host->caps & (MMC_CAP_AGGRESSIVE_PM | MMC_CAP_RUNTIME_RESUME)))
1775                 return 0;
1776
1777         err = _mmc_resume(host);
1778         if (err)
1779                 pr_err("%s: error %d doing aggressive resume\n",
1780                         mmc_hostname(host), err);
1781
1782         return 0;
1783 }
1784
1785 static int mmc_power_restore(struct mmc_host *host)
1786 {
1787         int ret;
1788
1789         mmc_claim_host(host);
1790         ret = mmc_init_card(host, host->card->ocr, host->card);
1791         mmc_release_host(host);
1792
1793         return ret;
1794 }
1795
1796 int mmc_can_reset(struct mmc_card *card)
1797 {
1798         u8 rst_n_function;
1799
1800         rst_n_function = card->ext_csd.rst_n_function;
1801         if ((rst_n_function & EXT_CSD_RST_N_EN_MASK) != EXT_CSD_RST_N_ENABLED)
1802                 return 0;
1803         return 1;
1804 }
1805 EXPORT_SYMBOL(mmc_can_reset);
1806
1807 static int mmc_reset(struct mmc_host *host)
1808 {
1809         struct mmc_card *card = host->card;
1810         u32 status;
1811
1812         if (!(host->caps & MMC_CAP_HW_RESET) || !host->ops->hw_reset)
1813                 return -EOPNOTSUPP;
1814
1815         if (!mmc_can_reset(card))
1816                 return -EOPNOTSUPP;
1817
1818         mmc_host_clk_hold(host);
1819         mmc_set_clock(host, host->f_init);
1820
1821         host->ops->hw_reset(host);
1822
1823         /* If the reset has happened, then a status command will fail */
1824         if (!mmc_send_status(card, &status)) {
1825                 mmc_host_clk_release(host);
1826                 return -ENOSYS;
1827         }
1828
1829         /* Set initial state and call mmc_set_ios */
1830         mmc_set_initial_state(host);
1831         mmc_host_clk_release(host);
1832
1833         return mmc_power_restore(host);
1834 }
1835
1836 static const struct mmc_bus_ops mmc_ops = {
1837         .remove = mmc_remove,
1838         .detect = mmc_detect,
1839         .suspend = mmc_suspend,
1840         .resume = mmc_resume,
1841         .runtime_suspend = mmc_runtime_suspend,
1842         .runtime_resume = mmc_runtime_resume,
1843         .power_restore = mmc_power_restore,
1844         .alive = mmc_alive,
1845         .shutdown = mmc_shutdown,
1846         .reset = mmc_reset,
1847 };
1848
1849 /*
1850  * Starting point for MMC card init.
1851  */
1852 int mmc_attach_mmc(struct mmc_host *host)
1853 {
1854         int err;
1855         u32 ocr, rocr;
1856
1857         BUG_ON(!host);
1858         WARN_ON(!host->claimed);
1859
1860         /* Set correct bus mode for MMC before attempting attach */
1861         if (!mmc_host_is_spi(host))
1862                 mmc_set_bus_mode(host, MMC_BUSMODE_OPENDRAIN);
1863
1864         err = mmc_send_op_cond(host, 0, &ocr);
1865         if (err)
1866                 return err;
1867
1868         mmc_attach_bus(host, &mmc_ops);
1869         if (host->ocr_avail_mmc)
1870                 host->ocr_avail = host->ocr_avail_mmc;
1871
1872         /*
1873          * We need to get OCR a different way for SPI.
1874          */
1875         if (mmc_host_is_spi(host)) {
1876                 err = mmc_spi_read_ocr(host, 1, &ocr);
1877                 if (err)
1878                         goto err;
1879         }
1880
1881         rocr = mmc_select_voltage(host, ocr);
1882
1883         /*
1884          * Can we support the voltage of the card?
1885          */
1886         if (!rocr) {
1887                 err = -EINVAL;
1888                 goto err;
1889         }
1890
1891         /*
1892          * Detect and init the card.
1893          */
1894         err = mmc_init_card(host, rocr, NULL);
1895         if (err)
1896                 goto err;
1897
1898         mmc_release_host(host);
1899         err = mmc_add_card(host->card);
1900         mmc_claim_host(host);
1901         if (err)
1902                 goto remove_card;
1903
1904         return 0;
1905
1906 remove_card:
1907         mmc_release_host(host);
1908         mmc_remove_card(host->card);
1909         mmc_claim_host(host);
1910         host->card = NULL;
1911 err:
1912         mmc_detach_bus(host);
1913
1914         pr_err("%s: error %d whilst initialising MMC card\n",
1915                 mmc_hostname(host), err);
1916
1917         return err;
1918 }