mmc.c 38.3 KB
Newer Older
P
Pierre Ossman 已提交
1
/*
P
Pierre Ossman 已提交
2
 *  linux/drivers/mmc/core/mmc.c
P
Pierre Ossman 已提交
3 4 5 6 7 8 9 10 11 12 13
 *
 *  Copyright (C) 2003-2004 Russell King, All Rights Reserved.
 *  Copyright (C) 2005-2007 Pierre Ossman, All Rights Reserved.
 *  MMCv4 support Copyright (C) 2006 Philip Langdale, All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/err.h>
14
#include <linux/slab.h>
15
#include <linux/stat.h>
P
Pierre Ossman 已提交
16 17 18 19 20 21

#include <linux/mmc/host.h>
#include <linux/mmc/card.h>
#include <linux/mmc/mmc.h>

#include "core.h"
P
Pierre Ossman 已提交
22
#include "bus.h"
P
Pierre Ossman 已提交
23
#include "mmc_ops.h"
24
#include "sd_ops.h"
P
Pierre Ossman 已提交
25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61

static const unsigned int tran_exp[] = {
	10000,		100000,		1000000,	10000000,
	0,		0,		0,		0
};

static const unsigned char tran_mant[] = {
	0,	10,	12,	13,	15,	20,	25,	30,
	35,	40,	45,	50,	55,	60,	70,	80,
};

static const unsigned int tacc_exp[] = {
	1,	10,	100,	1000,	10000,	100000,	1000000, 10000000,
};

static const unsigned int tacc_mant[] = {
	0,	10,	12,	13,	15,	20,	25,	30,
	35,	40,	45,	50,	55,	60,	70,	80,
};

#define UNSTUFF_BITS(resp,start,size)					\
	({								\
		const int __size = size;				\
		const u32 __mask = (__size < 32 ? 1 << __size : 0) - 1;	\
		const int __off = 3 - ((start) / 32);			\
		const int __shft = (start) & 31;			\
		u32 __res;						\
									\
		__res = resp[__off] >> __shft;				\
		if (__size + __shft > 32)				\
			__res |= resp[__off-1] << ((32 - __shft) % 32);	\
		__res & __mask;						\
	})

/*
 * Given the decoded CSD structure, decode the raw CID to our CID structure.
 */
P
Pierre Ossman 已提交
62
static int mmc_decode_cid(struct mmc_card *card)
P
Pierre Ossman 已提交
63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104
{
	u32 *resp = card->raw_cid;

	/*
	 * The selection of the format here is based upon published
	 * specs from sandisk and from what people have reported.
	 */
	switch (card->csd.mmca_vsn) {
	case 0: /* MMC v1.0 - v1.2 */
	case 1: /* MMC v1.4 */
		card->cid.manfid	= UNSTUFF_BITS(resp, 104, 24);
		card->cid.prod_name[0]	= UNSTUFF_BITS(resp, 96, 8);
		card->cid.prod_name[1]	= UNSTUFF_BITS(resp, 88, 8);
		card->cid.prod_name[2]	= UNSTUFF_BITS(resp, 80, 8);
		card->cid.prod_name[3]	= UNSTUFF_BITS(resp, 72, 8);
		card->cid.prod_name[4]	= UNSTUFF_BITS(resp, 64, 8);
		card->cid.prod_name[5]	= UNSTUFF_BITS(resp, 56, 8);
		card->cid.prod_name[6]	= UNSTUFF_BITS(resp, 48, 8);
		card->cid.hwrev		= UNSTUFF_BITS(resp, 44, 4);
		card->cid.fwrev		= UNSTUFF_BITS(resp, 40, 4);
		card->cid.serial	= UNSTUFF_BITS(resp, 16, 24);
		card->cid.month		= UNSTUFF_BITS(resp, 12, 4);
		card->cid.year		= UNSTUFF_BITS(resp, 8, 4) + 1997;
		break;

	case 2: /* MMC v2.0 - v2.2 */
	case 3: /* MMC v3.1 - v3.3 */
	case 4: /* MMC v4 */
		card->cid.manfid	= UNSTUFF_BITS(resp, 120, 8);
		card->cid.oemid		= UNSTUFF_BITS(resp, 104, 16);
		card->cid.prod_name[0]	= UNSTUFF_BITS(resp, 96, 8);
		card->cid.prod_name[1]	= UNSTUFF_BITS(resp, 88, 8);
		card->cid.prod_name[2]	= UNSTUFF_BITS(resp, 80, 8);
		card->cid.prod_name[3]	= UNSTUFF_BITS(resp, 72, 8);
		card->cid.prod_name[4]	= UNSTUFF_BITS(resp, 64, 8);
		card->cid.prod_name[5]	= UNSTUFF_BITS(resp, 56, 8);
		card->cid.serial	= UNSTUFF_BITS(resp, 16, 32);
		card->cid.month		= UNSTUFF_BITS(resp, 12, 4);
		card->cid.year		= UNSTUFF_BITS(resp, 8, 4) + 1997;
		break;

	default:
105
		pr_err("%s: card has unknown MMCA version %d\n",
P
Pierre Ossman 已提交
106
			mmc_hostname(card->host), card->csd.mmca_vsn);
P
Pierre Ossman 已提交
107
		return -EINVAL;
P
Pierre Ossman 已提交
108
	}
P
Pierre Ossman 已提交
109 110

	return 0;
P
Pierre Ossman 已提交
111 112
}

113 114 115 116 117 118 119 120 121 122
static void mmc_set_erase_size(struct mmc_card *card)
{
	if (card->ext_csd.erase_group_def & 1)
		card->erase_size = card->ext_csd.hc_erase_size;
	else
		card->erase_size = card->csd.erase_size;

	mmc_init_erase(card);
}

P
Pierre Ossman 已提交
123 124 125
/*
 * Given a 128-bit response, decode to our card CSD structure.
 */
P
Pierre Ossman 已提交
126
static int mmc_decode_csd(struct mmc_card *card)
P
Pierre Ossman 已提交
127 128
{
	struct mmc_csd *csd = &card->csd;
129
	unsigned int e, m, a, b;
P
Pierre Ossman 已提交
130 131 132 133 134
	u32 *resp = card->raw_csd;

	/*
	 * We only understand CSD structure v1.1 and v1.2.
	 * v1.2 has extra information in bits 15, 11 and 10.
K
Kyungmin Park 已提交
135
	 * We also support eMMC v4.4 & v4.41.
P
Pierre Ossman 已提交
136
	 */
K
Kyungmin Park 已提交
137 138
	csd->structure = UNSTUFF_BITS(resp, 126, 2);
	if (csd->structure == 0) {
139
		pr_err("%s: unrecognised CSD structure version %d\n",
K
Kyungmin Park 已提交
140
			mmc_hostname(card->host), csd->structure);
P
Pierre Ossman 已提交
141
		return -EINVAL;
P
Pierre Ossman 已提交
142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165
	}

	csd->mmca_vsn	 = UNSTUFF_BITS(resp, 122, 4);
	m = UNSTUFF_BITS(resp, 115, 4);
	e = UNSTUFF_BITS(resp, 112, 3);
	csd->tacc_ns	 = (tacc_exp[e] * tacc_mant[m] + 9) / 10;
	csd->tacc_clks	 = UNSTUFF_BITS(resp, 104, 8) * 100;

	m = UNSTUFF_BITS(resp, 99, 4);
	e = UNSTUFF_BITS(resp, 96, 3);
	csd->max_dtr	  = tran_exp[e] * tran_mant[m];
	csd->cmdclass	  = UNSTUFF_BITS(resp, 84, 12);

	e = UNSTUFF_BITS(resp, 47, 3);
	m = UNSTUFF_BITS(resp, 62, 12);
	csd->capacity	  = (1 + m) << (e + 2);

	csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4);
	csd->read_partial = UNSTUFF_BITS(resp, 79, 1);
	csd->write_misalign = UNSTUFF_BITS(resp, 78, 1);
	csd->read_misalign = UNSTUFF_BITS(resp, 77, 1);
	csd->r2w_factor = UNSTUFF_BITS(resp, 26, 3);
	csd->write_blkbits = UNSTUFF_BITS(resp, 22, 4);
	csd->write_partial = UNSTUFF_BITS(resp, 21, 1);
