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