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