P
Pierre Ossman 已提交
166

167 168 169 170 171 172 173
	if (csd->write_blkbits >= 9) {
		a = UNSTUFF_BITS(resp, 42, 5);
		b = UNSTUFF_BITS(resp, 37, 5);
		csd->erase_size = (a + 1) * (b + 1);
		csd->erase_size <<= csd->write_blkbits - 9;
	}

P
Pierre Ossman 已提交
174
	return 0;
P
Pierre Ossman 已提交
175 176 177
}

/*
178
 * Read extended CSD.
P
Pierre Ossman 已提交
179
 */
180
static int mmc_get_ext_csd(struct mmc_card *card, u8 **new_ext_csd)
P
Pierre Ossman 已提交
181 182 183 184 185
{
	int err;
	u8 *ext_csd;

	BUG_ON(!card);
186 187 188
	BUG_ON(!new_ext_csd);

	*new_ext_csd = NULL;
P
Pierre Ossman 已提交
189 190

	if (card->csd.mmca_vsn < CSD_SPEC_VER_4)
P
Pierre Ossman 已提交
191
		return 0;
P
Pierre Ossman 已提交
192 193 194 195 196 197 198

	/*
	 * As the ext_csd is so large and mostly unused, we don't store the
	 * raw block in mmc_card.
	 */
	ext_csd = kmalloc(512, GFP_KERNEL);
	if (!ext_csd) {
199
		pr_err("%s: could not allocate a buffer to "
P
Pierre Ossman 已提交
200
			"receive the ext_csd.\n", mmc_hostname(card->host));
P
Pierre Ossman 已提交
201
		return -ENOMEM;
P
Pierre Ossman 已提交
202 203 204
	}

	err = mmc_send_ext_csd(card, ext_csd);
P
Pierre Ossman 已提交
205
	if (err) {
206 207 208
		kfree(ext_csd);
		*new_ext_csd = NULL;

209 210 211 212 213
		/* If the host or the card can't do the switch,
		 * fail more gracefully. */
		if ((err != -EINVAL)
		 && (err != -ENOSYS)
		 && (err != -EFAULT))
214
			return err;
P
Pierre Ossman 已提交
215

P
Pierre Ossman 已提交
216 217 218 219 220
		/*
		 * High capacity cards should have this "magic" size
		 * stored in their CSD.
		 */
		if (card->csd.capacity == (4096 * 512)) {
221
			pr_err("%s: unable to read EXT_CSD "
P
Pierre Ossman 已提交
222 223 224 225
				"on a possible high capacity card. "
				"Card will be ignored.\n",
				mmc_hostname(card->host));
		} else {
226
			pr_warning("%s: unable to read "
P
Pierre Ossman 已提交
227 228 229
				"EXT_CSD, performance might "
				"suffer.\n",
				mmc_hostname(card->host));
P
Pierre Ossman 已提交
230
			err = 0;
P
Pierre Ossman 已提交
231
		}
232 233
	} else
		*new_ext_csd = ext_csd;
P
Pierre Ossman 已提交
234

235 236 237
	return err;
}

238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267
static void mmc_select_card_type(struct mmc_card *card)
{
	struct mmc_host *host = card->host;
	u8 card_type = card->ext_csd.raw_card_type & EXT_CSD_CARD_TYPE_MASK;
	unsigned int caps = host->caps, caps2 = host->caps2;
	unsigned int hs_max_dtr = 0;

	if (card_type & EXT_CSD_CARD_TYPE_26)
		hs_max_dtr = MMC_HIGH_26_MAX_DTR;

	if (caps & MMC_CAP_MMC_HIGHSPEED &&
			card_type & EXT_CSD_CARD_TYPE_52)
		hs_max_dtr = MMC_HIGH_52_MAX_DTR;

	if ((caps & MMC_CAP_1_8V_DDR &&
			card_type & EXT_CSD_CARD_TYPE_DDR_1_8V) ||
	    (caps & MMC_CAP_1_2V_DDR &&
			card_type & EXT_CSD_CARD_TYPE_DDR_1_2V))
		hs_max_dtr = MMC_HIGH_DDR_MAX_DTR;

	if ((caps2 & MMC_CAP2_HS200_1_8V_SDR &&
			card_type & EXT_CSD_CARD_TYPE_SDR_1_8V) ||
	    (caps2 & MMC_CAP2_HS200_1_2V_SDR &&
			card_type & EXT_CSD_CARD_TYPE_SDR_1_2V))
		hs_max_dtr = MMC_HS200_MAX_DTR;

	card->ext_csd.hs_max_dtr = hs_max_dtr;
	card->ext_csd.card_type = card_type;
}

268 269 270 271 272
/*
 * Decode extended CSD.
 */
static int mmc_read_ext_csd(struct mmc_card *card, u8 *ext_csd)
{
273 274 275
	int err = 0, idx;
	unsigned int part_size;
	u8 hc_erase_grp_sz = 0, hc_wp_grp_sz = 0;
276 277 278 279 280

	BUG_ON(!card);

	if (!ext_csd)
		return 0;
P
Pierre Ossman 已提交
281

K
Kyungmin Park 已提交
282
	/* Version is coded in the CSD_STRUCTURE byte in the EXT_CSD register */
283
	card->ext_csd.raw_ext_csd_structure = ext_csd[EXT_CSD_STRUCTURE];
K
Kyungmin Park 已提交
284
	if (card->csd.structure == 3) {
285
		if (card->ext_csd.raw_ext_csd_structure > 2) {
286
			pr_err("%s: unrecognised EXT_CSD structure "
K
Kyungmin Park 已提交
287
				"version %d\n", mmc_hostname(card->host),
288
					card->ext_csd.raw_ext_csd_structure);
K
Kyungmin Park 已提交
289 290 291 292 293
			err = -EINVAL;
			goto out;
		}
	}

294
	card->ext_csd.rev = ext_csd[EXT_CSD_REV];
295
	if (card->ext_csd.rev > 6) {
296
		pr_err("%s: unrecognised EXT_CSD revision %d\n",
K
Kyungmin Park 已提交
297
			mmc_hostname(card->host), card->ext_csd.rev);
298 299
		err = -EINVAL;
		goto out;
P
Pierre Ossman 已提交
300 301
	}

302 303 304 305
	card->ext_csd.raw_sectors[0] = ext_csd[EXT_CSD_SEC_CNT + 0];
	card->ext_csd.raw_sectors[1] = ext_csd[EXT_CSD_SEC_CNT + 1];
	card->ext_csd.raw_sectors[2] = ext_csd[EXT_CSD_SEC_CNT + 2];
	card->ext_csd.raw_sectors[3] = ext_csd[EXT_CSD_SEC_CNT + 3];
306
	if (card->ext_csd.rev >= 2) {
P
Pierre Ossman 已提交
307 308 309 310 311
		card->ext_csd.sectors =
			ext_csd[EXT_CSD_SEC_CNT + 0] << 0 |
			ext_csd[EXT_CSD_SEC_CNT + 1] << 8 |
			ext_csd[EXT_CSD_SEC_CNT + 2] << 16 |
			ext_csd[EXT_CSD_SEC_CNT + 3] << 24;
312 313 314

		/* Cards with density > 2GiB are sector addressed */
		if (card->ext_csd.sectors > (2u * 1024 * 1024 * 1024) / 512)
P
Pierre Ossman 已提交
315 316
			mmc_card_set_blockaddr(card);
	}
317

318
	card->ext_csd.raw_card_type = ext_csd[EXT_CSD_CARD_TYPE];
319
	mmc_select_card_type(card);
P
Pierre Ossman 已提交
320

321 322 323 324 325
	card->ext_csd.raw_s_a_timeout = ext_csd[EXT_CSD_S_A_TIMEOUT];
	card->ext_csd.raw_erase_timeout_mult =
		ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT];
	card->ext_csd.raw_hc_erase_grp_size =
		ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
