drivers/mmc/core/mmc.c

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