Linux Audio

Check our new training course

Open-source upstreaming

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