326 327
	if (card->ext_csd.rev >= 3) {
		u8 sa_shift = ext_csd[EXT_CSD_S_A_TIMEOUT];
328 329 330 331
		card->ext_csd.part_config = ext_csd[EXT_CSD_PART_CONFIG];

		/* EXT_CSD value is in units of 10ms, but we store in ms */
		card->ext_csd.part_time = 10 * ext_csd[EXT_CSD_PART_SWITCH_TIME];
332 333 334 335 336

		/* Sleep / awake timeout in 100ns units */
		if (sa_shift > 0 && sa_shift <= 0x17)
			card->ext_csd.sa_timeout =
					1 << ext_csd[EXT_CSD_S_A_TIMEOUT];
337 338 339 340 341 342
		card->ext_csd.erase_group_def =
			ext_csd[EXT_CSD_ERASE_GROUP_DEF];
		card->ext_csd.hc_erase_timeout = 300 *
			ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT];
		card->ext_csd.hc_erase_size =
			ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] << 10;
A
Andrei Warkentin 已提交
343 344

		card->ext_csd.rel_sectors = ext_csd[EXT_CSD_REL_WR_SEC_C];
345 346 347 348 349

		/*
		 * There are two boot regions of equal size, defined in
		 * multiples of 128K.
		 */
350 351 352 353 354
		if (ext_csd[EXT_CSD_BOOT_MULT] && mmc_boot_partition_access(card->host)) {
			for (idx = 0; idx < MMC_NUM_BOOT_PARTITION; idx++) {
				part_size = ext_csd[EXT_CSD_BOOT_MULT] << 17;
				mmc_part_add(card, part_size,
					EXT_CSD_PART_CONFIG_ACC_BOOT0 + idx,
355 356
					"boot%d", idx, true,
					MMC_BLK_DATA_AREA_BOOT);
357 358
			}
		}
359 360
	}

361
	card->ext_csd.raw_hc_erase_gap_size =
362
		ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
363 364 365 366 367 368 369 370
	card->ext_csd.raw_sec_trim_mult =
		ext_csd[EXT_CSD_SEC_TRIM_MULT];
	card->ext_csd.raw_sec_erase_mult =
		ext_csd[EXT_CSD_SEC_ERASE_MULT];
	card->ext_csd.raw_sec_feature_support =
		ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT];
	card->ext_csd.raw_trim_mult =
		ext_csd[EXT_CSD_TRIM_MULT];
371
	if (card->ext_csd.rev >= 4) {
372 373 374 375 376
		/*
		 * Enhanced area feature support -- check whether the eMMC
		 * card has the Enhanced area enabled.  If so, export enhanced
		 * area offset and size to user by adding sysfs interface.
		 */
377
		card->ext_csd.raw_partition_support = ext_csd[EXT_CSD_PARTITION_SUPPORT];
378
		if ((ext_csd[EXT_CSD_PARTITION_SUPPORT] & 0x2) &&
379
		    (ext_csd[EXT_CSD_PARTITION_ATTRIBUTE] & 0x1)) {
380
			hc_erase_grp_sz =
381
				ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
382
			hc_wp_grp_sz =
383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410
				ext_csd[EXT_CSD_HC_WP_GRP_SIZE];

			card->ext_csd.enhanced_area_en = 1;
			/*
			 * calculate the enhanced data area offset, in bytes
			 */
			card->ext_csd.enhanced_area_offset =
				(ext_csd[139] << 24) + (ext_csd[138] << 16) +
				(ext_csd[137] << 8) + ext_csd[136];
			if (mmc_card_blockaddr(card))
				card->ext_csd.enhanced_area_offset <<= 9;
			/*
			 * calculate the enhanced data area size, in kilobytes
			 */
			card->ext_csd.enhanced_area_size =
				(ext_csd[142] << 16) + (ext_csd[141] << 8) +
				ext_csd[140];
			card->ext_csd.enhanced_area_size *=
				(size_t)(hc_erase_grp_sz * hc_wp_grp_sz);
			card->ext_csd.enhanced_area_size <<= 9;
		} else {
			/*
			 * If the enhanced area is not enabled, disable these
			 * device attributes.
			 */
			card->ext_csd.enhanced_area_offset = -EINVAL;
			card->ext_csd.enhanced_area_size = -EINVAL;
		}
411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442

		/*
		 * General purpose partition feature support --
		 * If ext_csd has the size of general purpose partitions,
		 * set size, part_cfg, partition name in mmc_part.
		 */
		if (ext_csd[EXT_CSD_PARTITION_SUPPORT] &
			EXT_CSD_PART_SUPPORT_PART_EN) {
			if (card->ext_csd.enhanced_area_en != 1) {
				hc_erase_grp_sz =
					ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
				hc_wp_grp_sz =
					ext_csd[EXT_CSD_HC_WP_GRP_SIZE];

				card->ext_csd.enhanced_area_en = 1;
			}

			for (idx = 0; idx < MMC_NUM_GP_PARTITION; idx++) {
				if (!ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3] &&
				!ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 1] &&
				!ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 2])
					continue;
				part_size =
				(ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 2]
					<< 16) +
				(ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 1]
					<< 8) +
				ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3];
				part_size *= (size_t)(hc_erase_grp_sz *
					hc_wp_grp_sz);
				mmc_part_add(card, part_size << 19,
					EXT_CSD_PART_CONFIG_ACC_GP0 + idx,
443 444
					"gp%d", idx, false,
					MMC_BLK_DATA_AREA_GP);
445 446
			}
		}
447 448 449 450 451 452 453 454
		card->ext_csd.sec_trim_mult =
			ext_csd[EXT_CSD_SEC_TRIM_MULT];
		card->ext_csd.sec_erase_mult =
			ext_csd[EXT_CSD_SEC_ERASE_MULT];
		card->ext_csd.sec_feature_support =
			ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT];
		card->ext_csd.trim_timeout = 300 *
			ext_csd[EXT_CSD_TRIM_MULT];
455 456 457 458 459 460 461 462

		/*
		 * Note that the call to mmc_part_add above defaults to read
		 * only. If this default assumption is changed, the call must
		 * take into account the value of boot_locked below.
		 */
		card->ext_csd.boot_ro_lock = ext_csd[EXT_CSD_BOOT_WP];
		card->ext_csd.boot_ro_lockable = true;
463 464
	}

465
	if (card->ext_csd.rev >= 5) {
466 467 468 469 470 471 472 473 474 475 476 477 478 479 480
		/* check whether the eMMC card supports HPI */
		if (ext_csd[EXT_CSD_HPI_FEATURES] & 0x1) {
			card->ext_csd.hpi = 1;
			if (ext_csd[EXT_CSD_HPI_FEATURES] & 0x2)
				card->ext_csd.hpi_cmd =	MMC_STOP_TRANSMISSION;
			else
				card->ext_csd.hpi_cmd = MMC_SEND_STATUS;
			/*
			 * Indicate the maximum timeout to close
			 * a command interrupted by HPI
			 */
			card->ext_csd.out_of_int_time =
				ext_csd[EXT_CSD_OUT_OF_INTERRUPT_TIME] * 10;
		}

A
Andrei Warkentin 已提交
481
		card->ext_csd.rel_param = ext_csd[EXT_CSD_WR_REL_PARAM];
482 483
		card->ext_csd.rst_n_function = ext_csd[EXT_CSD_RST_N_FUNCTION];
	}
A
Andrei Warkentin 已提交
484

485
	card->ext_csd.raw_erased_mem_count = ext_csd[EXT_CSD_ERASED_MEM_CONT];
486 487 488 489 490
	if (ext_csd[EXT_CSD_ERASED_MEM_CONT])
		card->erased_byte = 0xFF;
	else
		card->erased_byte = 0x0;

491
	/* eMMC v4.5 or later */
