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