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 int mmc_compare_ext_csds(struct mmc_card *card, unsigned bus_width)
 644 {
 645         u8 *bw_ext_csd;
 646         int err;
 647
 648         if (bus_width == MMC_BUS_WIDTH_1)
 649                 return 0;
 650
 651         err = mmc_get_ext_csd(card, &bw_ext_csd);
 652
 653         if (err || bw_ext_csd == NULL) {
 654                 err = -EINVAL;
 655                 goto out;
 656         }
 657
 658         /* only compare read only fields */
 659         err = !((card->ext_csd.raw_partition_support ==
 660                         bw_ext_csd[EXT_CSD_PARTITION_SUPPORT]) &&
 661                 (card->ext_csd.raw_erased_mem_count ==
 662                         bw_ext_csd[EXT_CSD_ERASED_MEM_CONT]) &&
 663                 (card->ext_csd.rev ==
 664                         bw_ext_csd[EXT_CSD_REV]) &&
 665                 (card->ext_csd.raw_ext_csd_structure ==
 666                         bw_ext_csd[EXT_CSD_STRUCTURE]) &&
 667                 (card->ext_csd.raw_card_type ==
 668                         bw_ext_csd[EXT_CSD_CARD_TYPE]) &&
 669                 (card->ext_csd.raw_s_a_timeout ==
 670                         bw_ext_csd[EXT_CSD_S_A_TIMEOUT]) &&
 671                 (card->ext_csd.raw_hc_erase_gap_size ==
 672                         bw_ext_csd[EXT_CSD_HC_WP_GRP_SIZE]) &&
 673                 (card->ext_csd.raw_erase_timeout_mult ==
 674                         bw_ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT]) &&
 675                 (card->ext_csd.raw_hc_erase_grp_size ==
 676                         bw_ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]) &&
 677                 (card->ext_csd.raw_sec_trim_mult ==
 678                         bw_ext_csd[EXT_CSD_SEC_TRIM_MULT]) &&
 679                 (card->ext_csd.raw_sec_erase_mult ==
 680                         bw_ext_csd[EXT_CSD_SEC_ERASE_MULT]) &&
 681                 (card->ext_csd.raw_sec_feature_support ==
 682                         bw_ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT]) &&
 683                 (card->ext_csd.raw_trim_mult ==
 684                         bw_ext_csd[EXT_CSD_TRIM_MULT]) &&
 685                 (card->ext_csd.raw_sectors[0] ==
 686                         bw_ext_csd[EXT_CSD_SEC_CNT + 0]) &&
 687                 (card->ext_csd.raw_sectors[1] ==
 688                         bw_ext_csd[EXT_CSD_SEC_CNT + 1]) &&
 689                 (card->ext_csd.raw_sectors[2] ==
 690                         bw_ext_csd[EXT_CSD_SEC_CNT + 2]) &&
 691                 (card->ext_csd.raw_sectors[3] ==
 692                         bw_ext_csd[EXT_CSD_SEC_CNT + 3]) &&
 693                 (card->ext_csd.raw_pwr_cl_52_195 ==
 694                         bw_ext_csd[EXT_CSD_PWR_CL_52_195]) &&
 695                 (card->ext_csd.raw_pwr_cl_26_195 ==
 696                         bw_ext_csd[EXT_CSD_PWR_CL_26_195]) &&
 697                 (card->ext_csd.raw_pwr_cl_52_360 ==
 698                         bw_ext_csd[EXT_CSD_PWR_CL_52_360]) &&
 699                 (card->ext_csd.raw_pwr_cl_26_360 ==
 700                         bw_ext_csd[EXT_CSD_PWR_CL_26_360]) &&
 701                 (card->ext_csd.raw_pwr_cl_200_195 ==
 702                         bw_ext_csd[EXT_CSD_PWR_CL_200_195]) &&
 703                 (card->ext_csd.raw_pwr_cl_200_360 ==
 704                         bw_ext_csd[EXT_CSD_PWR_CL_200_360]) &&
 705                 (card->ext_csd.raw_pwr_cl_ddr_52_195 ==
 706                         bw_ext_csd[EXT_CSD_PWR_CL_DDR_52_195]) &&
 707                 (card->ext_csd.raw_pwr_cl_ddr_52_360 ==
 708                         bw_ext_csd[EXT_CSD_PWR_CL_DDR_52_360]) &&
 709                 (card->ext_csd.raw_pwr_cl_ddr_200_360 ==
 710                         bw_ext_csd[EXT_CSD_PWR_CL_DDR_200_360]));
 711
 712         if (err)
 713                 err = -EINVAL;
 714
 715 out:
 716         kfree(bw_ext_csd);
 717         return err;
 718 }
 719
 720 MMC_DEV_ATTR(cid, "%08x%08x%08x%08x\n", card->raw_cid[0], card->raw_cid[1],
 721         card->raw_cid[2], card->raw_cid[3]);
 722 MMC_DEV_ATTR(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1],
 723         card->raw_csd[2], card->raw_csd[3]);
 724 MMC_DEV_ATTR(date, "%02d/%04d\n", card->cid.month, card->cid.year);
 725 MMC_DEV_ATTR(erase_size, "%u\n", card->erase_size << 9);
 726 MMC_DEV_ATTR(preferred_erase_size, "%u\n", card->pref_erase << 9);
 727 MMC_DEV_ATTR(ffu_capable, "%d\n", card->ext_csd.ffu_capable);
 728 MMC_DEV_ATTR(hwrev, "0x%x\n", card->cid.hwrev);
 729 MMC_DEV_ATTR(manfid, "0x%06x\n", card->cid.manfid);
 730 MMC_DEV_ATTR(name, "%s\n", card->cid.prod_name);
 731 MMC_DEV_ATTR(oemid, "0x%04x\n", card->cid.oemid);
 732 MMC_DEV_ATTR(prv, "0x%x\n", card->cid.prv);
 733 MMC_DEV_ATTR(serial, "0x%08x\n", card->cid.serial);
 734 MMC_DEV_ATTR(enhanced_area_offset, "%llu\n",
 735                 card->ext_csd.enhanced_area_offset);
 736 MMC_DEV_ATTR(enhanced_area_size, "%u\n", card->ext_csd.enhanced_area_size);
 737 MMC_DEV_ATTR(raw_rpmb_size_mult, "%#x\n", card->ext_csd.raw_rpmb_size_mult);
 738 MMC_DEV_ATTR(rel_sectors, "%#x\n", card->ext_csd.rel_sectors);
 739
 740 static ssize_t mmc_fwrev_show(struct device *dev,
 741                               struct device_attribute *attr,
 742                               char *buf)
 743 {
 744         struct mmc_card *card = mmc_dev_to_card(dev);
 745
 746         if (card->ext_csd.rev < 7) {
 747                 return sprintf(buf, "0x%x\n", card->cid.fwrev);
 748         } else {
 749                 return sprintf(buf, "0x%*phN\n", MMC_FIRMWARE_LEN,
 750                                card->ext_csd.fwrev);
 751         }
 752 }
 753
 754 static DEVICE_ATTR(fwrev, S_IRUGO, mmc_fwrev_show, NULL);
 755
 756 static struct attribute *mmc_std_attrs[] = {
 757         &dev_attr_cid.attr,
 758         &dev_attr_csd.attr,
 759         &dev_attr_date.attr,
 760         &dev_attr_erase_size.attr,
 761         &dev_attr_preferred_erase_size.attr,
 762         &dev_attr_fwrev.attr,
 763         &dev_attr_ffu_capable.attr,
 764         &dev_attr_hwrev.attr,
 765         &dev_attr_manfid.attr,
 766         &dev_attr_name.attr,
 767         &dev_attr_oemid.attr,
 768         &dev_attr_prv.attr,
 769         &dev_attr_serial.attr,
 770         &dev_attr_enhanced_area_offset.attr,
 771         &dev_attr_enhanced_area_size.attr,
 772         &dev_attr_raw_rpmb_size_mult.attr,
 773         &dev_attr_rel_sectors.attr,
 774         NULL,
 775 };
 776 ATTRIBUTE_GROUPS(mmc_std);
 777
 778 static struct device_type mmc_type = {
 779         .groups = mmc_std_groups,
 780 };
 781
 782 /*
 783  * Select the PowerClass for the current bus width
 784  * If power class is defined for 4/8 bit bus in the
 785  * extended CSD register, select it by executing the
 786  * mmc_switch command.
 787  */
 788 static int __mmc_select_powerclass(struct mmc_card *card,
 789                                    unsigned int bus_width)
 790 {
 791         struct mmc_host *host = card->host;
 792         struct mmc_ext_csd *ext_csd = &card->ext_csd;
 793         unsigned int pwrclass_val = 0;
 794         int err = 0;
 795
 796         switch (1 << host->ios.vdd) {
 797         case MMC_VDD_165_195:
 798                 if (host->ios.clock <= MMC_HIGH_26_MAX_DTR)
 799                         pwrclass_val = ext_csd->raw_pwr_cl_26_195;
 800                 else if (host->ios.clock <= MMC_HIGH_52_MAX_DTR)
 801                         pwrclass_val = (bus_width <= EXT_CSD_BUS_WIDTH_8) ?
 802                                 ext_csd->raw_pwr_cl_52_195 :
 803                                 ext_csd->raw_pwr_cl_ddr_52_195;
 804                 else if (host->ios.clock <= MMC_HS200_MAX_DTR)
 805                         pwrclass_val = ext_csd->raw_pwr_cl_200_195;
 806                 break;
 807         case MMC_VDD_27_28:
 808         case MMC_VDD_28_29:
 809         case MMC_VDD_29_30:
 810         case MMC_VDD_30_31:
 811         case MMC_VDD_31_32:
 812         case MMC_VDD_32_33:
 813         case MMC_VDD_33_34:
 814         case MMC_VDD_34_35:
 815         case MMC_VDD_35_36:
 816                 if (host->ios.clock <= MMC_HIGH_26_MAX_DTR)
 817                         pwrclass_val = ext_csd->raw_pwr_cl_26_360;
 818                 else if (host->ios.clock <= MMC_HIGH_52_MAX_DTR)
 819                         pwrclass_val = (bus_width <= EXT_CSD_BUS_WIDTH_8) ?
 820                                 ext_csd->raw_pwr_cl_52_360 :
 821                                 ext_csd->raw_pwr_cl_ddr_52_360;
 822                 else if (host->ios.clock <= MMC_HS200_MAX_DTR)
 823                         pwrclass_val = (bus_width == EXT_CSD_DDR_BUS_WIDTH_8) ?
 824                                 ext_csd->raw_pwr_cl_ddr_200_360 :
 825                                 ext_csd->raw_pwr_cl_200_360;
 826                 break;
 827         default:
 828                 pr_warn("%s: Voltage range not supported for power class\n",
 829                         mmc_hostname(host));
 830                 return -EINVAL;
 831         }
 832
 833         if (bus_width & (EXT_CSD_BUS_WIDTH_8 | EXT_CSD_DDR_BUS_WIDTH_8))
 834                 pwrclass_val = (pwrclass_val & EXT_CSD_PWR_CL_8BIT_MASK) >>
 835                                 EXT_CSD_PWR_CL_8BIT_SHIFT;
 836         else
 837                 pwrclass_val = (pwrclass_val & EXT_CSD_PWR_CL_4BIT_MASK) >>
 838                                 EXT_CSD_PWR_CL_4BIT_SHIFT;
 839
 840         /* If the power class is different from the default value */
 841         if (pwrclass_val > 0) {
 842                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
 843                                  EXT_CSD_POWER_CLASS,
 844                                  pwrclass_val,
 845                                  card->ext_csd.generic_cmd6_time);
 846         }
 847
 848         return err;
 849 }
 850
 851 static int mmc_select_powerclass(struct mmc_card *card)
 852 {
 853         struct mmc_host *host = card->host;
 854         u32 bus_width, ext_csd_bits;
 855         int err, ddr;
 856
 857         /* Power class selection is supported for versions >= 4.0 */
 858         if (card->csd.mmca_vsn < CSD_SPEC_VER_4)
 859                 return 0;
 860
 861         bus_width = host->ios.bus_width;
 862         /* Power class values are defined only for 4/8 bit bus */
 863         if (bus_width == MMC_BUS_WIDTH_1)
 864                 return 0;
 865
 866         ddr = card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_52;
 867         if (ddr)
 868                 ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ?
 869                         EXT_CSD_DDR_BUS_WIDTH_8 : EXT_CSD_DDR_BUS_WIDTH_4;
 870         else
 871                 ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ?
 872                         EXT_CSD_BUS_WIDTH_8 :  EXT_CSD_BUS_WIDTH_4;
 873
 874         err = __mmc_select_powerclass(card, ext_csd_bits);
 875         if (err)
 876                 pr_warn("%s: power class selection to bus width %d ddr %d failed\n",
 877                         mmc_hostname(host), 1 << bus_width, ddr);
 878
 879         return err;
 880 }
 881
 882 /*
 883  * Set the bus speed for the selected speed mode.
 884  */
 885 static void mmc_set_bus_speed(struct mmc_card *card)
 886 {
 887         unsigned int max_dtr = (unsigned int)-1;
 888
 889         if ((mmc_card_hs200(card) || mmc_card_hs400(card)) &&
 890              max_dtr > card->ext_csd.hs200_max_dtr)
 891                 max_dtr = card->ext_csd.hs200_max_dtr;
 892         else if (mmc_card_hs(card) && max_dtr > card->ext_csd.hs_max_dtr)
 893                 max_dtr = card->ext_csd.hs_max_dtr;
 894         else if (max_dtr > card->csd.max_dtr)
 895                 max_dtr = card->csd.max_dtr;
 896
 897         mmc_set_clock(card->host, max_dtr);
 898 }
 899
 900 /*
 901  * Select the bus width amoung 4-bit and 8-bit(SDR).
 902  * If the bus width is changed successfully, return the selected width value.
 903  * Zero is returned instead of error value if the wide width is not supported.
 904  */
 905 static int mmc_select_bus_width(struct mmc_card *card)
 906 {
 907         static unsigned ext_csd_bits[] = {
 908                 EXT_CSD_BUS_WIDTH_8,
 909                 EXT_CSD_BUS_WIDTH_4,
 910         };
 911         static unsigned bus_widths[] = {
 912                 MMC_BUS_WIDTH_8,
 913                 MMC_BUS_WIDTH_4,
 914         };
 915         struct mmc_host *host = card->host;
 916         unsigned idx, bus_width = 0;
 917         int err = 0;
 918
 919         if ((card->csd.mmca_vsn < CSD_SPEC_VER_4) &&
 920             !(host->caps & (MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA)))
 921                 return 0;
 922
 923         idx = (host->caps & MMC_CAP_8_BIT_DATA) ? 0 : 1;
 924
 925         /*
 926          * Unlike SD, MMC cards dont have a configuration register to notify
 927          * supported bus width. So bus test command should be run to identify
 928          * the supported bus width or compare the ext csd values of current
 929          * bus width and ext csd values of 1 bit mode read earlier.
 930          */
 931         for (; idx < ARRAY_SIZE(bus_widths); idx++) {
 932                 /*
 933                  * Host is capable of 8bit transfer, then switch
 934                  * the device to work in 8bit transfer mode. If the
 935                  * mmc switch command returns error then switch to
 936                  * 4bit transfer mode. On success set the corresponding
 937                  * bus width on the host.
 938                  */
 939                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
 940                                  EXT_CSD_BUS_WIDTH,
 941                                  ext_csd_bits[idx],
 942                                  card->ext_csd.generic_cmd6_time);
 943                 if (err)
 944                         continue;
 945
 946                 bus_width = bus_widths[idx];
 947                 mmc_set_bus_width(host, bus_width);
 948
 949                 /*
 950                  * If controller can't handle bus width test,
 951                  * compare ext_csd previously read in 1 bit mode
 952                  * against ext_csd at new bus width
 953                  */
 954                 if (!(host->caps & MMC_CAP_BUS_WIDTH_TEST))
 955                         err = mmc_compare_ext_csds(card, bus_width);
 956                 else
 957                         err = mmc_bus_test(card, bus_width);
 958
 959                 if (!err) {
 960                         err = bus_width;
 961                         break;
 962                 } else {
 963                         pr_warn("%s: switch to bus width %d failed\n",
 964                                 mmc_hostname(host), ext_csd_bits[idx]);
 965                 }
 966         }
 967
 968         return err;
 969 }
 970
 971 /*
 972  * Switch to the high-speed mode
 973  */
 974 static int mmc_select_hs(struct mmc_card *card)
 975 {
 976         int err;
 977
 978         err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
 979                            EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS,
 980                            card->ext_csd.generic_cmd6_time,
 981                            true, true, true);
 982         if (!err)
 983                 mmc_set_timing(card->host, MMC_TIMING_MMC_HS);
 984
 985         return err;
 986 }
 987
 988 /*
 989  * Activate wide bus and DDR if supported.
 990  */
 991 static int mmc_select_hs_ddr(struct mmc_card *card)
 992 {
 993         struct mmc_host *host = card->host;
 994         u32 bus_width, ext_csd_bits;
 995         int err = 0;
 996
 997         if (!(card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_52))
 998                 return 0;
 999
1000         bus_width = host->ios.bus_width;
1001         if (bus_width == MMC_BUS_WIDTH_1)
1002                 return 0;
1003
1004         ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ?
1005                 EXT_CSD_DDR_BUS_WIDTH_8 : EXT_CSD_DDR_BUS_WIDTH_4;
1006
1007         err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1008                         EXT_CSD_BUS_WIDTH,
1009                         ext_csd_bits,
1010                         card->ext_csd.generic_cmd6_time);
1011         if (err) {
1012                 pr_err("%s: switch to bus width %d ddr failed\n",
1013                         mmc_hostname(host), 1 << bus_width);
1014                 return err;
1015         }
1016
1017         /*
1018          * eMMC cards can support 3.3V to 1.2V i/o (vccq)
1019          * signaling.
1020          *
1021          * EXT_CSD_CARD_TYPE_DDR_1_8V means 3.3V or 1.8V vccq.
1022          *
1023          * 1.8V vccq at 3.3V core voltage (vcc) is not required
1024          * in the JEDEC spec for DDR.
1025          *
1026          * Even (e)MMC card can support 3.3v to 1.2v vccq, but not all
1027          * host controller can support this, like some of the SDHCI
1028          * controller which connect to an eMMC device. Some of these
1029          * host controller still needs to use 1.8v vccq for supporting
1030          * DDR mode.
1031          *
1032          * So the sequence will be:
1033          * if (host and device can both support 1.2v IO)
1034          *      use 1.2v IO;
1035          * else if (host and device can both support 1.8v IO)
1036          *      use 1.8v IO;
1037          * so if host and device can only support 3.3v IO, this is the
1038          * last choice.
1039          *
1040          * WARNING: eMMC rules are NOT the same as SD DDR
1041          */
1042         err = -EINVAL;
1043         if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_1_2V)
1044                 err = __mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120);
1045
1046         if (err && (card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_1_8V))
1047                 err = __mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180);
1048
1049         /* make sure vccq is 3.3v after switching disaster */
1050         if (err)
1051                 err = __mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330);
1052
1053         if (!err)
1054                 mmc_set_timing(host, MMC_TIMING_MMC_DDR52);
1055
1056         return err;
1057 }
1058
1059 static int mmc_select_hs400(struct mmc_card *card)
1060 {
1061         struct mmc_host *host = card->host;
1062         int err = 0;
1063
1064         /*
1065          * HS400 mode requires 8-bit bus width
1066          */
1067         if (!(card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400 &&
1068               host->ios.bus_width == MMC_BUS_WIDTH_8))
1069                 return 0;
1070
1071         /*
1072          * Before switching to dual data rate operation for HS400,
1073          * it is required to convert from HS200 mode to HS mode.
1074          */
1075         mmc_set_timing(card->host, MMC_TIMING_MMC_HS);
1076         mmc_set_bus_speed(card);
1077
1078         err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1079                            EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS,
1080                            card->ext_csd.generic_cmd6_time,
1081                            true, true, true);
1082         if (err) {
1083                 pr_err("%s: switch to high-speed from hs200 failed, err:%d\n",
1084                         mmc_hostname(host), err);
1085                 return err;
1086         }
1087
1088         err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1089                          EXT_CSD_BUS_WIDTH,
1090                          EXT_CSD_DDR_BUS_WIDTH_8,
1091                          card->ext_csd.generic_cmd6_time);
1092         if (err) {
1093                 pr_err("%s: switch to bus width for hs400 failed, err:%d\n",
1094                         mmc_hostname(host), err);
1095                 return err;
1096         }
1097
1098         err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1099                            EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS400,
1100                            card->ext_csd.generic_cmd6_time,
1101                            true, true, true);
1102         if (err) {
1103                 pr_err("%s: switch to hs400 failed, err:%d\n",
1104                          mmc_hostname(host), err);
1105                 return err;
1106         }
1107
1108         mmc_set_timing(host, MMC_TIMING_MMC_HS400);
1109         mmc_set_bus_speed(card);
1110
1111         return 0;
1112 }
1113
1114 /*
1115  * For device supporting HS200 mode, the following sequence
1116  * should be done before executing the tuning process.
1117  * 1. set the desired bus width(4-bit or 8-bit, 1-bit is not supported)
1118  * 2. switch to HS200 mode
1119  * 3. set the clock to > 52Mhz and <=200MHz
1120  */
1121 static int mmc_select_hs200(struct mmc_card *card)
1122 {
1123         struct mmc_host *host = card->host;
1124         int err = -EINVAL;
1125
1126         if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS200_1_2V)
1127                 err = __mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120);
1128
1129         if (err && card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS200_1_8V)
1130                 err = __mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180);
1131
1132         /* If fails try again during next card power cycle */
1133         if (err)
1134                 goto err;
1135
1136         /*
1137          * Set the bus width(4 or 8) with host's support and
1138          * switch to HS200 mode if bus width is set successfully.
1139          */
1140         err = mmc_select_bus_width(card);
1141         if (!IS_ERR_VALUE(err)) {
1142                 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1143                                    EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS200,
1144                                    card->ext_csd.generic_cmd6_time,
1145                                    true, true, true);
1146                 if (!err)
1147                         mmc_set_timing(host, MMC_TIMING_MMC_HS200);
1148         }
1149 err:
1150         return err;
1151 }
1152
1153 /*
1154  * Activate High Speed or HS200 mode if supported.
1155  */
1156 static int mmc_select_timing(struct mmc_card *card)
1157 {
1158         int err = 0;
1159
1160         if (card->csd.mmca_vsn < CSD_SPEC_VER_4)
1161                 goto bus_speed;
1162
1163         if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS200)
1164                 err = mmc_select_hs200(card);
1165         else if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS)
1166                 err = mmc_select_hs(card);
1167
1168         if (err && err != -EBADMSG)
1169                 return err;
1170
1171         if (err) {
1172                 pr_warn("%s: switch to %s failed\n",
1173                         mmc_card_hs(card) ? "high-speed" :
1174                         (mmc_card_hs200(card) ? "hs200" : ""),
1175                         mmc_hostname(card->host));
1176                 err = 0;
1177         }
1178
1179 bus_speed:
1180         /*
1181          * Set the bus speed to the selected bus timing.
1182          * If timing is not selected, backward compatible is the default.
1183          */
1184         mmc_set_bus_speed(card);
1185         return err;
1186 }
1187
1188 const u8 tuning_blk_pattern_4bit[MMC_TUNING_BLK_PATTERN_4BIT_SIZE] = {
1189         0xff, 0x0f, 0xff, 0x00, 0xff, 0xcc, 0xc3, 0xcc,
1190         0xc3, 0x3c, 0xcc, 0xff, 0xfe, 0xff, 0xfe, 0xef,
1191         0xff, 0xdf, 0xff, 0xdd, 0xff, 0xfb, 0xff, 0xfb,
1192         0xbf, 0xff, 0x7f, 0xff, 0x77, 0xf7, 0xbd, 0xef,
1193         0xff, 0xf0, 0xff, 0xf0, 0x0f, 0xfc, 0xcc, 0x3c,
1194         0xcc, 0x33, 0xcc, 0xcf, 0xff, 0xef, 0xff, 0xee,
1195         0xff, 0xfd, 0xff, 0xfd, 0xdf, 0xff, 0xbf, 0xff,
1196         0xbb, 0xff, 0xf7, 0xff, 0xf7, 0x7f, 0x7b, 0xde,
1197 };
1198 EXPORT_SYMBOL(tuning_blk_pattern_4bit);
1199
1200 const u8 tuning_blk_pattern_8bit[MMC_TUNING_BLK_PATTERN_8BIT_SIZE] = {
1201         0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00,
1202         0xff, 0xff, 0xcc, 0xcc, 0xcc, 0x33, 0xcc, 0xcc,
1203         0xcc, 0x33, 0x33, 0xcc, 0xcc, 0xcc, 0xff, 0xff,
1204         0xff, 0xee, 0xff, 0xff, 0xff, 0xee, 0xee, 0xff,
1205         0xff, 0xff, 0xdd, 0xff, 0xff, 0xff, 0xdd, 0xdd,
1206         0xff, 0xff, 0xff, 0xbb, 0xff, 0xff, 0xff, 0xbb,
1207         0xbb, 0xff, 0xff, 0xff, 0x77, 0xff, 0xff, 0xff,
1208         0x77, 0x77, 0xff, 0x77, 0xbb, 0xdd, 0xee, 0xff,
1209         0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00,
1210         0x00, 0xff, 0xff, 0xcc, 0xcc, 0xcc, 0x33, 0xcc,
1211         0xcc, 0xcc, 0x33, 0x33, 0xcc, 0xcc, 0xcc, 0xff,
1212         0xff, 0xff, 0xee, 0xff, 0xff, 0xff, 0xee, 0xee,
1213         0xff, 0xff, 0xff, 0xdd, 0xff, 0xff, 0xff, 0xdd,
1214         0xdd, 0xff, 0xff, 0xff, 0xbb, 0xff, 0xff, 0xff,
1215         0xbb, 0xbb, 0xff, 0xff, 0xff, 0x77, 0xff, 0xff,
1216         0xff, 0x77, 0x77, 0xff, 0x77, 0xbb, 0xdd, 0xee,
1217 };
1218 EXPORT_SYMBOL(tuning_blk_pattern_8bit);
1219
1220 /*
1221  * Execute tuning sequence to seek the proper bus operating
1222  * conditions for HS200 and HS400, which sends CMD21 to the device.
1223  */
1224 static int mmc_hs200_tuning(struct mmc_card *card)
1225 {
1226         struct mmc_host *host = card->host;
1227         int err = 0;
1228
1229         /*
1230          * Timing should be adjusted to the HS400 target
1231          * operation frequency for tuning process
1232          */
1233         if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400 &&
1234             host->ios.bus_width == MMC_BUS_WIDTH_8)
1235                 if (host->ops->prepare_hs400_tuning)
1236                         host->ops->prepare_hs400_tuning(host, &host->ios);
1237
1238         if (host->ops->execute_tuning) {
1239                 mmc_host_clk_hold(host);
1240                 err = host->ops->execute_tuning(host,
1241                                 MMC_SEND_TUNING_BLOCK_HS200);
1242                 mmc_host_clk_release(host);
1243
1244                 if (err)
1245                         pr_err("%s: tuning execution failed\n",
1246                                 mmc_hostname(host));
1247         }
1248
1249         return err;
1250 }
1251
1252 /*
1253  * Handle the detection and initialisation of a card.
1254  *
1255  * In the case of a resume, "oldcard" will contain the card
1256  * we're trying to reinitialise.
1257  */
1258 static int mmc_init_card(struct mmc_host *host, u32 ocr,
1259         struct mmc_card *oldcard)
1260 {
1261         struct mmc_card *card;
1262         int err;
1263         u32 cid[4];
1264         u32 rocr;
1265         u8 *ext_csd = NULL;
1266
1267         BUG_ON(!host);
1268         WARN_ON(!host->claimed);
1269
1270         /* Set correct bus mode for MMC before attempting init */
1271         if (!mmc_host_is_spi(host))
1272                 mmc_set_bus_mode(host, MMC_BUSMODE_OPENDRAIN);
1273
1274         /*
1275          * Since we're changing the OCR value, we seem to
1276          * need to tell some cards to go back to the idle
1277          * state.  We wait 1ms to give cards time to
1278          * respond.
1279          * mmc_go_idle is needed for eMMC that are asleep
1280          */
1281         mmc_go_idle(host);
1282
1283         /* The extra bit indicates that we support high capacity */
1284         err = mmc_send_op_cond(host, ocr | (1 << 30), &rocr);
1285         if (err)
1286                 goto err;
1287
1288         /*
1289          * For SPI, enable CRC as appropriate.
1290          */
1291         if (mmc_host_is_spi(host)) {
1292                 err = mmc_spi_set_crc(host, use_spi_crc);
1293                 if (err)
1294                         goto err;
1295         }
1296
1297         /*
1298          * Fetch CID from card.
1299          */
1300         if (mmc_host_is_spi(host))
1301                 err = mmc_send_cid(host, cid);
1302         else
1303                 err = mmc_all_send_cid(host, cid);
1304         if (err)
1305                 goto err;
1306
1307         if (oldcard) {
1308                 if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0) {
1309                         err = -ENOENT;
1310                         goto err;
1311                 }
1312
1313                 card = oldcard;
1314         } else {
1315                 /*
1316                  * Allocate card structure.
1317                  */
1318                 card = mmc_alloc_card(host, &mmc_type);
1319                 if (IS_ERR(card)) {
1320                         err = PTR_ERR(card);
1321                         goto err;
1322                 }
1323
1324                 card->ocr = ocr;
1325                 card->type = MMC_TYPE_MMC;
1326                 card->rca = 1;
1327                 memcpy(card->raw_cid, cid, sizeof(card->raw_cid));
1328         }
1329
1330         /*
1331          * For native busses:  set card RCA and quit open drain mode.
1332          */
1333         if (!mmc_host_is_spi(host)) {
1334                 err = mmc_set_relative_addr(card);
1335                 if (err)
1336                         goto free_card;
1337
1338                 mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL);
1339         }
1340
1341         if (!oldcard) {
1342                 /*
1343                  * Fetch CSD from card.
1344                  */
1345                 err = mmc_send_csd(card, card->raw_csd);
1346                 if (err)
1347                         goto free_card;
1348
1349                 err = mmc_decode_csd(card);
1350                 if (err)
1351                         goto free_card;
1352                 err = mmc_decode_cid(card);
1353                 if (err)
1354                         goto free_card;
1355         }
1356
1357         /*
1358          * handling only for cards supporting DSR and hosts requesting
1359          * DSR configuration
1360          */
1361         if (card->csd.dsr_imp && host->dsr_req)
1362                 mmc_set_dsr(host);
1363
1364         /*
1365          * Select card, as all following commands rely on that.
1366          */
1367         if (!mmc_host_is_spi(host)) {
1368                 err = mmc_select_card(card);
1369                 if (err)
1370                         goto free_card;
1371         }
1372
1373         if (!oldcard) {
1374                 /*
1375                  * Fetch and process extended CSD.
1376                  */
1377
1378                 err = mmc_get_ext_csd(card, &ext_csd);
1379                 if (err)
1380                         goto free_card;
1381                 err = mmc_read_ext_csd(card, ext_csd);
1382                 if (err)
1383                         goto free_card;
1384
1385                 /* If doing byte addressing, check if required to do sector
1386                  * addressing.  Handle the case of <2GB cards needing sector
1387                  * addressing.  See section 8.1 JEDEC Standard JED84-A441;
1388                  * ocr register has bit 30 set for sector addressing.
1389                  */
1390                 if (!(mmc_card_blockaddr(card)) && (rocr & (1<<30)))
1391                         mmc_card_set_blockaddr(card);
1392
1393                 /* Erase size depends on CSD and Extended CSD */
1394                 mmc_set_erase_size(card);
1395         }
1396
1397         /*
1398          * If enhanced_area_en is TRUE, host needs to enable ERASE_GRP_DEF
1399          * bit.  This bit will be lost every time after a reset or power off.
1400          */
1401         if (card->ext_csd.partition_setting_completed ||
1402             (card->ext_csd.rev >= 3 && (host->caps2 & MMC_CAP2_HC_ERASE_SZ))) {
1403                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1404                                  EXT_CSD_ERASE_GROUP_DEF, 1,
1405                                  card->ext_csd.generic_cmd6_time);
1406
1407                 if (err && err != -EBADMSG)
1408                         goto free_card;
1409
1410                 if (err) {
1411                         err = 0;
1412                         /*
1413                          * Just disable enhanced area off & sz
1414                          * will try to enable ERASE_GROUP_DEF
1415                          * during next time reinit
1416                          */
1417                         card->ext_csd.enhanced_area_offset = -EINVAL;
1418                         card->ext_csd.enhanced_area_size = -EINVAL;
1419                 } else {
1420                         card->ext_csd.erase_group_def = 1;
1421                         /*
1422                          * enable ERASE_GRP_DEF successfully.
1423                          * This will affect the erase size, so
1424                          * here need to reset erase size
1425                          */
1426                         mmc_set_erase_size(card);
1427                 }
1428         }
1429
1430         /*
1431          * Ensure eMMC user default partition is enabled
1432          */
1433         if (card->ext_csd.part_config & EXT_CSD_PART_CONFIG_ACC_MASK) {
1434                 card->ext_csd.part_config &= ~EXT_CSD_PART_CONFIG_ACC_MASK;
1435                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONFIG,
1436                                  card->ext_csd.part_config,
1437                                  card->ext_csd.part_time);
1438                 if (err && err != -EBADMSG)
1439                         goto free_card;
1440         }
1441
1442         /*
1443          * Enable power_off_notification byte in the ext_csd register
1444          */
1445         if (card->ext_csd.rev >= 6) {
1446                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1447                                  EXT_CSD_POWER_OFF_NOTIFICATION,
1448                                  EXT_CSD_POWER_ON,
1449                                  card->ext_csd.generic_cmd6_time);
1450                 if (err && err != -EBADMSG)
1451                         goto free_card;
1452
1453                 /*
1454                  * The err can be -EBADMSG or 0,
1455                  * so check for success and update the flag
1456                  */
1457                 if (!err)
1458                         card->ext_csd.power_off_notification = EXT_CSD_POWER_ON;
1459         }
1460
1461         /*
1462          * Select timing interface
1463          */
1464         err = mmc_select_timing(card);
1465         if (err)
1466                 goto free_card;
1467
1468         if (mmc_card_hs200(card)) {
1469                 err = mmc_hs200_tuning(card);
1470                 if (err)
1471                         goto free_card;
1472
1473                 err = mmc_select_hs400(card);
1474                 if (err)
1475                         goto free_card;
1476         } else if (mmc_card_hs(card)) {
1477                 /* Select the desired bus width optionally */
1478                 err = mmc_select_bus_width(card);
1479                 if (!IS_ERR_VALUE(err)) {
1480                         err = mmc_select_hs_ddr(card);
1481                         if (err)
1482                                 goto free_card;
1483                 }
1484         }
1485
1486         /*
1487          * Choose the power class with selected bus interface
1488          */
1489         mmc_select_powerclass(card);
1490
1491         /*
1492          * Enable HPI feature (if supported)
1493          */
1494         if (card->ext_csd.hpi) {
1495                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1496                                 EXT_CSD_HPI_MGMT, 1,
1497                                 card->ext_csd.generic_cmd6_time);
1498                 if (err && err != -EBADMSG)
1499                         goto free_card;
1500                 if (err) {
1501                         pr_warn("%s: Enabling HPI failed\n",
1502                                 mmc_hostname(card->host));
1503                         err = 0;
1504                 } else
1505                         card->ext_csd.hpi_en = 1;
1506         }
1507
1508         /*
1509          * If cache size is higher than 0, this indicates
1510          * the existence of cache and it can be turned on.
1511          */
1512         if (card->ext_csd.cache_size > 0) {
1513                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1514                                 EXT_CSD_CACHE_CTRL, 1,
1515                                 card->ext_csd.generic_cmd6_time);
1516                 if (err && err != -EBADMSG)
1517                         goto free_card;
1518
1519                 /*
1520                  * Only if no error, cache is turned on successfully.
1521                  */
1522                 if (err) {
1523                         pr_warn("%s: Cache is supported, but failed to turn on (%d)\n",
1524                                 mmc_hostname(card->host), err);
1525                         card->ext_csd.cache_ctrl = 0;
1526                         err = 0;
1527                 } else {
1528                         card->ext_csd.cache_ctrl = 1;
1529                 }
1530         }
1531
1532         /*
1533          * The mandatory minimum values are defined for packed command.
1534          * read: 5, write: 3
1535          */
1536         if (card->ext_csd.max_packed_writes >= 3 &&
1537             card->ext_csd.max_packed_reads >= 5 &&
1538             host->caps2 & MMC_CAP2_PACKED_CMD) {
1539                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1540                                 EXT_CSD_EXP_EVENTS_CTRL,
1541                                 EXT_CSD_PACKED_EVENT_EN,
1542                                 card->ext_csd.generic_cmd6_time);
1543                 if (err && err != -EBADMSG)
1544                         goto free_card;
1545                 if (err) {
1546                         pr_warn("%s: Enabling packed event failed\n",
1547                                 mmc_hostname(card->host));
1548                         card->ext_csd.packed_event_en = 0;
1549                         err = 0;
1550                 } else {
1551                         card->ext_csd.packed_event_en = 1;
1552                 }
1553         }
1554
1555         if (!oldcard)
1556                 host->card = card;
1557
1558         kfree(ext_csd);
1559         return 0;
1560
1561 free_card:
1562         if (!oldcard)
1563                 mmc_remove_card(card);
1564 err:
1565         kfree(ext_csd);
1566
1567         return err;
1568 }
1569
1570 static int mmc_can_sleep(struct mmc_card *card)
1571 {
1572         return (card && card->ext_csd.rev >= 3);
1573 }
1574
1575 static int mmc_sleep(struct mmc_host *host)
1576 {
1577         struct mmc_command cmd = {0};
1578         struct mmc_card *card = host->card;
1579         unsigned int timeout_ms = DIV_ROUND_UP(card->ext_csd.sa_timeout, 10000);
1580         int err;
1581
1582         err = mmc_deselect_cards(host);
1583         if (err)
1584                 return err;
1585
1586         cmd.opcode = MMC_SLEEP_AWAKE;
1587         cmd.arg = card->rca << 16;
1588         cmd.arg |= 1 << 15;
1589
1590         /*
1591          * If the max_busy_timeout of the host is specified, validate it against
1592          * the sleep cmd timeout. A failure means we need to prevent the host
1593          * from doing hw busy detection, which is done by converting to a R1
1594          * response instead of a R1B.
1595          */
1596         if (host->max_busy_timeout && (timeout_ms > host->max_busy_timeout)) {
1597                 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
1598         } else {
1599                 cmd.flags = MMC_RSP_R1B | MMC_CMD_AC;
1600                 cmd.busy_timeout = timeout_ms;
1601         }
1602
1603         err = mmc_wait_for_cmd(host, &cmd, 0);
1604         if (err)
1605                 return err;
1606
1607         /*
1608          * If the host does not wait while the card signals busy, then we will
1609          * will have to wait the sleep/awake timeout.  Note, we cannot use the
1610          * SEND_STATUS command to poll the status because that command (and most
1611          * others) is invalid while the card sleeps.
1612          */
1613         if (!cmd.busy_timeout || !(host->caps & MMC_CAP_WAIT_WHILE_BUSY))
1614                 mmc_delay(timeout_ms);
1615
1616         return err;
1617 }
1618
1619 static int mmc_can_poweroff_notify(const struct mmc_card *card)
1620 {
1621         return card &&
1622                 mmc_card_mmc(card) &&
1623                 (card->ext_csd.power_off_notification == EXT_CSD_POWER_ON);
1624 }
1625
1626 static int mmc_poweroff_notify(struct mmc_card *card, unsigned int notify_type)
1627 {
1628         unsigned int timeout = card->ext_csd.generic_cmd6_time;
1629         int err;
1630
1631         /* Use EXT_CSD_POWER_OFF_SHORT as default notification type. */
1632         if (notify_type == EXT_CSD_POWER_OFF_LONG)
1633                 timeout = card->ext_csd.power_off_longtime;
1634
1635         err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1636                         EXT_CSD_POWER_OFF_NOTIFICATION,
1637                         notify_type, timeout, true, false, false);
1638         if (err)
1639                 pr_err("%s: Power Off Notification timed out, %u\n",
1640                        mmc_hostname(card->host), timeout);
1641
1642         /* Disable the power off notification after the switch operation. */
1643         card->ext_csd.power_off_notification = EXT_CSD_NO_POWER_NOTIFICATION;
1644
1645         return err;
1646 }
1647
1648 /*
1649  * Host is being removed. Free up the current card.
1650  */
1651 static void mmc_remove(struct mmc_host *host)
1652 {
1653         BUG_ON(!host);
1654         BUG_ON(!host->card);
1655
1656         mmc_remove_card(host->card);
1657         host->card = NULL;
1658 }
1659
1660 /*
1661  * Card detection - card is alive.
1662  */
1663 static int mmc_alive(struct mmc_host *host)
1664 {
1665         return mmc_send_status(host->card, NULL);
1666 }
1667
1668 /*
1669  * Card detection callback from host.
1670  */
1671 static void mmc_detect(struct mmc_host *host)
1672 {
1673         int err;
1674
1675         BUG_ON(!host);
1676         BUG_ON(!host->card);
1677
1678         mmc_get_card(host->card);
1679
1680         /*
1681          * Just check if our card has been removed.
1682          */
1683         err = _mmc_detect_card_removed(host);
1684
1685         mmc_put_card(host->card);
1686
1687         if (err) {
1688                 mmc_remove(host);
1689
1690                 mmc_claim_host(host);
1691                 mmc_detach_bus(host);
1692                 mmc_power_off(host);
1693                 mmc_release_host(host);
1694         }
1695 }
1696
1697 static int _mmc_suspend(struct mmc_host *host, bool is_suspend)
1698 {
1699         int err = 0;
1700         unsigned int notify_type = is_suspend ? EXT_CSD_POWER_OFF_SHORT :
1701                                         EXT_CSD_POWER_OFF_LONG;
1702
1703         BUG_ON(!host);
1704         BUG_ON(!host->card);
1705
1706         mmc_claim_host(host);
1707
1708         if (mmc_card_suspended(host->card))
1709                 goto out;
1710
1711         if (mmc_card_doing_bkops(host->card)) {
1712                 err = mmc_stop_bkops(host->card);
1713                 if (err)
1714                         goto out;
1715         }
1716
1717         err = mmc_flush_cache(host->card);
1718         if (err)
1719                 goto out;
1720
1721         if (mmc_can_poweroff_notify(host->card) &&
1722                 ((host->caps2 & MMC_CAP2_FULL_PWR_CYCLE) || !is_suspend))
1723                 err = mmc_poweroff_notify(host->card, notify_type);
1724         else if (mmc_can_sleep(host->card))
1725                 err = mmc_sleep(host);
1726         else if (!mmc_host_is_spi(host))
1727                 err = mmc_deselect_cards(host);
1728
1729         if (!err) {
1730                 mmc_power_off(host);
1731                 mmc_card_set_suspended(host->card);
1732         }
1733 out:
1734         mmc_release_host(host);
1735         return err;
1736 }
1737
1738 /*
1739  * Suspend callback
1740  */
1741 static int mmc_suspend(struct mmc_host *host)
1742 {
1743         int err;
1744
1745         err = _mmc_suspend(host, true);
1746         if (!err) {
1747                 pm_runtime_disable(&host->card->dev);
1748                 pm_runtime_set_suspended(&host->card->dev);
1749         }
1750
1751         return err;
1752 }
1753
1754 /*
1755  * This function tries to determine if the same card is still present
1756  * and, if so, restore all state to it.
1757  */
1758 static int _mmc_resume(struct mmc_host *host)
1759 {
1760         int err = 0;
1761
1762         BUG_ON(!host);
1763         BUG_ON(!host->card);
1764
1765         mmc_claim_host(host);
1766
1767         if (!mmc_card_suspended(host->card))
1768                 goto out;
1769
1770         mmc_power_up(host, host->card->ocr);
1771         err = mmc_init_card(host, host->card->ocr, host->card);
1772         mmc_card_clr_suspended(host->card);
1773
1774 out:
1775         mmc_release_host(host);
1776         return err;
1777 }
1778
1779 /*
1780  * Shutdown callback
1781  */
1782 static int mmc_shutdown(struct mmc_host *host)
1783 {
1784         int err = 0;
1785
1786         /*
1787          * In a specific case for poweroff notify, we need to resume the card
1788          * before we can shutdown it properly.
1789          */
1790         if (mmc_can_poweroff_notify(host->card) &&
1791                 !(host->caps2 & MMC_CAP2_FULL_PWR_CYCLE))
1792                 err = _mmc_resume(host);
1793
1794         if (!err)
1795                 err = _mmc_suspend(host, false);
1796
1797         return err;
1798 }
1799
1800 /*
1801  * Callback for resume.
1802  */
1803 static int mmc_resume(struct mmc_host *host)
1804 {
1805         int err = 0;
1806
1807         if (!(host->caps & MMC_CAP_RUNTIME_RESUME)) {
1808                 err = _mmc_resume(host);
1809                 pm_runtime_set_active(&host->card->dev);
1810                 pm_runtime_mark_last_busy(&host->card->dev);
1811         }
1812         pm_runtime_enable(&host->card->dev);
1813
1814         return err;
1815 }
1816
1817 /*
1818  * Callback for runtime_suspend.
1819  */
1820 static int mmc_runtime_suspend(struct mmc_host *host)
1821 {
1822         int err;
1823
1824         if (!(host->caps & MMC_CAP_AGGRESSIVE_PM))
1825                 return 0;
1826
1827         err = _mmc_suspend(host, true);
1828         if (err)
1829                 pr_err("%s: error %d doing aggessive suspend\n",
1830                         mmc_hostname(host), err);
1831
1832         return err;
1833 }
1834
1835 /*
1836  * Callback for runtime_resume.
1837  */
1838 static int mmc_runtime_resume(struct mmc_host *host)
1839 {
1840         int err;
1841
1842         if (!(host->caps & (MMC_CAP_AGGRESSIVE_PM | MMC_CAP_RUNTIME_RESUME)))
1843                 return 0;
1844
1845         err = _mmc_resume(host);
1846         if (err)
1847                 pr_err("%s: error %d doing aggessive resume\n",
1848                         mmc_hostname(host), err);
1849
1850         return 0;
1851 }
1852
1853 static int mmc_power_restore(struct mmc_host *host)
1854 {
1855         int ret;
1856
1857         mmc_claim_host(host);
1858         ret = mmc_init_card(host, host->card->ocr, host->card);
1859         mmc_release_host(host);
1860
1861         return ret;
1862 }
1863
1864 static const struct mmc_bus_ops mmc_ops = {
1865         .remove = mmc_remove,
1866         .detect = mmc_detect,
1867         .suspend = mmc_suspend,
1868         .resume = mmc_resume,
1869         .runtime_suspend = mmc_runtime_suspend,
1870         .runtime_resume = mmc_runtime_resume,
1871         .power_restore = mmc_power_restore,
1872         .alive = mmc_alive,
1873         .shutdown = mmc_shutdown,
1874 };
1875
1876 /*
1877  * Starting point for MMC card init.
1878  */
1879 int mmc_attach_mmc(struct mmc_host *host)
1880 {
1881         int err;
1882         u32 ocr, rocr;
1883
1884         BUG_ON(!host);
1885         WARN_ON(!host->claimed);
1886
1887         /* Set correct bus mode for MMC before attempting attach */
1888         if (!mmc_host_is_spi(host))
1889                 mmc_set_bus_mode(host, MMC_BUSMODE_OPENDRAIN);
1890
1891         err = mmc_send_op_cond(host, 0, &ocr);
1892         if (err)
1893                 return err;
1894
1895         mmc_attach_bus(host, &mmc_ops);
1896         if (host->ocr_avail_mmc)
1897                 host->ocr_avail = host->ocr_avail_mmc;
1898
1899         /*
1900          * We need to get OCR a different way for SPI.
1901          */
1902         if (mmc_host_is_spi(host)) {
1903                 err = mmc_spi_read_ocr(host, 1, &ocr);
1904                 if (err)
1905                         goto err;
1906         }
1907
1908         rocr = mmc_select_voltage(host, ocr);
1909
1910         /*
1911          * Can we support the voltage of the card?
1912          */
1913         if (!rocr) {
1914                 err = -EINVAL;
1915                 goto err;
1916         }
1917
1918         /*
1919          * Detect and init the card.
1920          */
1921         err = mmc_init_card(host, rocr, NULL);
1922         if (err)
1923                 goto err;
1924
1925         mmc_release_host(host);
1926         err = mmc_add_card(host->card);
1927         mmc_claim_host(host);
1928         if (err)
1929                 goto remove_card;
1930
1931         return 0;
1932
1933 remove_card:
1934         mmc_release_host(host);
1935         mmc_remove_card(host->card);
1936         mmc_claim_host(host);
1937         host->card = NULL;
1938 err:
1939         mmc_detach_bus(host);
1940
1941         pr_err("%s: error %d whilst initialising MMC card\n",
1942                 mmc_hostname(host), err);
1943
1944         return err;
1945 }