492
	if (card->ext_csd.rev >= 6) {
493 494
		card->ext_csd.feature_support |= MMC_DISCARD_FEATURE;

495 496
		card->ext_csd.generic_cmd6_time = 10 *
			ext_csd[EXT_CSD_GENERIC_CMD6_TIME];
497 498
		card->ext_csd.power_off_longtime = 10 *
			ext_csd[EXT_CSD_POWER_OFF_LONG_TIME];
499

500 501 502 503 504
		card->ext_csd.cache_size =
			ext_csd[EXT_CSD_CACHE_SIZE + 0] << 0 |
			ext_csd[EXT_CSD_CACHE_SIZE + 1] << 8 |
			ext_csd[EXT_CSD_CACHE_SIZE + 2] << 16 |
			ext_csd[EXT_CSD_CACHE_SIZE + 3] << 24;
S
Saugata Das 已提交
505 506 507 508 509 510 511 512 513 514 515 516 517 518

		if (ext_csd[EXT_CSD_DATA_SECTOR_SIZE] == 1)
			card->ext_csd.data_sector_size = 4096;
		else
			card->ext_csd.data_sector_size = 512;

		if ((ext_csd[EXT_CSD_DATA_TAG_SUPPORT] & 1) &&
		    (ext_csd[EXT_CSD_TAG_UNIT_SIZE] <= 8)) {
			card->ext_csd.data_tag_unit_size =
			((unsigned int) 1 << ext_csd[EXT_CSD_TAG_UNIT_SIZE]) *
			(card->ext_csd.data_sector_size);
		} else {
			card->ext_csd.data_tag_unit_size = 0;
		}
519
	}
520

P
Pierre Ossman 已提交
521
out:
522 523 524 525 526
	return err;
}

static inline void mmc_free_ext_csd(u8 *ext_csd)
{
P
Pierre Ossman 已提交
527
	kfree(ext_csd);
528 529
}

P
Pierre Ossman 已提交
530

531
static int mmc_compare_ext_csds(struct mmc_card *card, unsigned bus_width)
532 533 534 535
{
	u8 *bw_ext_csd;
	int err;

536 537 538
	if (bus_width == MMC_BUS_WIDTH_1)
		return 0;

539 540
	err = mmc_get_ext_csd(card, &bw_ext_csd);

541
	if (err || bw_ext_csd == NULL) {
542 543 544 545 546 547 548 549 550
		if (bus_width != MMC_BUS_WIDTH_1)
			err = -EINVAL;
		goto out;
	}

	if (bus_width == MMC_BUS_WIDTH_1)
		goto out;

	/* only compare read only fields */
551
	err = !((card->ext_csd.raw_partition_support ==
552
			bw_ext_csd[EXT_CSD_PARTITION_SUPPORT]) &&
553
		(card->ext_csd.raw_erased_mem_count ==
554
			bw_ext_csd[EXT_CSD_ERASED_MEM_CONT]) &&
555
		(card->ext_csd.rev ==
556
			bw_ext_csd[EXT_CSD_REV]) &&
557
		(card->ext_csd.raw_ext_csd_structure ==
558
			bw_ext_csd[EXT_CSD_STRUCTURE]) &&
559
		(card->ext_csd.raw_card_type ==
560
			bw_ext_csd[EXT_CSD_CARD_TYPE]) &&
561
		(card->ext_csd.raw_s_a_timeout ==
562
			bw_ext_csd[EXT_CSD_S_A_TIMEOUT]) &&
563
		(card->ext_csd.raw_hc_erase_gap_size ==
564
			bw_ext_csd[EXT_CSD_HC_WP_GRP_SIZE]) &&
565
		(card->ext_csd.raw_erase_timeout_mult ==
566
			bw_ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT]) &&
567
		(card->ext_csd.raw_hc_erase_grp_size ==
568
			bw_ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]) &&
569
		(card->ext_csd.raw_sec_trim_mult ==
570
			bw_ext_csd[EXT_CSD_SEC_TRIM_MULT]) &&
571
		(card->ext_csd.raw_sec_erase_mult ==
572
			bw_ext_csd[EXT_CSD_SEC_ERASE_MULT]) &&
573
		(card->ext_csd.raw_sec_feature_support ==
574
			bw_ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT]) &&
575
		(card->ext_csd.raw_trim_mult ==
576
			bw_ext_csd[EXT_CSD_TRIM_MULT]) &&
577 578 579 580 581 582 583 584
		(card->ext_csd.raw_sectors[0] ==
			bw_ext_csd[EXT_CSD_SEC_CNT + 0]) &&
		(card->ext_csd.raw_sectors[1] ==
			bw_ext_csd[EXT_CSD_SEC_CNT + 1]) &&
		(card->ext_csd.raw_sectors[2] ==
			bw_ext_csd[EXT_CSD_SEC_CNT + 2]) &&
		(card->ext_csd.raw_sectors[3] ==
			bw_ext_csd[EXT_CSD_SEC_CNT + 3]));
585 586 587 588 589
	if (err)
		err = -EINVAL;

out:
	mmc_free_ext_csd(bw_ext_csd);
P
Pierre Ossman 已提交
590 591 592
	return err;
}

593 594 595 596 597
MMC_DEV_ATTR(cid, "%08x%08x%08x%08x\n", card->raw_cid[0], card->raw_cid[1],
	card->raw_cid[2], card->raw_cid[3]);
MMC_DEV_ATTR(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1],
	card->raw_csd[2], card->raw_csd[3]);
MMC_DEV_ATTR(date, "%02d/%04d\n", card->cid.month, card->cid.year);
598 599
MMC_DEV_ATTR(erase_size, "%u\n", card->erase_size << 9);
MMC_DEV_ATTR(preferred_erase_size, "%u\n", card->pref_erase << 9);
600 601 602 603 604 605
MMC_DEV_ATTR(fwrev, "0x%x\n", card->cid.fwrev);
MMC_DEV_ATTR(hwrev, "0x%x\n", card->cid.hwrev);
MMC_DEV_ATTR(manfid, "0x%06x\n", card->cid.manfid);
MMC_DEV_ATTR(name, "%s\n", card->cid.prod_name);
MMC_DEV_ATTR(oemid, "0x%04x\n", card->cid.oemid);
MMC_DEV_ATTR(serial, "0x%08x\n", card->cid.serial);
606 607 608
MMC_DEV_ATTR(enhanced_area_offset, "%llu\n",
		card->ext_csd.enhanced_area_offset);
MMC_DEV_ATTR(enhanced_area_size, "%u\n", card->ext_csd.enhanced_area_size);
609 610 611 612 613

static struct attribute *mmc_std_attrs[] = {
	&dev_attr_cid.attr,
	&dev_attr_csd.attr,
	&dev_attr_date.attr,
614 615
	&dev_attr_erase_size.attr,
	&dev_attr_preferred_erase_size.attr,
616 617 618 619 620 621
	&dev_attr_fwrev.attr,
	&dev_attr_hwrev.attr,
	&dev_attr_manfid.attr,
	&dev_attr_name.attr,
	&dev_attr_oemid.attr,
	&dev_attr_serial.attr,
622 623
	&dev_attr_enhanced_area_offset.attr,
	&dev_attr_enhanced_area_size.attr,
624 625 626 627 628 629 630
	NULL,
};

static struct attribute_group mmc_std_attr_group = {
	.attrs = mmc_std_attrs,
};

631
static const struct attribute_group *mmc_attr_groups[] = {
632 633 634 635 636 637 638 639
	&mmc_std_attr_group,
	NULL,
};

static struct device_type mmc_type = {
	.groups = mmc_attr_groups,
};

640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680
/*
 * Select the PowerClass for the current bus width
 * If power class is defined for 4/8 bit bus in the
 * extended CSD register, select it by executing the
 * mmc_switch command.
 */
