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