static int mmc_select_powerclass(struct mmc_card *card,
		unsigned int bus_width, u8 *ext_csd)
{
	int err = 0;
	unsigned int pwrclass_val;
	unsigned int index = 0;
	struct mmc_host *host;

	BUG_ON(!card);

	host = card->host;
	BUG_ON(!host);

	if (ext_csd == NULL)
		return 0;

	/* Power class selection is supported for versions >= 4.0 */
	if (card->csd.mmca_vsn < CSD_SPEC_VER_4)
		return 0;

	/* Power class values are defined only for 4/8 bit bus */
	if (bus_width == EXT_CSD_BUS_WIDTH_1)
		return 0;

	switch (1 << host->ios.vdd) {
	case MMC_VDD_165_195:
		if (host->ios.clock <= 26000000)
			index = EXT_CSD_PWR_CL_26_195;
		else if	(host->ios.clock <= 52000000)
			index = (bus_width <= EXT_CSD_BUS_WIDTH_8) ?
				EXT_CSD_PWR_CL_52_195 :
				EXT_CSD_PWR_CL_DDR_52_195;
		else if (host->ios.clock <= 200000000)
			index = EXT_CSD_PWR_CL_200_195;
		break;
681 682 683 684 685
	case MMC_VDD_27_28:
	case MMC_VDD_28_29:
	case MMC_VDD_29_30:
	case MMC_VDD_30_31:
	case MMC_VDD_31_32:
686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718
	case MMC_VDD_32_33:
	case MMC_VDD_33_34:
	case MMC_VDD_34_35:
	case MMC_VDD_35_36:
		if (host->ios.clock <= 26000000)
			index = EXT_CSD_PWR_CL_26_360;
		else if	(host->ios.clock <= 52000000)
			index = (bus_width <= EXT_CSD_BUS_WIDTH_8) ?
				EXT_CSD_PWR_CL_52_360 :
				EXT_CSD_PWR_CL_DDR_52_360;
		else if (host->ios.clock <= 200000000)
			index = EXT_CSD_PWR_CL_200_360;
		break;
	default:
		pr_warning("%s: Voltage range not supported "
			   "for power class.\n", mmc_hostname(host));
		return -EINVAL;
	}

	pwrclass_val = ext_csd[index];

	if (bus_width & (EXT_CSD_BUS_WIDTH_8 | EXT_CSD_DDR_BUS_WIDTH_8))
		pwrclass_val = (pwrclass_val & EXT_CSD_PWR_CL_8BIT_MASK) >>
				EXT_CSD_PWR_CL_8BIT_SHIFT;
	else
		pwrclass_val = (pwrclass_val & EXT_CSD_PWR_CL_4BIT_MASK) >>
				EXT_CSD_PWR_CL_4BIT_SHIFT;

	/* If the power class is different from the default value */
	if (pwrclass_val > 0) {
		err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
				 EXT_CSD_POWER_CLASS,
				 pwrclass_val,
719
				 card->ext_csd.generic_cmd6_time);
720 721
	}

722 723 724 725
	if (err)
		pr_err("%s: power class selection for ext_csd_bus_width %d"
		       " failed\n", mmc_hostname(card->host), bus_width);

726 727 728
	return err;
}

729 730 731 732 733 734
/*
 * Selects the desired buswidth and switch to the HS200 mode
 * if bus width set without error
 */
static int mmc_select_hs200(struct mmc_card *card)
{
735
	int idx, err = -EINVAL;
736 737 738 739 740 741 742 743 744 745 746 747 748 749 750
	struct mmc_host *host;
	static unsigned ext_csd_bits[] = {
		EXT_CSD_BUS_WIDTH_4,
		EXT_CSD_BUS_WIDTH_8,
	};
	static unsigned bus_widths[] = {
		MMC_BUS_WIDTH_4,
		MMC_BUS_WIDTH_8,
	};

	BUG_ON(!card);

	host = card->host;

	if (card->ext_csd.card_type & EXT_CSD_CARD_TYPE_SDR_1_2V &&
751 752 753 754 755 756
			host->caps2 & MMC_CAP2_HS200_1_2V_SDR)
		err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120, 0);

	if (err && card->ext_csd.card_type & EXT_CSD_CARD_TYPE_SDR_1_8V &&
			host->caps2 & MMC_CAP2_HS200_1_8V_SDR)
		err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180, 0);
757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803

	/* If fails try again during next card power cycle */
	if (err)
		goto err;

	idx = (host->caps & MMC_CAP_8_BIT_DATA) ? 1 : 0;

	/*
	 * Unlike SD, MMC cards dont have a configuration register to notify
	 * supported bus width. So bus test command should be run to identify
	 * the supported bus width or compare the ext csd values of current
	 * bus width and ext csd values of 1 bit mode read earlier.
	 */
	for (; idx >= 0; idx--) {

		/*
		 * Host is capable of 8bit transfer, then switch
		 * the device to work in 8bit transfer mode. If the
		 * mmc switch command returns error then switch to
		 * 4bit transfer mode. On success set the corresponding
		 * bus width on the host.
		 */
		err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
				 EXT_CSD_BUS_WIDTH,
				 ext_csd_bits[idx],
				 card->ext_csd.generic_cmd6_time);
		if (err)
			continue;

		mmc_set_bus_width(card->host, bus_widths[idx]);

		if (!(host->caps & MMC_CAP_BUS_WIDTH_TEST))
			err = mmc_compare_ext_csds(card, bus_widths[idx]);
		else
			err = mmc_bus_test(card, bus_widths[idx]);
		if (!err)
			break;
	}

	/* switch to HS200 mode if bus width set successfully */
	if (!err)
		err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
				 EXT_CSD_HS_TIMING, 2, 0);
err:
	return err;
}

P
Pierre Ossman 已提交
804
/*
805 806
 * Handle the detection and initialisation of a card.
 *
D
Deepak Saxena 已提交
807
 * In the case of a resume, "oldcard" will contain the card
808
 * we're trying to reinitialise.
P
Pierre Ossman 已提交
809
 */
810
static int mmc_init_card(struct mmc_host *host, u32 ocr,
811
	struct mmc_card *oldcard)
P
Pierre Ossman 已提交
812 813
{
	struct mmc_card *card;
P
Philip Rakity 已提交
814
	int err, ddr = 0;
P
Pierre Ossman 已提交
815 816
	u32 cid[4];
	unsigned int max_dtr;
817
	u32 rocr;
818
	u8 *ext_csd = NULL;
P
Pierre Ossman 已提交
819 820

	BUG_ON(!host);
P
Pierre Ossman 已提交
821
	WARN_ON(!host->claimed);
P
Pierre Ossman 已提交
822

823 824 825 826
	/* Set correct bus mode for MMC before attempting init */
	if (!mmc_host_is_spi(host))
		mmc_set_bus_mode(host, MMC_BUSMODE_OPENDRAIN);

827 828 829
	/* Initialization should be done at 3.3 V I/O voltage. */
	mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330, 0);

P
Pierre Ossman 已提交
830 831 832 833 834
	/*
	 * Since we're changing the OCR value, we seem to
	 * need to tell some cards to go back to the idle
	 * state.  We wait 1ms to give cards time to
	 * respond.
835
	 * mmc_go_idle is needed for eMMC that are asleep
P
Pierre Ossman 已提交
836 837 838 839
	 */
	mmc_go_idle(host);

	/* The extra bit indicates that we support high capacity */
840
	err = mmc_send_op_cond(host, ocr | (1 << 30), &rocr);
P
Pierre Ossman 已提交
841
	if (err)
842
		goto err;
P
Pierre Ossman 已提交
843

D
David Brownell 已提交
844 845 846 847 848 849 850 851 852
	/*
	 * For SPI, enable CRC as appropriate.
	 */
	if (mmc_host_is_spi(host)) {
		err = mmc_spi_set_crc(host, use_spi_crc);
		if (err)
			goto err;
	}

P
Pierre Ossman 已提交
853 854 855
	/*
	 * Fetch CID from card.
	 */
D
David Brownell 已提交
856 857 858 859
	if (mmc_host_is_spi(host))
		err = mmc_send_cid(host, cid);
	else
		err = mmc_all_send_cid(host, cid);
P
Pierre Ossman 已提交
860
	if (err)
P
Pierre Ossman 已提交
861 862
		goto err;

863
	if (oldcard) {
P
Pierre Ossman 已提交
864 865
		if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0) {
			err = -ENOENT;
866
			goto err;
P
Pierre Ossman 已提交
867
		}
868 869 870 871 872 873

		card = oldcard;
	} else {
		/*
		 * Allocate card structure.
		 */
874
		card = mmc_alloc_card(host, &mmc_type);
P
Pierre Ossman 已提交
875 876
		if (IS_ERR(card)) {
			err = PTR_ERR(card);
877
			goto err;
P
Pierre Ossman 已提交
878
		}
P
Pierre Ossman 已提交
879

880 881 882 883
		card->type = MMC_TYPE_MMC;
		card->rca = 1;
		memcpy(card->raw_cid, cid, sizeof(card->raw_cid));
	}
P
Pierre Ossman 已提交
884 885

	/*
D
David Brownell 已提交
886
	 * For native busses:  set card RCA and quit open drain mode.
P
Pierre Ossman 已提交
887
	 */
D
David Brownell 已提交
888 889 890 891
	if (!mmc_host_is_spi(host)) {
		err = mmc_set_relative_addr(card);
		if (err)
			goto free_card;
P
Pierre Ossman 已提交
892

D
David Brownell 已提交
893 894
		mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL);
	}
P
Pierre Ossman 已提交
895

896 897 898 899 900
	if (!oldcard) {
		/*
		 * Fetch CSD from card.
		 */
		err = mmc_send_csd(card, card->raw_csd);
P
Pierre Ossman 已提交
901
		if (err)
902
			goto free_card;
P
Pierre Ossman 已提交
903

P
Pierre Ossman 已提交
904
		err = mmc_decode_csd(card);
P
Pierre Ossman 已提交
905
		if (err)
P
Pierre Ossman 已提交
906 907
			goto free_card;
		err = mmc_decode_cid(card);
P
Pierre Ossman 已提交
908
		if (err)
P
Pierre Ossman 已提交
909
			goto free_card;
910
	}
P
Pierre Ossman 已提交
911 912

	/*
913
	 * Select card, as all following commands rely on that.
P
Pierre Ossman 已提交
914
	 */
D
David Brownell 已提交
915 916 917 918 919
	if (!mmc_host_is_spi(host)) {
		err = mmc_select_card(card);
		if (err)
			goto free_card;
	}
P
Pierre Ossman 已提交
920

921 922
	if (!oldcard) {
		/*
D
David Brownell 已提交
923
		 * Fetch and process extended CSD.
924
		 */
925 926 927 928 929

		err = mmc_get_ext_csd(card, &ext_csd);
		if (err)
			goto free_card;
		err = mmc_read_ext_csd(card, ext_csd);
P
Pierre Ossman 已提交
930
		if (err)
931
			goto free_card;
932 933 934 935 936 937 938 939 940

		/* If doing byte addressing, check if required to do sector
		 * addressing.  Handle the case of <2GB cards needing sector
		 * addressing.  See section 8.1 JEDEC Standard JED84-A441;
		 * ocr register has bit 30 set for sector addressing.
		 */
		if (!(mmc_card_blockaddr(card)) && (rocr & (1<<30)))
			mmc_card_set_blockaddr(card);

941 942
		/* Erase size depends on CSD and Extended CSD */
		mmc_set_erase_size(card);
943
	}
P
Pierre Ossman 已提交
944

945 946
	/*
	 * If enhanced_area_en is TRUE, host needs to enable ERASE_GRP_DEF
L
Lucas De Marchi 已提交
947
	 * bit.  This bit will be lost every time after a reset or power off.
948
	 */
949 950
	if (card->ext_csd.enhanced_area_en ||
	    (card->ext_csd.rev >= 3 && (host->caps2 & MMC_CAP2_HC_ERASE_SZ))) {
951
		err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
952 953
				 EXT_CSD_ERASE_GROUP_DEF, 1,
				 card->ext_csd.generic_cmd6_time);
954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977

		if (err && err != -EBADMSG)
			goto free_card;

		if (err) {
			err = 0;
			/*
			 * Just disable enhanced area off & sz
			 * will try to enable ERASE_GROUP_DEF
			 * during next time reinit
			 */
			card->ext_csd.enhanced_area_offset = -EINVAL;
			card->ext_csd.enhanced_area_size = -EINVAL;
		} else {
			card->ext_csd.erase_group_def = 1;
			/*
			 * enable ERASE_GRP_DEF successfully.
			 * This will affect the erase size, so
			 * here need to reset erase size
			 */
			mmc_set_erase_size(card);
		}
	}

978 979 980
	/*
	 * Ensure eMMC user default partition is enabled
	 */
981 982 983 984 985 986 987
	if (card->ext_csd.part_config & EXT_CSD_PART_CONFIG_ACC_MASK) {
		card->ext_csd.part_config &= ~EXT_CSD_PART_CONFIG_ACC_MASK;
		err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONFIG,
				 card->ext_csd.part_config,
				 card->ext_csd.part_time);
		if (err && err != -EBADMSG)
			goto free_card;
988 989
	}

990 991 992 993 994
	/*
	 * If the host supports the power_off_notify capability then
	 * set the notification byte in the ext_csd register of device
	 */
	if ((host->caps2 & MMC_CAP2_POWEROFF_NOTIFY) &&
995
	    (card->ext_csd.rev >= 6)) {
996 997 998 999 1000 1001 1002
		err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
				 EXT_CSD_POWER_OFF_NOTIFICATION,
				 EXT_CSD_POWER_ON,
				 card->ext_csd.generic_cmd6_time);
		if (err && err != -EBADMSG)
			goto free_card;

1003 1004 1005 1006 1007 1008 1009
		/*
		 * The err can be -EBADMSG or 0,
		 * so check for success and update the flag
		 */
		if (!err)
			card->poweroff_notify_state = MMC_POWERED_ON;
	}
1010

1011 1012 1013
	/*
	 * Activate high speed (if supported)
	 */
1014 1015 1016 1017 1018 1019 1020
	if (card->ext_csd.hs_max_dtr != 0) {
		err = 0;
		if (card->ext_csd.hs_max_dtr > 52000000 &&
		    host->caps2 & MMC_CAP2_HS200)
			err = mmc_select_hs200(card);
		else if	(host->caps & MMC_CAP_MMC_HIGHSPEED)
			err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1021 1022
					 EXT_CSD_HS_TIMING, 1,
					 card->ext_csd.generic_cmd6_time);
1023

1024
		if (err && err != -EBADMSG)
1025 1026
			goto free_card;

1027
		if (err) {
1028
			pr_warning("%s: switch to highspeed failed\n",
1029 1030 1031
			       mmc_hostname(card->host));
			err = 0;
		} else {
1032 1033 1034 1035 1036 1037 1038 1039 1040
			if (card->ext_csd.hs_max_dtr > 52000000 &&
			    host->caps2 & MMC_CAP2_HS200) {
				mmc_card_set_hs200(card);
				mmc_set_timing(card->host,
					       MMC_TIMING_MMC_HS200);
			} else {
				mmc_card_set_highspeed(card);
				mmc_set_timing(card->host, MMC_TIMING_MMC_HS);
			}
1041
		}
1042 1043
	}

P
Pierre Ossman 已提交
1044 1045 1046 1047 1048
	/*
	 * Compute bus speed.
	 */
	max_dtr = (unsigned int)-1;

1049
	if (mmc_card_highspeed(card) || mmc_card_hs200(card)) {
P
Pierre Ossman 已提交
1050 1051 1052 1053 1054 1055 1056 1057
		if (max_dtr > card->ext_csd.hs_max_dtr)
			max_dtr = card->ext_csd.hs_max_dtr;
	} else if (max_dtr > card->csd.max_dtr) {
		max_dtr = card->csd.max_dtr;
	}

	mmc_set_clock(host, max_dtr);

H
Hanumath Prasad 已提交
1058
	/*
1059
	 * Indicate DDR mode (if supported).
H
Hanumath Prasad 已提交
1060 1061 1062
	 */
	if (mmc_card_highspeed(card)) {
		if ((card->ext_csd.card_type & EXT_CSD_CARD_TYPE_DDR_1_8V)
1063 1064 1065
			&& ((host->caps & (MMC_CAP_1_8V_DDR |
			     MMC_CAP_UHS_DDR50))
				== (MMC_CAP_1_8V_DDR | MMC_CAP_UHS_DDR50)))
A
Adrian Hunter 已提交
1066
				ddr = MMC_1_8V_DDR_MODE;
H
Hanumath Prasad 已提交
1067
		else if ((card->ext_csd.card_type & EXT_CSD_CARD_TYPE_DDR_1_2V)
1068 1069 1070
			&& ((host->caps & (MMC_CAP_1_2V_DDR |
			     MMC_CAP_UHS_DDR50))
				== (MMC_CAP_1_2V_DDR | MMC_CAP_UHS_DDR50)))
A
Adrian Hunter 已提交
1071
				ddr = MMC_1_2V_DDR_MODE;
H
Hanumath Prasad 已提交
1072 1073
	}

1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092
	/*
	 * Indicate HS200 SDR mode (if supported).
	 */
	if (mmc_card_hs200(card)) {
		u32 ext_csd_bits;
		u32 bus_width = card->host->ios.bus_width;

		/*
		 * For devices supporting HS200 mode, the bus width has
		 * to be set before executing the tuning function. If
		 * set before tuning, then device will respond with CRC
		 * errors for responses on CMD line. So for HS200 the
		 * sequence will be
		 * 1. set bus width 4bit / 8 bit (1 bit not supported)
		 * 2. switch to HS200 mode
		 * 3. set the clock to > 52Mhz <=200MHz and
		 * 4. execute tuning for HS200
		 */
		if ((host->caps2 & MMC_CAP2_HS200) &&
S
Subhash Jadavani 已提交
1093 1094
		    card->host->ops->execute_tuning) {
			mmc_host_clk_hold(card->host);
1095 1096
			err = card->host->ops->execute_tuning(card->host,
				MMC_SEND_TUNING_BLOCK_HS200);
S
Subhash Jadavani 已提交
1097 1098
			mmc_host_clk_release(card->host);
		}
1099 1100 1101 1102 1103 1104 1105 1106 1107
		if (err) {
			pr_warning("%s: tuning execution failed\n",
				   mmc_hostname(card->host));
			goto err;
		}

		ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ?
				EXT_CSD_BUS_WIDTH_8 : EXT_CSD_BUS_WIDTH_4;
		err = mmc_select_powerclass(card, ext_csd_bits, ext_csd);
1108
		if (err)
1109
			goto err;
1110 1111
	}

1112
	/*
1113
	 * Activate wide bus and DDR (if supported).
1114
	 */
1115
	if (!mmc_card_hs200(card) &&
1116
	    (card->csd.mmca_vsn >= CSD_SPEC_VER_4) &&
J
Jarkko Lavinen 已提交
1117
	    (host->caps & (MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA))) {
1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137
		static unsigned ext_csd_bits[][2] = {
			{ EXT_CSD_BUS_WIDTH_8, EXT_CSD_DDR_BUS_WIDTH_8 },
			{ EXT_CSD_BUS_WIDTH_4, EXT_CSD_DDR_BUS_WIDTH_4 },
			{ EXT_CSD_BUS_WIDTH_1, EXT_CSD_BUS_WIDTH_1 },
		};
		static unsigned bus_widths[] = {
			MMC_BUS_WIDTH_8,
			MMC_BUS_WIDTH_4,
			MMC_BUS_WIDTH_1
		};
		unsigned idx, bus_width = 0;

		if (host->caps & MMC_CAP_8_BIT_DATA)
			idx = 0;
		else
			idx = 1;
		for (; idx < ARRAY_SIZE(bus_widths); idx++) {
			bus_width = bus_widths[idx];
			if (bus_width == MMC_BUS_WIDTH_1)
				ddr = 0; /* no DDR for 1-bit width */
1138 1139 1140
			err = mmc_select_powerclass(card, ext_csd_bits[idx][0],
						    ext_csd);
			if (err)
1141
				goto err;
1142

1143 1144
			err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
					 EXT_CSD_BUS_WIDTH,
1145
					 ext_csd_bits[idx][0],
1146
					 card->ext_csd.generic_cmd6_time);
1147
			if (!err) {
1148
				mmc_set_bus_width(card->host, bus_width);
1149

1150 1151
				/*
				 * If controller can't handle bus width test,
1152 1153
				 * compare ext_csd previously read in 1 bit mode
				 * against ext_csd at new bus width
1154 1155
				 */
				if (!(host->caps & MMC_CAP_BUS_WIDTH_TEST))
1156 1157 1158 1159
					err = mmc_compare_ext_csds(card,
						bus_width);
				else
					err = mmc_bus_test(card, bus_width);
1160 1161 1162
				if (!err)
					break;
			}
J
Jarkko Lavinen 已提交
1163 1164
		}

1165
		if (!err && ddr) {
1166 1167 1168
			err = mmc_select_powerclass(card, ext_csd_bits[idx][1],
						    ext_csd);
			if (err)
1169
				goto err;
1170

1171
			err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1172 1173
					 EXT_CSD_BUS_WIDTH,
					 ext_csd_bits[idx][1],
1174
					 card->ext_csd.generic_cmd6_time);
1175
		}
1176
		if (err) {
1177
			pr_warning("%s: switch to bus width %d ddr %d "
1178 1179 1180 1181
				"failed\n", mmc_hostname(card->host),
				1 << bus_width, ddr);
			goto free_card;
		} else if (ddr) {
1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195
			/*
			 * eMMC cards can support 3.3V to 1.2V i/o (vccq)
			 * signaling.
			 *
			 * EXT_CSD_CARD_TYPE_DDR_1_8V means 3.3V or 1.8V vccq.
			 *
			 * 1.8V vccq at 3.3V core voltage (vcc) is not required
			 * in the JEDEC spec for DDR.
			 *
			 * Do not force change in vccq since we are obviously
			 * working and no change to vccq is needed.
			 *
			 * WARNING: eMMC rules are NOT the same as SD DDR
			 */
1196
			if (ddr == MMC_1_2V_DDR_MODE) {
1197 1198 1199 1200 1201
				err = mmc_set_signal_voltage(host,
					MMC_SIGNAL_VOLTAGE_120, 0);
				if (err)
					goto err;
			}
1202
			mmc_card_set_ddr_mode(card);
1203 1204
			mmc_set_timing(card->host, MMC_TIMING_UHS_DDR50);
			mmc_set_bus_width(card->host, bus_width);
1205
		}
1206 1207
	}

S
Subhash Jadavani 已提交
1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224
	/*
	 * Enable HPI feature (if supported)
	 */
	if (card->ext_csd.hpi) {
		err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
				EXT_CSD_HPI_MGMT, 1,
				card->ext_csd.generic_cmd6_time);
		if (err && err != -EBADMSG)
			goto free_card;
		if (err) {
			pr_warning("%s: Enabling HPI failed\n",
				   mmc_hostname(card->host));
			err = 0;
		} else
			card->ext_csd.hpi_en = 1;
	}

1225 1226 1227 1228 1229 1230 1231
	/*
	 * If cache size is higher than 0, this indicates
	 * the existence of cache and it can be turned on.
	 */
	if ((host->caps2 & MMC_CAP2_CACHE_CTRL) &&
			card->ext_csd.cache_size > 0) {
		err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
1232 1233
				EXT_CSD_CACHE_CTRL, 1,
				card->ext_csd.generic_cmd6_time);
1234 1235 1236 1237 1238 1239
		if (err && err != -EBADMSG)
			goto free_card;

		/*
		 * Only if no error, cache is turned on successfully.
		 */
1240 1241 1242 1243 1244 1245 1246 1247 1248
		if (err) {
			pr_warning("%s: Cache is supported, "
					"but failed to turn on (%d)\n",
					mmc_hostname(card->host), err);
			card->ext_csd.cache_ctrl = 0;
			err = 0;
		} else {
			card->ext_csd.cache_ctrl = 1;
		}
1249 1250
	}

1251 1252 1253
	if (!oldcard)
		host->card = card;

1254
	mmc_free_ext_csd(ext_csd);
P
Pierre Ossman 已提交
1255
	return 0;
1256 1257 1258 1259 1260

free_card:
	if (!oldcard)
		mmc_remove_card(card);
err:
1261
	mmc_free_ext_csd(ext_csd);
1262

P
Pierre Ossman 已提交
1263
	return err;
1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277
}

/*
 * Host is being removed. Free up the current card.
 */
static void mmc_remove(struct mmc_host *host)
{
	BUG_ON(!host);
	BUG_ON(!host->card);

	mmc_remove_card(host->card);
	host->card = NULL;
}

1278 1279 1280 1281 1282 1283 1284 1285
/*
 * Card detection - card is alive.
 */
static int mmc_alive(struct mmc_host *host)
{
	return mmc_send_status(host->card, NULL);
}

1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300
/*
 * Card detection callback from host.
 */
static void mmc_detect(struct mmc_host *host)
{
	int err;

	BUG_ON(!host);
	BUG_ON(!host->card);

	mmc_claim_host(host);

	/*
	 * Just check if our card has been removed.
	 */
1301
	err = _mmc_detect_card_removed(host);
1302 1303 1304

	mmc_release_host(host);

P
Pierre Ossman 已提交
1305
	if (err) {
P
Pierre Ossman 已提交
1306
		mmc_remove(host);
1307 1308 1309

		mmc_claim_host(host);
		mmc_detach_bus(host);
1310
		mmc_power_off(host);
1311 1312 1313 1314 1315 1316 1317
		mmc_release_host(host);
	}
}

/*
 * Suspend callback from host.
 */
1318
static int mmc_suspend(struct mmc_host *host)
1319
{
1320 1321
	int err = 0;

1322 1323
	BUG_ON(!host);
	BUG_ON(!host->card);
P
Pierre Ossman 已提交
1324

1325
	mmc_claim_host(host);
1326
	if (mmc_card_can_sleep(host)) {
1327
		err = mmc_card_sleep(host);
1328 1329 1330
		if (!err)
			mmc_card_set_sleep(host->card);
	} else if (!mmc_host_is_spi(host))
D
David Brownell 已提交
1331
		mmc_deselect_cards(host);
1332
	host->card->state &= ~(MMC_STATE_HIGHSPEED | MMC_STATE_HIGHSPEED_200);
P
Pierre Ossman 已提交
1333
	mmc_release_host(host);
1334

1335
	return err;
1336
}
P
Pierre Ossman 已提交
1337

1338 1339 1340 1341 1342 1343
/*
 * Resume callback from host.
 *
 * This function tries to determine if the same card is still present
 * and, if so, restore all state to it.
 */
1344
static int mmc_resume(struct mmc_host *host)
1345 1346 1347 1348 1349 1350 1351
{
	int err;

	BUG_ON(!host);
	BUG_ON(!host->card);

	mmc_claim_host(host);
1352 1353 1354 1355 1356
	if (mmc_card_is_sleep(host->card)) {
		err = mmc_card_awake(host);
		mmc_card_clr_sleep(host->card);
	} else
		err = mmc_init_card(host, host->ocr, host->card);
1357 1358
	mmc_release_host(host);

1359
	return err;
1360 1361
}

1362
static int mmc_power_restore(struct mmc_host *host)
1363
{
1364 1365
	int ret;

1366 1367
	host->card->state &= ~(MMC_STATE_HIGHSPEED | MMC_STATE_HIGHSPEED_200);
	mmc_card_clr_sleep(host->card);
1368
	mmc_claim_host(host);
1369
	ret = mmc_init_card(host, host->ocr, host->card);
1370
	mmc_release_host(host);
1371 1372

	return ret;
1373 1374
}

1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404
static int mmc_sleep(struct mmc_host *host)
{
	struct mmc_card *card = host->card;
	int err = -ENOSYS;

	if (card && card->ext_csd.rev >= 3) {
		err = mmc_card_sleepawake(host, 1);
		if (err < 0)
			pr_debug("%s: Error %d while putting card into sleep",
				 mmc_hostname(host), err);
	}

	return err;
}

static int mmc_awake(struct mmc_host *host)
{
	struct mmc_card *card = host->card;
	int err = -ENOSYS;

	if (card && card->ext_csd.rev >= 3) {
		err = mmc_card_sleepawake(host, 0);
		if (err < 0)
			pr_debug("%s: Error %d while awaking sleeping card",
				 mmc_hostname(host), err);
	}

	return err;
}

1405
static const struct mmc_bus_ops mmc_ops = {
1406 1407
	.awake = mmc_awake,
	.sleep = mmc_sleep,
1408 1409 1410 1411
	.remove = mmc_remove,
	.detect = mmc_detect,
	.suspend = NULL,
	.resume = NULL,
1412
	.power_restore = mmc_power_restore,
1413
	.alive = mmc_alive,
1414 1415 1416
};

static const struct mmc_bus_ops mmc_ops_unsafe = {
1417 1418
	.awake = mmc_awake,
	.sleep = mmc_sleep,
1419 1420 1421 1422
	.remove = mmc_remove,
	.detect = mmc_detect,
	.suspend = mmc_suspend,
	.resume = mmc_resume,
1423
	.power_restore = mmc_power_restore,
1424
	.alive = mmc_alive,
1425 1426
};

1427 1428 1429 1430
static void mmc_attach_bus_ops(struct mmc_host *host)
{
	const struct mmc_bus_ops *bus_ops;

1431
	if (!mmc_card_is_removable(host))
1432 1433 1434 1435 1436 1437
		bus_ops = &mmc_ops_unsafe;
	else
		bus_ops = &mmc_ops;
	mmc_attach_bus(host, bus_ops);
}

1438 1439 1440
/*
 * Starting point for MMC card init.
 */
1441
int mmc_attach_mmc(struct mmc_host *host)
1442 1443
{
	int err;
1444
	u32 ocr;
1445 1446

	BUG_ON(!host);
P
Pierre Ossman 已提交
1447
	WARN_ON(!host->claimed);
1448

1449 1450 1451 1452
	/* Set correct bus mode for MMC before attempting attach */
	if (!mmc_host_is_spi(host))
		mmc_set_bus_mode(host, MMC_BUSMODE_OPENDRAIN);

1453 1454 1455 1456
	err = mmc_send_op_cond(host, 0, &ocr);
	if (err)
		return err;

1457
	mmc_attach_bus_ops(host);
1458 1459
	if (host->ocr_avail_mmc)
		host->ocr_avail = host->ocr_avail_mmc;
1460

D
David Brownell 已提交
1461 1462 1463 1464 1465 1466 1467 1468 1469
	/*
	 * We need to get OCR a different way for SPI.
	 */
	if (mmc_host_is_spi(host)) {
		err = mmc_spi_read_ocr(host, 1, &ocr);
		if (err)
			goto err;
	}

1470 1471 1472 1473 1474
	/*
	 * Sanity check the voltages that the card claims to
	 * support.
	 */
	if (ocr & 0x7F) {
1475
		pr_warning("%s: card claims to support voltages "
1476 1477 1478 1479 1480 1481 1482 1483 1484 1485
		       "below the defined range. These will be ignored.\n",
		       mmc_hostname(host));
		ocr &= ~0x7F;
	}

	host->ocr = mmc_select_voltage(host, ocr);

	/*
	 * Can we support the voltage of the card?
	 */
1486 1487
	if (!host->ocr) {
		err = -EINVAL;
1488
		goto err;
1489
	}
1490 1491 1492 1493

	/*
	 * Detect and init the card.
	 */
1494
	err = mmc_init_card(host, host->ocr, NULL);
P
Pierre Ossman 已提交
1495
	if (err)
1496 1497 1498
		goto err;

	mmc_release_host(host);
P
Pierre Ossman 已提交
1499
	err = mmc_add_card(host->card);
1500
	mmc_claim_host(host);
P
Pierre Ossman 已提交
1501
	if (err)
1502
		goto remove_card;
P
Pierre Ossman 已提交
1503 1504 1505

	return 0;

1506
remove_card:
1507
	mmc_release_host(host);
1508
	mmc_remove_card(host->card);
1509
	mmc_claim_host(host);
1510
	host->card = NULL;
P
Pierre Ossman 已提交
1511 1512 1513
err:
	mmc_detach_bus(host);

1514
	pr_err("%s: error %d whilst initialising MMC card\n",
1515 1516
		mmc_hostname(host), err);

P
Pierre Ossman 已提交
1517
	return err;
P
Pierre Ossman 已提交
1518
}