Linux Audio

Check our new training course

Loading...
v4.6
 
   1/*
   2 *  linux/drivers/mmc/core/sd.c
   3 *
   4 *  Copyright (C) 2003-2004 Russell King, All Rights Reserved.
   5 *  SD support Copyright (C) 2004 Ian Molton, All Rights Reserved.
   6 *  Copyright (C) 2005-2007 Pierre Ossman, All Rights Reserved.
   7 *
   8 * This program is free software; you can redistribute it and/or modify
   9 * it under the terms of the GNU General Public License version 2 as
  10 * published by the Free Software Foundation.
  11 */
  12
  13#include <linux/err.h>
  14#include <linux/sizes.h>
  15#include <linux/slab.h>
  16#include <linux/stat.h>
  17#include <linux/pm_runtime.h>
 
 
 
  18
  19#include <linux/mmc/host.h>
  20#include <linux/mmc/card.h>
  21#include <linux/mmc/mmc.h>
  22#include <linux/mmc/sd.h>
  23
  24#include "core.h"
 
 
  25#include "bus.h"
  26#include "mmc_ops.h"
  27#include "sd.h"
  28#include "sd_ops.h"
  29
  30static const unsigned int tran_exp[] = {
  31	10000,		100000,		1000000,	10000000,
  32	0,		0,		0,		0
  33};
  34
  35static const unsigned char tran_mant[] = {
  36	0,	10,	12,	13,	15,	20,	25,	30,
  37	35,	40,	45,	50,	55,	60,	70,	80,
  38};
  39
  40static const unsigned int tacc_exp[] = {
  41	1,	10,	100,	1000,	10000,	100000,	1000000, 10000000,
  42};
  43
  44static const unsigned int tacc_mant[] = {
  45	0,	10,	12,	13,	15,	20,	25,	30,
  46	35,	40,	45,	50,	55,	60,	70,	80,
  47};
  48
  49static const unsigned int sd_au_size[] = {
  50	0,		SZ_16K / 512,		SZ_32K / 512,	SZ_64K / 512,
  51	SZ_128K / 512,	SZ_256K / 512,		SZ_512K / 512,	SZ_1M / 512,
  52	SZ_2M / 512,	SZ_4M / 512,		SZ_8M / 512,	(SZ_8M + SZ_4M) / 512,
  53	SZ_16M / 512,	(SZ_16M + SZ_8M) / 512,	SZ_32M / 512,	SZ_64M / 512,
  54};
  55
  56#define UNSTUFF_BITS(resp,start,size)					\
  57	({								\
  58		const int __size = size;				\
  59		const u32 __mask = (__size < 32 ? 1 << __size : 0) - 1;	\
  60		const int __off = 3 - ((start) / 32);			\
  61		const int __shft = (start) & 31;			\
  62		u32 __res;						\
  63									\
  64		__res = resp[__off] >> __shft;				\
  65		if (__size + __shft > 32)				\
  66			__res |= resp[__off-1] << ((32 - __shft) % 32);	\
  67		__res & __mask;						\
  68	})
  69
 
 
 
 
 
 
 
 
  70/*
  71 * Given the decoded CSD structure, decode the raw CID to our CID structure.
  72 */
  73void mmc_decode_cid(struct mmc_card *card)
  74{
  75	u32 *resp = card->raw_cid;
  76
  77	/*
 
 
 
 
 
 
  78	 * SD doesn't currently have a version field so we will
  79	 * have to assume we can parse this.
  80	 */
  81	card->cid.manfid		= UNSTUFF_BITS(resp, 120, 8);
  82	card->cid.oemid			= UNSTUFF_BITS(resp, 104, 16);
  83	card->cid.prod_name[0]		= UNSTUFF_BITS(resp, 96, 8);
  84	card->cid.prod_name[1]		= UNSTUFF_BITS(resp, 88, 8);
  85	card->cid.prod_name[2]		= UNSTUFF_BITS(resp, 80, 8);
  86	card->cid.prod_name[3]		= UNSTUFF_BITS(resp, 72, 8);
  87	card->cid.prod_name[4]		= UNSTUFF_BITS(resp, 64, 8);
  88	card->cid.hwrev			= UNSTUFF_BITS(resp, 60, 4);
  89	card->cid.fwrev			= UNSTUFF_BITS(resp, 56, 4);
  90	card->cid.serial		= UNSTUFF_BITS(resp, 24, 32);
  91	card->cid.year			= UNSTUFF_BITS(resp, 12, 8);
  92	card->cid.month			= UNSTUFF_BITS(resp, 8, 4);
  93
  94	card->cid.year += 2000; /* SD cards year offset */
  95}
  96
  97/*
  98 * Given a 128-bit response, decode to our card CSD structure.
  99 */
 100static int mmc_decode_csd(struct mmc_card *card)
 101{
 102	struct mmc_csd *csd = &card->csd;
 103	unsigned int e, m, csd_struct;
 104	u32 *resp = card->raw_csd;
 105
 106	csd_struct = UNSTUFF_BITS(resp, 126, 2);
 107
 108	switch (csd_struct) {
 109	case 0:
 110		m = UNSTUFF_BITS(resp, 115, 4);
 111		e = UNSTUFF_BITS(resp, 112, 3);
 112		csd->tacc_ns	 = (tacc_exp[e] * tacc_mant[m] + 9) / 10;
 113		csd->tacc_clks	 = UNSTUFF_BITS(resp, 104, 8) * 100;
 114
 115		m = UNSTUFF_BITS(resp, 99, 4);
 116		e = UNSTUFF_BITS(resp, 96, 3);
 117		csd->max_dtr	  = tran_exp[e] * tran_mant[m];
 118		csd->cmdclass	  = UNSTUFF_BITS(resp, 84, 12);
 119
 120		e = UNSTUFF_BITS(resp, 47, 3);
 121		m = UNSTUFF_BITS(resp, 62, 12);
 122		csd->capacity	  = (1 + m) << (e + 2);
 123
 124		csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4);
 125		csd->read_partial = UNSTUFF_BITS(resp, 79, 1);
 126		csd->write_misalign = UNSTUFF_BITS(resp, 78, 1);
 127		csd->read_misalign = UNSTUFF_BITS(resp, 77, 1);
 128		csd->dsr_imp = UNSTUFF_BITS(resp, 76, 1);
 129		csd->r2w_factor = UNSTUFF_BITS(resp, 26, 3);
 130		csd->write_blkbits = UNSTUFF_BITS(resp, 22, 4);
 131		csd->write_partial = UNSTUFF_BITS(resp, 21, 1);
 132
 133		if (UNSTUFF_BITS(resp, 46, 1)) {
 134			csd->erase_size = 1;
 135		} else if (csd->write_blkbits >= 9) {
 136			csd->erase_size = UNSTUFF_BITS(resp, 39, 7) + 1;
 137			csd->erase_size <<= csd->write_blkbits - 9;
 138		}
 
 
 
 139		break;
 140	case 1:
 141		/*
 142		 * This is a block-addressed SDHC or SDXC card. Most
 143		 * interesting fields are unused and have fixed
 144		 * values. To avoid getting tripped by buggy cards,
 145		 * we assume those fixed values ourselves.
 146		 */
 147		mmc_card_set_blockaddr(card);
 148
 149		csd->tacc_ns	 = 0; /* Unused */
 150		csd->tacc_clks	 = 0; /* Unused */
 151
 152		m = UNSTUFF_BITS(resp, 99, 4);
 153		e = UNSTUFF_BITS(resp, 96, 3);
 154		csd->max_dtr	  = tran_exp[e] * tran_mant[m];
 155		csd->cmdclass	  = UNSTUFF_BITS(resp, 84, 12);
 156		csd->c_size	  = UNSTUFF_BITS(resp, 48, 22);
 157
 158		/* SDXC cards have a minimum C_SIZE of 0x00FFFF */
 159		if (csd->c_size >= 0xFFFF)
 160			mmc_card_set_ext_capacity(card);
 161
 162		m = UNSTUFF_BITS(resp, 48, 22);
 163		csd->capacity     = (1 + m) << 10;
 164
 165		csd->read_blkbits = 9;
 166		csd->read_partial = 0;
 167		csd->write_misalign = 0;
 168		csd->read_misalign = 0;
 169		csd->r2w_factor = 4; /* Unused */
 170		csd->write_blkbits = 9;
 171		csd->write_partial = 0;
 172		csd->erase_size = 1;
 
 
 
 173		break;
 174	default:
 175		pr_err("%s: unrecognised CSD structure version %d\n",
 176			mmc_hostname(card->host), csd_struct);
 177		return -EINVAL;
 178	}
 179
 180	card->erase_size = csd->erase_size;
 181
 182	return 0;
 183}
 184
 185/*
 186 * Given a 64-bit response, decode to our card SCR structure.
 187 */
 188static int mmc_decode_scr(struct mmc_card *card)
 189{
 190	struct sd_scr *scr = &card->scr;
 191	unsigned int scr_struct;
 192	u32 resp[4];
 193
 194	resp[3] = card->raw_scr[1];
 195	resp[2] = card->raw_scr[0];
 196
 197	scr_struct = UNSTUFF_BITS(resp, 60, 4);
 198	if (scr_struct != 0) {
 199		pr_err("%s: unrecognised SCR structure version %d\n",
 200			mmc_hostname(card->host), scr_struct);
 201		return -EINVAL;
 202	}
 203
 204	scr->sda_vsn = UNSTUFF_BITS(resp, 56, 4);
 205	scr->bus_widths = UNSTUFF_BITS(resp, 48, 4);
 206	if (scr->sda_vsn == SCR_SPEC_VER_2)
 207		/* Check if Physical Layer Spec v3.0 is supported */
 208		scr->sda_spec3 = UNSTUFF_BITS(resp, 47, 1);
 209
 
 
 
 
 
 210	if (UNSTUFF_BITS(resp, 55, 1))
 211		card->erased_byte = 0xFF;
 212	else
 213		card->erased_byte = 0x0;
 214
 215	if (scr->sda_spec3)
 
 
 216		scr->cmds = UNSTUFF_BITS(resp, 32, 2);
 
 
 
 
 
 
 
 
 217	return 0;
 218}
 219
 220/*
 221 * Fetch and process SD Status register.
 222 */
 223static int mmc_read_ssr(struct mmc_card *card)
 224{
 225	unsigned int au, es, et, eo;
 226	int err, i;
 227	u32 *ssr;
 
 
 228
 229	if (!(card->csd.cmdclass & CCC_APP_SPEC)) {
 230		pr_warn("%s: card lacks mandatory SD Status function\n",
 231			mmc_hostname(card->host));
 232		return 0;
 233	}
 234
 235	ssr = kmalloc(64, GFP_KERNEL);
 236	if (!ssr)
 237		return -ENOMEM;
 238
 239	err = mmc_app_sd_status(card, ssr);
 240	if (err) {
 241		pr_warn("%s: problem reading SD Status register\n",
 242			mmc_hostname(card->host));
 243		err = 0;
 244		goto out;
 245	}
 246
 247	for (i = 0; i < 16; i++)
 248		ssr[i] = be32_to_cpu(ssr[i]);
 
 
 249
 250	/*
 251	 * UNSTUFF_BITS only works with four u32s so we have to offset the
 252	 * bitfield positions accordingly.
 253	 */
 254	au = UNSTUFF_BITS(ssr, 428 - 384, 4);
 255	if (au) {
 256		if (au <= 9 || card->scr.sda_spec3) {
 257			card->ssr.au = sd_au_size[au];
 258			es = UNSTUFF_BITS(ssr, 408 - 384, 16);
 259			et = UNSTUFF_BITS(ssr, 402 - 384, 6);
 260			if (es && et) {
 261				eo = UNSTUFF_BITS(ssr, 400 - 384, 2);
 262				card->ssr.erase_timeout = (et * 1000) / es;
 263				card->ssr.erase_offset = eo * 1000;
 264			}
 265		} else {
 266			pr_warn("%s: SD Status: Invalid Allocation Unit size\n",
 267				mmc_hostname(card->host));
 268		}
 269	}
 270out:
 271	kfree(ssr);
 272	return err;
 
 
 
 
 
 
 
 273}
 274
 275/*
 276 * Fetches and decodes switch information
 277 */
 278static int mmc_read_switch(struct mmc_card *card)
 279{
 280	int err;
 281	u8 *status;
 282
 283	if (card->scr.sda_vsn < SCR_SPEC_VER_1)
 284		return 0;
 285
 286	if (!(card->csd.cmdclass & CCC_SWITCH)) {
 287		pr_warn("%s: card lacks mandatory switch function, performance might suffer\n",
 288			mmc_hostname(card->host));
 289		return 0;
 290	}
 291
 292	err = -EIO;
 293
 294	status = kmalloc(64, GFP_KERNEL);
 295	if (!status) {
 296		pr_err("%s: could not allocate a buffer for "
 297			"switch capabilities.\n",
 298			mmc_hostname(card->host));
 299		return -ENOMEM;
 300	}
 301
 302	/*
 303	 * Find out the card's support bits with a mode 0 operation.
 304	 * The argument does not matter, as the support bits do not
 305	 * change with the arguments.
 306	 */
 307	err = mmc_sd_switch(card, 0, 0, 0, status);
 308	if (err) {
 309		/*
 310		 * If the host or the card can't do the switch,
 311		 * fail more gracefully.
 312		 */
 313		if (err != -EINVAL && err != -ENOSYS && err != -EFAULT)
 314			goto out;
 315
 316		pr_warn("%s: problem reading Bus Speed modes\n",
 317			mmc_hostname(card->host));
 318		err = 0;
 319
 320		goto out;
 321	}
 322
 323	if (status[13] & SD_MODE_HIGH_SPEED)
 324		card->sw_caps.hs_max_dtr = HIGH_SPEED_MAX_DTR;
 325
 326	if (card->scr.sda_spec3) {
 327		card->sw_caps.sd3_bus_mode = status[13];
 328		/* Driver Strengths supported by the card */
 329		card->sw_caps.sd3_drv_type = status[9];
 330		card->sw_caps.sd3_curr_limit = status[7] | status[6] << 8;
 331	}
 332
 333out:
 334	kfree(status);
 335
 336	return err;
 337}
 338
 339/*
 340 * Test if the card supports high-speed mode and, if so, switch to it.
 341 */
 342int mmc_sd_switch_hs(struct mmc_card *card)
 343{
 344	int err;
 345	u8 *status;
 346
 347	if (card->scr.sda_vsn < SCR_SPEC_VER_1)
 348		return 0;
 349
 350	if (!(card->csd.cmdclass & CCC_SWITCH))
 351		return 0;
 352
 353	if (!(card->host->caps & MMC_CAP_SD_HIGHSPEED))
 354		return 0;
 355
 356	if (card->sw_caps.hs_max_dtr == 0)
 357		return 0;
 358
 359	status = kmalloc(64, GFP_KERNEL);
 360	if (!status) {
 361		pr_err("%s: could not allocate a buffer for "
 362			"switch capabilities.\n", mmc_hostname(card->host));
 363		return -ENOMEM;
 364	}
 365
 366	err = mmc_sd_switch(card, 1, 0, 1, status);
 367	if (err)
 368		goto out;
 369
 370	if ((status[16] & 0xF) != 1) {
 371		pr_warn("%s: Problem switching card into high-speed mode!\n",
 372			mmc_hostname(card->host));
 373		err = 0;
 374	} else {
 375		err = 1;
 376	}
 377
 378out:
 379	kfree(status);
 380
 381	return err;
 382}
 383
 384static int sd_select_driver_type(struct mmc_card *card, u8 *status)
 385{
 386	int card_drv_type, drive_strength, drv_type;
 387	int err;
 388
 389	card->drive_strength = 0;
 390
 391	card_drv_type = card->sw_caps.sd3_drv_type | SD_DRIVER_TYPE_B;
 392
 393	drive_strength = mmc_select_drive_strength(card,
 394						   card->sw_caps.uhs_max_dtr,
 395						   card_drv_type, &drv_type);
 396
 397	if (drive_strength) {
 398		err = mmc_sd_switch(card, 1, 2, drive_strength, status);
 399		if (err)
 400			return err;
 401		if ((status[15] & 0xF) != drive_strength) {
 402			pr_warn("%s: Problem setting drive strength!\n",
 403				mmc_hostname(card->host));
 404			return 0;
 405		}
 406		card->drive_strength = drive_strength;
 407	}
 408
 409	if (drv_type)
 410		mmc_set_driver_type(card->host, drv_type);
 411
 412	return 0;
 413}
 414
 415static void sd_update_bus_speed_mode(struct mmc_card *card)
 416{
 417	/*
 418	 * If the host doesn't support any of the UHS-I modes, fallback on
 419	 * default speed.
 420	 */
 421	if (!mmc_host_uhs(card->host)) {
 422		card->sd_bus_speed = 0;
 423		return;
 424	}
 425
 426	if ((card->host->caps & MMC_CAP_UHS_SDR104) &&
 427	    (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR104)) {
 428			card->sd_bus_speed = UHS_SDR104_BUS_SPEED;
 429	} else if ((card->host->caps & MMC_CAP_UHS_DDR50) &&
 430		   (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_DDR50)) {
 431			card->sd_bus_speed = UHS_DDR50_BUS_SPEED;
 432	} else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
 433		    MMC_CAP_UHS_SDR50)) && (card->sw_caps.sd3_bus_mode &
 434		    SD_MODE_UHS_SDR50)) {
 435			card->sd_bus_speed = UHS_SDR50_BUS_SPEED;
 436	} else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
 437		    MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25)) &&
 438		   (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR25)) {
 439			card->sd_bus_speed = UHS_SDR25_BUS_SPEED;
 440	} else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
 441		    MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25 |
 442		    MMC_CAP_UHS_SDR12)) && (card->sw_caps.sd3_bus_mode &
 443		    SD_MODE_UHS_SDR12)) {
 444			card->sd_bus_speed = UHS_SDR12_BUS_SPEED;
 445	}
 446}
 447
 448static int sd_set_bus_speed_mode(struct mmc_card *card, u8 *status)
 449{
 450	int err;
 451	unsigned int timing = 0;
 452
 453	switch (card->sd_bus_speed) {
 454	case UHS_SDR104_BUS_SPEED:
 455		timing = MMC_TIMING_UHS_SDR104;
 456		card->sw_caps.uhs_max_dtr = UHS_SDR104_MAX_DTR;
 457		break;
 458	case UHS_DDR50_BUS_SPEED:
 459		timing = MMC_TIMING_UHS_DDR50;
 460		card->sw_caps.uhs_max_dtr = UHS_DDR50_MAX_DTR;
 461		break;
 462	case UHS_SDR50_BUS_SPEED:
 463		timing = MMC_TIMING_UHS_SDR50;
 464		card->sw_caps.uhs_max_dtr = UHS_SDR50_MAX_DTR;
 465		break;
 466	case UHS_SDR25_BUS_SPEED:
 467		timing = MMC_TIMING_UHS_SDR25;
 468		card->sw_caps.uhs_max_dtr = UHS_SDR25_MAX_DTR;
 469		break;
 470	case UHS_SDR12_BUS_SPEED:
 471		timing = MMC_TIMING_UHS_SDR12;
 472		card->sw_caps.uhs_max_dtr = UHS_SDR12_MAX_DTR;
 473		break;
 474	default:
 475		return 0;
 476	}
 477
 478	err = mmc_sd_switch(card, 1, 0, card->sd_bus_speed, status);
 479	if (err)
 480		return err;
 481
 482	if ((status[16] & 0xF) != card->sd_bus_speed)
 483		pr_warn("%s: Problem setting bus speed mode!\n",
 484			mmc_hostname(card->host));
 485	else {
 486		mmc_set_timing(card->host, timing);
 487		mmc_set_clock(card->host, card->sw_caps.uhs_max_dtr);
 488	}
 489
 490	return 0;
 491}
 492
 493/* Get host's max current setting at its current voltage */
 494static u32 sd_get_host_max_current(struct mmc_host *host)
 495{
 496	u32 voltage, max_current;
 497
 498	voltage = 1 << host->ios.vdd;
 499	switch (voltage) {
 500	case MMC_VDD_165_195:
 501		max_current = host->max_current_180;
 502		break;
 503	case MMC_VDD_29_30:
 504	case MMC_VDD_30_31:
 505		max_current = host->max_current_300;
 506		break;
 507	case MMC_VDD_32_33:
 508	case MMC_VDD_33_34:
 509		max_current = host->max_current_330;
 510		break;
 511	default:
 512		max_current = 0;
 513	}
 514
 515	return max_current;
 516}
 517
 518static int sd_set_current_limit(struct mmc_card *card, u8 *status)
 519{
 520	int current_limit = SD_SET_CURRENT_NO_CHANGE;
 521	int err;
 522	u32 max_current;
 523
 524	/*
 525	 * Current limit switch is only defined for SDR50, SDR104, and DDR50
 526	 * bus speed modes. For other bus speed modes, we do not change the
 527	 * current limit.
 528	 */
 529	if ((card->sd_bus_speed != UHS_SDR50_BUS_SPEED) &&
 530	    (card->sd_bus_speed != UHS_SDR104_BUS_SPEED) &&
 531	    (card->sd_bus_speed != UHS_DDR50_BUS_SPEED))
 532		return 0;
 533
 534	/*
 535	 * Host has different current capabilities when operating at
 536	 * different voltages, so find out its max current first.
 537	 */
 538	max_current = sd_get_host_max_current(card->host);
 539
 540	/*
 541	 * We only check host's capability here, if we set a limit that is
 542	 * higher than the card's maximum current, the card will be using its
 543	 * maximum current, e.g. if the card's maximum current is 300ma, and
 544	 * when we set current limit to 200ma, the card will draw 200ma, and
 545	 * when we set current limit to 400/600/800ma, the card will draw its
 546	 * maximum 300ma from the host.
 547	 *
 548	 * The above is incorrect: if we try to set a current limit that is
 549	 * not supported by the card, the card can rightfully error out the
 550	 * attempt, and remain at the default current limit.  This results
 551	 * in a 300mA card being limited to 200mA even though the host
 552	 * supports 800mA. Failures seen with SanDisk 8GB UHS cards with
 553	 * an iMX6 host. --rmk
 554	 */
 555	if (max_current >= 800 &&
 556	    card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_800)
 557		current_limit = SD_SET_CURRENT_LIMIT_800;
 558	else if (max_current >= 600 &&
 559		 card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_600)
 560		current_limit = SD_SET_CURRENT_LIMIT_600;
 561	else if (max_current >= 400 &&
 562		 card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_400)
 563		current_limit = SD_SET_CURRENT_LIMIT_400;
 564	else if (max_current >= 200 &&
 565		 card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_200)
 566		current_limit = SD_SET_CURRENT_LIMIT_200;
 567
 568	if (current_limit != SD_SET_CURRENT_NO_CHANGE) {
 569		err = mmc_sd_switch(card, 1, 3, current_limit, status);
 570		if (err)
 571			return err;
 572
 573		if (((status[15] >> 4) & 0x0F) != current_limit)
 574			pr_warn("%s: Problem setting current limit!\n",
 575				mmc_hostname(card->host));
 576
 577	}
 578
 579	return 0;
 580}
 581
 582/*
 583 * UHS-I specific initialization procedure
 584 */
 585static int mmc_sd_init_uhs_card(struct mmc_card *card)
 586{
 587	int err;
 588	u8 *status;
 589
 590	if (!card->scr.sda_spec3)
 591		return 0;
 592
 593	if (!(card->csd.cmdclass & CCC_SWITCH))
 594		return 0;
 595
 596	status = kmalloc(64, GFP_KERNEL);
 597	if (!status) {
 598		pr_err("%s: could not allocate a buffer for "
 599			"switch capabilities.\n", mmc_hostname(card->host));
 600		return -ENOMEM;
 601	}
 602
 603	/* Set 4-bit bus width */
 604	if ((card->host->caps & MMC_CAP_4_BIT_DATA) &&
 605	    (card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {
 606		err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
 607		if (err)
 608			goto out;
 609
 610		mmc_set_bus_width(card->host, MMC_BUS_WIDTH_4);
 611	}
 612
 613	/*
 614	 * Select the bus speed mode depending on host
 615	 * and card capability.
 616	 */
 617	sd_update_bus_speed_mode(card);
 618
 619	/* Set the driver strength for the card */
 620	err = sd_select_driver_type(card, status);
 621	if (err)
 622		goto out;
 623
 624	/* Set current limit for the card */
 625	err = sd_set_current_limit(card, status);
 626	if (err)
 627		goto out;
 628
 629	/* Set bus speed mode of the card */
 630	err = sd_set_bus_speed_mode(card, status);
 631	if (err)
 632		goto out;
 633
 634	/*
 635	 * SPI mode doesn't define CMD19 and tuning is only valid for SDR50 and
 636	 * SDR104 mode SD-cards. Note that tuning is mandatory for SDR104.
 637	 */
 638	if (!mmc_host_is_spi(card->host) &&
 639		(card->host->ios.timing == MMC_TIMING_UHS_SDR50 ||
 640		 card->host->ios.timing == MMC_TIMING_UHS_DDR50 ||
 641		 card->host->ios.timing == MMC_TIMING_UHS_SDR104)) {
 642		err = mmc_execute_tuning(card);
 643
 644		/*
 645		 * As SD Specifications Part1 Physical Layer Specification
 646		 * Version 3.01 says, CMD19 tuning is available for unlocked
 647		 * cards in transfer state of 1.8V signaling mode. The small
 648		 * difference between v3.00 and 3.01 spec means that CMD19
 649		 * tuning is also available for DDR50 mode.
 650		 */
 651		if (err && card->host->ios.timing == MMC_TIMING_UHS_DDR50) {
 652			pr_warn("%s: ddr50 tuning failed\n",
 653				mmc_hostname(card->host));
 654			err = 0;
 655		}
 656	}
 657
 658out:
 659	kfree(status);
 660
 661	return err;
 662}
 663
 664MMC_DEV_ATTR(cid, "%08x%08x%08x%08x\n", card->raw_cid[0], card->raw_cid[1],
 665	card->raw_cid[2], card->raw_cid[3]);
 666MMC_DEV_ATTR(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1],
 667	card->raw_csd[2], card->raw_csd[3]);
 668MMC_DEV_ATTR(scr, "%08x%08x\n", card->raw_scr[0], card->raw_scr[1]);
 
 
 
 
 
 
 
 
 669MMC_DEV_ATTR(date, "%02d/%04d\n", card->cid.month, card->cid.year);
 670MMC_DEV_ATTR(erase_size, "%u\n", card->erase_size << 9);
 671MMC_DEV_ATTR(preferred_erase_size, "%u\n", card->pref_erase << 9);
 672MMC_DEV_ATTR(fwrev, "0x%x\n", card->cid.fwrev);
 673MMC_DEV_ATTR(hwrev, "0x%x\n", card->cid.hwrev);
 674MMC_DEV_ATTR(manfid, "0x%06x\n", card->cid.manfid);
 675MMC_DEV_ATTR(name, "%s\n", card->cid.prod_name);
 676MMC_DEV_ATTR(oemid, "0x%04x\n", card->cid.oemid);
 677MMC_DEV_ATTR(serial, "0x%08x\n", card->cid.serial);
 
 
 678
 679
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 680static struct attribute *sd_std_attrs[] = {
 
 
 
 
 
 
 
 681	&dev_attr_cid.attr,
 682	&dev_attr_csd.attr,
 683	&dev_attr_scr.attr,
 
 684	&dev_attr_date.attr,
 685	&dev_attr_erase_size.attr,
 686	&dev_attr_preferred_erase_size.attr,
 687	&dev_attr_fwrev.attr,
 688	&dev_attr_hwrev.attr,
 689	&dev_attr_manfid.attr,
 690	&dev_attr_name.attr,
 691	&dev_attr_oemid.attr,
 692	&dev_attr_serial.attr,
 
 
 
 693	NULL,
 694};
 695ATTRIBUTE_GROUPS(sd_std);
 696
 697struct device_type sd_type = {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 698	.groups = sd_std_groups,
 699};
 700
 701/*
 702 * Fetch CID from card.
 703 */
 704int mmc_sd_get_cid(struct mmc_host *host, u32 ocr, u32 *cid, u32 *rocr)
 705{
 706	int err;
 707	u32 max_current;
 708	int retries = 10;
 709	u32 pocr = ocr;
 710
 711try_again:
 712	if (!retries) {
 713		ocr &= ~SD_OCR_S18R;
 714		pr_warn("%s: Skipping voltage switch\n", mmc_hostname(host));
 715	}
 716
 717	/*
 718	 * Since we're changing the OCR value, we seem to
 719	 * need to tell some cards to go back to the idle
 720	 * state.  We wait 1ms to give cards time to
 721	 * respond.
 722	 */
 723	mmc_go_idle(host);
 724
 725	/*
 726	 * If SD_SEND_IF_COND indicates an SD 2.0
 727	 * compliant card and we should set bit 30
 728	 * of the ocr to indicate that we can handle
 729	 * block-addressed SDHC cards.
 730	 */
 731	err = mmc_send_if_cond(host, ocr);
 732	if (!err)
 733		ocr |= SD_OCR_CCS;
 734
 735	/*
 736	 * If the host supports one of UHS-I modes, request the card
 737	 * to switch to 1.8V signaling level. If the card has failed
 738	 * repeatedly to switch however, skip this.
 739	 */
 740	if (retries && mmc_host_uhs(host))
 741		ocr |= SD_OCR_S18R;
 742
 743	/*
 744	 * If the host can supply more than 150mA at current voltage,
 745	 * XPC should be set to 1.
 746	 */
 747	max_current = sd_get_host_max_current(host);
 748	if (max_current > 150)
 749		ocr |= SD_OCR_XPC;
 750
 751	err = mmc_send_app_op_cond(host, ocr, rocr);
 752	if (err)
 753		return err;
 754
 755	/*
 756	 * In case CCS and S18A in the response is set, start Signal Voltage
 757	 * Switch procedure. SPI mode doesn't support CMD11.
 758	 */
 759	if (!mmc_host_is_spi(host) && rocr &&
 760	   ((*rocr & 0x41000000) == 0x41000000)) {
 761		err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180,
 762					pocr);
 
 
 763		if (err == -EAGAIN) {
 764			retries--;
 765			goto try_again;
 766		} else if (err) {
 767			retries = 0;
 768			goto try_again;
 769		}
 770	}
 771
 772	if (mmc_host_is_spi(host))
 773		err = mmc_send_cid(host, cid);
 774	else
 775		err = mmc_all_send_cid(host, cid);
 776
 777	return err;
 778}
 779
 780int mmc_sd_get_csd(struct mmc_host *host, struct mmc_card *card)
 781{
 782	int err;
 783
 784	/*
 785	 * Fetch CSD from card.
 786	 */
 787	err = mmc_send_csd(card, card->raw_csd);
 788	if (err)
 789		return err;
 790
 791	err = mmc_decode_csd(card);
 792	if (err)
 793		return err;
 794
 795	return 0;
 796}
 797
 798static int mmc_sd_get_ro(struct mmc_host *host)
 799{
 800	int ro;
 801
 802	/*
 803	 * Some systems don't feature a write-protect pin and don't need one.
 804	 * E.g. because they only have micro-SD card slot. For those systems
 805	 * assume that the SD card is always read-write.
 806	 */
 807	if (host->caps2 & MMC_CAP2_NO_WRITE_PROTECT)
 808		return 0;
 809
 810	if (!host->ops->get_ro)
 811		return -1;
 812
 813	ro = host->ops->get_ro(host);
 814
 815	return ro;
 816}
 817
 818int mmc_sd_setup_card(struct mmc_host *host, struct mmc_card *card,
 819	bool reinit)
 820{
 821	int err;
 822
 823	if (!reinit) {
 824		/*
 825		 * Fetch SCR from card.
 826		 */
 827		err = mmc_app_send_scr(card, card->raw_scr);
 828		if (err)
 829			return err;
 830
 831		err = mmc_decode_scr(card);
 832		if (err)
 833			return err;
 834
 835		/*
 836		 * Fetch and process SD Status register.
 837		 */
 838		err = mmc_read_ssr(card);
 839		if (err)
 840			return err;
 841
 842		/* Erase init depends on CSD and SSR */
 843		mmc_init_erase(card);
 844
 845		/*
 846		 * Fetch switch information from card.
 847		 */
 848		err = mmc_read_switch(card);
 849		if (err)
 850			return err;
 851	}
 852
 853	/*
 
 
 
 
 
 
 
 
 854	 * For SPI, enable CRC as appropriate.
 855	 * This CRC enable is located AFTER the reading of the
 856	 * card registers because some SDHC cards are not able
 857	 * to provide valid CRCs for non-512-byte blocks.
 858	 */
 859	if (mmc_host_is_spi(host)) {
 860		err = mmc_spi_set_crc(host, use_spi_crc);
 861		if (err)
 862			return err;
 863	}
 864
 865	/*
 866	 * Check if read-only switch is active.
 867	 */
 868	if (!reinit) {
 869		int ro = mmc_sd_get_ro(host);
 870
 871		if (ro < 0) {
 872			pr_warn("%s: host does not support reading read-only switch, assuming write-enable\n",
 873				mmc_hostname(host));
 874		} else if (ro > 0) {
 875			mmc_card_set_readonly(card);
 876		}
 877	}
 878
 879	return 0;
 880}
 881
 882unsigned mmc_sd_get_max_clock(struct mmc_card *card)
 883{
 884	unsigned max_dtr = (unsigned int)-1;
 885
 886	if (mmc_card_hs(card)) {
 887		if (max_dtr > card->sw_caps.hs_max_dtr)
 888			max_dtr = card->sw_caps.hs_max_dtr;
 889	} else if (max_dtr > card->csd.max_dtr) {
 890		max_dtr = card->csd.max_dtr;
 891	}
 892
 893	return max_dtr;
 894}
 895
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 896/*
 897 * Handle the detection and initialisation of a card.
 898 *
 899 * In the case of a resume, "oldcard" will contain the card
 900 * we're trying to reinitialise.
 901 */
 902static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
 903	struct mmc_card *oldcard)
 904{
 905	struct mmc_card *card;
 906	int err;
 907	u32 cid[4];
 908	u32 rocr = 0;
 
 909
 910	BUG_ON(!host);
 911	WARN_ON(!host->claimed);
 912
 913	err = mmc_sd_get_cid(host, ocr, cid, &rocr);
 914	if (err)
 915		return err;
 916
 917	if (oldcard) {
 918		if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0)
 
 
 919			return -ENOENT;
 
 920
 921		card = oldcard;
 922	} else {
 923		/*
 924		 * Allocate card structure.
 925		 */
 926		card = mmc_alloc_card(host, &sd_type);
 927		if (IS_ERR(card))
 928			return PTR_ERR(card);
 929
 930		card->ocr = ocr;
 931		card->type = MMC_TYPE_SD;
 932		memcpy(card->raw_cid, cid, sizeof(card->raw_cid));
 933	}
 934
 935	/*
 936	 * Call the optional HC's init_card function to handle quirks.
 937	 */
 938	if (host->ops->init_card)
 939		host->ops->init_card(host, card);
 940
 941	/*
 942	 * For native busses:  get card RCA and quit open drain mode.
 943	 */
 944	if (!mmc_host_is_spi(host)) {
 945		err = mmc_send_relative_addr(host, &card->rca);
 946		if (err)
 947			goto free_card;
 948	}
 949
 950	if (!oldcard) {
 951		err = mmc_sd_get_csd(host, card);
 952		if (err)
 953			goto free_card;
 954
 955		mmc_decode_cid(card);
 956	}
 957
 958	/*
 959	 * handling only for cards supporting DSR and hosts requesting
 960	 * DSR configuration
 961	 */
 962	if (card->csd.dsr_imp && host->dsr_req)
 963		mmc_set_dsr(host);
 964
 965	/*
 966	 * Select card, as all following commands rely on that.
 967	 */
 968	if (!mmc_host_is_spi(host)) {
 969		err = mmc_select_card(card);
 970		if (err)
 971			goto free_card;
 972	}
 973
 974	err = mmc_sd_setup_card(host, card, oldcard != NULL);
 975	if (err)
 976		goto free_card;
 977
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 978	/* Initialization sequence for UHS-I cards */
 979	if (rocr & SD_ROCR_S18A) {
 980		err = mmc_sd_init_uhs_card(card);
 981		if (err)
 982			goto free_card;
 983	} else {
 984		/*
 985		 * Attempt to change to high-speed (if supported)
 986		 */
 987		err = mmc_sd_switch_hs(card);
 988		if (err > 0)
 989			mmc_set_timing(card->host, MMC_TIMING_SD_HS);
 990		else if (err)
 991			goto free_card;
 992
 993		/*
 994		 * Set bus speed.
 995		 */
 996		mmc_set_clock(host, mmc_sd_get_max_clock(card));
 997
 
 
 
 
 
 
 
 998		/*
 999		 * Switch to wider bus (if supported).
1000		 */
1001		if ((host->caps & MMC_CAP_4_BIT_DATA) &&
1002			(card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {
1003			err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
1004			if (err)
1005				goto free_card;
1006
1007			mmc_set_bus_width(host, MMC_BUS_WIDTH_4);
1008		}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1009	}
1010
1011	host->card = card;
1012	return 0;
1013
1014free_card:
1015	if (!oldcard)
1016		mmc_remove_card(card);
1017
1018	return err;
1019}
1020
1021/*
1022 * Host is being removed. Free up the current card.
1023 */
1024static void mmc_sd_remove(struct mmc_host *host)
1025{
1026	BUG_ON(!host);
1027	BUG_ON(!host->card);
1028
1029	mmc_remove_card(host->card);
1030	host->card = NULL;
1031}
1032
1033/*
1034 * Card detection - card is alive.
1035 */
1036static int mmc_sd_alive(struct mmc_host *host)
1037{
1038	return mmc_send_status(host->card, NULL);
1039}
1040
1041/*
1042 * Card detection callback from host.
1043 */
1044static void mmc_sd_detect(struct mmc_host *host)
1045{
1046	int err;
1047
1048	BUG_ON(!host);
1049	BUG_ON(!host->card);
1050
1051	mmc_get_card(host->card);
1052
1053	/*
1054	 * Just check if our card has been removed.
1055	 */
1056	err = _mmc_detect_card_removed(host);
1057
1058	mmc_put_card(host->card);
1059
1060	if (err) {
1061		mmc_sd_remove(host);
1062
1063		mmc_claim_host(host);
1064		mmc_detach_bus(host);
1065		mmc_power_off(host);
1066		mmc_release_host(host);
1067	}
1068}
1069
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1070static int _mmc_sd_suspend(struct mmc_host *host)
1071{
 
1072	int err = 0;
1073
1074	BUG_ON(!host);
1075	BUG_ON(!host->card);
1076
1077	mmc_claim_host(host);
1078
1079	if (mmc_card_suspended(host->card))
1080		goto out;
1081
1082	if (!mmc_host_is_spi(host))
 
 
1083		err = mmc_deselect_cards(host);
1084
1085	if (!err) {
1086		mmc_power_off(host);
1087		mmc_card_set_suspended(host->card);
1088	}
1089
1090out:
1091	mmc_release_host(host);
1092	return err;
1093}
1094
1095/*
1096 * Callback for suspend
1097 */
1098static int mmc_sd_suspend(struct mmc_host *host)
1099{
1100	int err;
1101
1102	err = _mmc_sd_suspend(host);
1103	if (!err) {
1104		pm_runtime_disable(&host->card->dev);
1105		pm_runtime_set_suspended(&host->card->dev);
1106	}
1107
1108	return err;
1109}
1110
1111/*
1112 * This function tries to determine if the same card is still present
1113 * and, if so, restore all state to it.
1114 */
1115static int _mmc_sd_resume(struct mmc_host *host)
1116{
1117	int err = 0;
1118
1119	BUG_ON(!host);
1120	BUG_ON(!host->card);
1121
1122	mmc_claim_host(host);
1123
1124	if (!mmc_card_suspended(host->card))
1125		goto out;
1126
1127	mmc_power_up(host, host->card->ocr);
1128	err = mmc_sd_init_card(host, host->card->ocr, host->card);
1129	mmc_card_clr_suspended(host->card);
1130
1131out:
1132	mmc_release_host(host);
1133	return err;
1134}
1135
1136/*
1137 * Callback for resume
1138 */
1139static int mmc_sd_resume(struct mmc_host *host)
1140{
1141	pm_runtime_enable(&host->card->dev);
1142	return 0;
1143}
1144
1145/*
1146 * Callback for runtime_suspend.
1147 */
1148static int mmc_sd_runtime_suspend(struct mmc_host *host)
1149{
1150	int err;
1151
1152	if (!(host->caps & MMC_CAP_AGGRESSIVE_PM))
1153		return 0;
1154
1155	err = _mmc_sd_suspend(host);
1156	if (err)
1157		pr_err("%s: error %d doing aggressive suspend\n",
1158			mmc_hostname(host), err);
1159
1160	return err;
1161}
1162
1163/*
1164 * Callback for runtime_resume.
1165 */
1166static int mmc_sd_runtime_resume(struct mmc_host *host)
1167{
1168	int err;
1169
1170	err = _mmc_sd_resume(host);
1171	if (err && err != -ENOMEDIUM)
1172		pr_err("%s: error %d doing runtime resume\n",
1173			mmc_hostname(host), err);
1174
1175	return 0;
1176}
1177
1178static int mmc_sd_reset(struct mmc_host *host)
1179{
1180	mmc_power_cycle(host, host->card->ocr);
1181	return mmc_sd_init_card(host, host->card->ocr, host->card);
1182}
1183
1184static const struct mmc_bus_ops mmc_sd_ops = {
1185	.remove = mmc_sd_remove,
1186	.detect = mmc_sd_detect,
1187	.runtime_suspend = mmc_sd_runtime_suspend,
1188	.runtime_resume = mmc_sd_runtime_resume,
1189	.suspend = mmc_sd_suspend,
1190	.resume = mmc_sd_resume,
1191	.alive = mmc_sd_alive,
1192	.shutdown = mmc_sd_suspend,
1193	.reset = mmc_sd_reset,
 
 
1194};
1195
1196/*
1197 * Starting point for SD card init.
1198 */
1199int mmc_attach_sd(struct mmc_host *host)
1200{
1201	int err;
1202	u32 ocr, rocr;
1203
1204	BUG_ON(!host);
1205	WARN_ON(!host->claimed);
1206
1207	err = mmc_send_app_op_cond(host, 0, &ocr);
1208	if (err)
1209		return err;
1210
1211	mmc_attach_bus(host, &mmc_sd_ops);
1212	if (host->ocr_avail_sd)
1213		host->ocr_avail = host->ocr_avail_sd;
1214
1215	/*
1216	 * We need to get OCR a different way for SPI.
1217	 */
1218	if (mmc_host_is_spi(host)) {
1219		mmc_go_idle(host);
1220
1221		err = mmc_spi_read_ocr(host, 0, &ocr);
1222		if (err)
1223			goto err;
1224	}
 
 
 
 
 
 
1225
1226	rocr = mmc_select_voltage(host, ocr);
1227
1228	/*
1229	 * Can we support the voltage(s) of the card(s)?
1230	 */
1231	if (!rocr) {
1232		err = -EINVAL;
1233		goto err;
1234	}
1235
1236	/*
1237	 * Detect and init the card.
1238	 */
1239	err = mmc_sd_init_card(host, rocr, NULL);
1240	if (err)
1241		goto err;
1242
1243	mmc_release_host(host);
1244	err = mmc_add_card(host->card);
1245	if (err)
1246		goto remove_card;
1247
1248	mmc_claim_host(host);
1249	return 0;
1250
1251remove_card:
1252	mmc_remove_card(host->card);
1253	host->card = NULL;
1254	mmc_claim_host(host);
1255err:
1256	mmc_detach_bus(host);
1257
1258	pr_err("%s: error %d whilst initialising SD card\n",
1259		mmc_hostname(host), err);
1260
1261	return err;
1262}
v6.9.4
   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 *  linux/drivers/mmc/core/sd.c
   4 *
   5 *  Copyright (C) 2003-2004 Russell King, All Rights Reserved.
   6 *  SD support Copyright (C) 2004 Ian Molton, All Rights Reserved.
   7 *  Copyright (C) 2005-2007 Pierre Ossman, All Rights Reserved.
 
 
 
 
   8 */
   9
  10#include <linux/err.h>
  11#include <linux/sizes.h>
  12#include <linux/slab.h>
  13#include <linux/stat.h>
  14#include <linux/pm_runtime.h>
  15#include <linux/random.h>
  16#include <linux/scatterlist.h>
  17#include <linux/sysfs.h>
  18
  19#include <linux/mmc/host.h>
  20#include <linux/mmc/card.h>
  21#include <linux/mmc/mmc.h>
  22#include <linux/mmc/sd.h>
  23
  24#include "core.h"
  25#include "card.h"
  26#include "host.h"
  27#include "bus.h"
  28#include "mmc_ops.h"
  29#include "sd.h"
  30#include "sd_ops.h"
  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
  51static const unsigned int sd_au_size[] = {
  52	0,		SZ_16K / 512,		SZ_32K / 512,	SZ_64K / 512,
  53	SZ_128K / 512,	SZ_256K / 512,		SZ_512K / 512,	SZ_1M / 512,
  54	SZ_2M / 512,	SZ_4M / 512,		SZ_8M / 512,	(SZ_8M + SZ_4M) / 512,
  55	SZ_16M / 512,	(SZ_16M + SZ_8M) / 512,	SZ_32M / 512,	SZ_64M / 512,
  56};
  57
  58#define UNSTUFF_BITS(resp,start,size)					\
  59	({								\
  60		const int __size = size;				\
  61		const u32 __mask = (__size < 32 ? 1 << __size : 0) - 1;	\
  62		const int __off = 3 - ((start) / 32);			\
  63		const int __shft = (start) & 31;			\
  64		u32 __res;						\
  65									\
  66		__res = resp[__off] >> __shft;				\
  67		if (__size + __shft > 32)				\
  68			__res |= resp[__off-1] << ((32 - __shft) % 32);	\
  69		__res & __mask;						\
  70	})
  71
  72#define SD_POWEROFF_NOTIFY_TIMEOUT_MS 1000
  73#define SD_WRITE_EXTR_SINGLE_TIMEOUT_MS 1000
  74
  75struct sd_busy_data {
  76	struct mmc_card *card;
  77	u8 *reg_buf;
  78};
  79
  80/*
  81 * Given the decoded CSD structure, decode the raw CID to our CID structure.
  82 */
  83void mmc_decode_cid(struct mmc_card *card)
  84{
  85	u32 *resp = card->raw_cid;
  86
  87	/*
  88	 * Add the raw card ID (cid) data to the entropy pool. It doesn't
  89	 * matter that not all of it is unique, it's just bonus entropy.
  90	 */
  91	add_device_randomness(&card->raw_cid, sizeof(card->raw_cid));
  92
  93	/*
  94	 * SD doesn't currently have a version field so we will
  95	 * have to assume we can parse this.
  96	 */
  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.hwrev			= UNSTUFF_BITS(resp, 60, 4);
 105	card->cid.fwrev			= UNSTUFF_BITS(resp, 56, 4);
 106	card->cid.serial		= UNSTUFF_BITS(resp, 24, 32);
 107	card->cid.year			= UNSTUFF_BITS(resp, 12, 8);
 108	card->cid.month			= UNSTUFF_BITS(resp, 8, 4);
 109
 110	card->cid.year += 2000; /* SD cards year offset */
 111}
 112
 113/*
 114 * Given a 128-bit response, decode to our card CSD structure.
 115 */
 116static int mmc_decode_csd(struct mmc_card *card)
 117{
 118	struct mmc_csd *csd = &card->csd;
 119	unsigned int e, m, csd_struct;
 120	u32 *resp = card->raw_csd;
 121
 122	csd_struct = UNSTUFF_BITS(resp, 126, 2);
 123
 124	switch (csd_struct) {
 125	case 0:
 126		m = UNSTUFF_BITS(resp, 115, 4);
 127		e = UNSTUFF_BITS(resp, 112, 3);
 128		csd->taac_ns	 = (taac_exp[e] * taac_mant[m] + 9) / 10;
 129		csd->taac_clks	 = UNSTUFF_BITS(resp, 104, 8) * 100;
 130
 131		m = UNSTUFF_BITS(resp, 99, 4);
 132		e = UNSTUFF_BITS(resp, 96, 3);
 133		csd->max_dtr	  = tran_exp[e] * tran_mant[m];
 134		csd->cmdclass	  = UNSTUFF_BITS(resp, 84, 12);
 135
 136		e = UNSTUFF_BITS(resp, 47, 3);
 137		m = UNSTUFF_BITS(resp, 62, 12);
 138		csd->capacity	  = (1 + m) << (e + 2);
 139
 140		csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4);
 141		csd->read_partial = UNSTUFF_BITS(resp, 79, 1);
 142		csd->write_misalign = UNSTUFF_BITS(resp, 78, 1);
 143		csd->read_misalign = UNSTUFF_BITS(resp, 77, 1);
 144		csd->dsr_imp = UNSTUFF_BITS(resp, 76, 1);
 145		csd->r2w_factor = UNSTUFF_BITS(resp, 26, 3);
 146		csd->write_blkbits = UNSTUFF_BITS(resp, 22, 4);
 147		csd->write_partial = UNSTUFF_BITS(resp, 21, 1);
 148
 149		if (UNSTUFF_BITS(resp, 46, 1)) {
 150			csd->erase_size = 1;
 151		} else if (csd->write_blkbits >= 9) {
 152			csd->erase_size = UNSTUFF_BITS(resp, 39, 7) + 1;
 153			csd->erase_size <<= csd->write_blkbits - 9;
 154		}
 155
 156		if (UNSTUFF_BITS(resp, 13, 1))
 157			mmc_card_set_readonly(card);
 158		break;
 159	case 1:
 160		/*
 161		 * This is a block-addressed SDHC or SDXC card. Most
 162		 * interesting fields are unused and have fixed
 163		 * values. To avoid getting tripped by buggy cards,
 164		 * we assume those fixed values ourselves.
 165		 */
 166		mmc_card_set_blockaddr(card);
 167
 168		csd->taac_ns	 = 0; /* Unused */
 169		csd->taac_clks	 = 0; /* Unused */
 170
 171		m = UNSTUFF_BITS(resp, 99, 4);
 172		e = UNSTUFF_BITS(resp, 96, 3);
 173		csd->max_dtr	  = tran_exp[e] * tran_mant[m];
 174		csd->cmdclass	  = UNSTUFF_BITS(resp, 84, 12);
 175		csd->c_size	  = UNSTUFF_BITS(resp, 48, 22);
 176
 177		/* SDXC cards have a minimum C_SIZE of 0x00FFFF */
 178		if (csd->c_size >= 0xFFFF)
 179			mmc_card_set_ext_capacity(card);
 180
 181		m = UNSTUFF_BITS(resp, 48, 22);
 182		csd->capacity     = (1 + m) << 10;
 183
 184		csd->read_blkbits = 9;
 185		csd->read_partial = 0;
 186		csd->write_misalign = 0;
 187		csd->read_misalign = 0;
 188		csd->r2w_factor = 4; /* Unused */
 189		csd->write_blkbits = 9;
 190		csd->write_partial = 0;
 191		csd->erase_size = 1;
 192
 193		if (UNSTUFF_BITS(resp, 13, 1))
 194			mmc_card_set_readonly(card);
 195		break;
 196	default:
 197		pr_err("%s: unrecognised CSD structure version %d\n",
 198			mmc_hostname(card->host), csd_struct);
 199		return -EINVAL;
 200	}
 201
 202	card->erase_size = csd->erase_size;
 203
 204	return 0;
 205}
 206
 207/*
 208 * Given a 64-bit response, decode to our card SCR structure.
 209 */
 210static int mmc_decode_scr(struct mmc_card *card)
 211{
 212	struct sd_scr *scr = &card->scr;
 213	unsigned int scr_struct;
 214	u32 resp[4];
 215
 216	resp[3] = card->raw_scr[1];
 217	resp[2] = card->raw_scr[0];
 218
 219	scr_struct = UNSTUFF_BITS(resp, 60, 4);
 220	if (scr_struct != 0) {
 221		pr_err("%s: unrecognised SCR structure version %d\n",
 222			mmc_hostname(card->host), scr_struct);
 223		return -EINVAL;
 224	}
 225
 226	scr->sda_vsn = UNSTUFF_BITS(resp, 56, 4);
 227	scr->bus_widths = UNSTUFF_BITS(resp, 48, 4);
 228	if (scr->sda_vsn == SCR_SPEC_VER_2)
 229		/* Check if Physical Layer Spec v3.0 is supported */
 230		scr->sda_spec3 = UNSTUFF_BITS(resp, 47, 1);
 231
 232	if (scr->sda_spec3) {
 233		scr->sda_spec4 = UNSTUFF_BITS(resp, 42, 1);
 234		scr->sda_specx = UNSTUFF_BITS(resp, 38, 4);
 235	}
 236
 237	if (UNSTUFF_BITS(resp, 55, 1))
 238		card->erased_byte = 0xFF;
 239	else
 240		card->erased_byte = 0x0;
 241
 242	if (scr->sda_spec4)
 243		scr->cmds = UNSTUFF_BITS(resp, 32, 4);
 244	else if (scr->sda_spec3)
 245		scr->cmds = UNSTUFF_BITS(resp, 32, 2);
 246
 247	/* SD Spec says: any SD Card shall set at least bits 0 and 2 */
 248	if (!(scr->bus_widths & SD_SCR_BUS_WIDTH_1) ||
 249	    !(scr->bus_widths & SD_SCR_BUS_WIDTH_4)) {
 250		pr_err("%s: invalid bus width\n", mmc_hostname(card->host));
 251		return -EINVAL;
 252	}
 253
 254	return 0;
 255}
 256
 257/*
 258 * Fetch and process SD Status register.
 259 */
 260static int mmc_read_ssr(struct mmc_card *card)
 261{
 262	unsigned int au, es, et, eo;
 263	__be32 *raw_ssr;
 264	u32 resp[4] = {};
 265	u8 discard_support;
 266	int i;
 267
 268	if (!(card->csd.cmdclass & CCC_APP_SPEC)) {
 269		pr_warn("%s: card lacks mandatory SD Status function\n",
 270			mmc_hostname(card->host));
 271		return 0;
 272	}
 273
 274	raw_ssr = kmalloc(sizeof(card->raw_ssr), GFP_KERNEL);
 275	if (!raw_ssr)
 276		return -ENOMEM;
 277
 278	if (mmc_app_sd_status(card, raw_ssr)) {
 
 279		pr_warn("%s: problem reading SD Status register\n",
 280			mmc_hostname(card->host));
 281		kfree(raw_ssr);
 282		return 0;
 283	}
 284
 285	for (i = 0; i < 16; i++)
 286		card->raw_ssr[i] = be32_to_cpu(raw_ssr[i]);
 287
 288	kfree(raw_ssr);
 289
 290	/*
 291	 * UNSTUFF_BITS only works with four u32s so we have to offset the
 292	 * bitfield positions accordingly.
 293	 */
 294	au = UNSTUFF_BITS(card->raw_ssr, 428 - 384, 4);
 295	if (au) {
 296		if (au <= 9 || card->scr.sda_spec3) {
 297			card->ssr.au = sd_au_size[au];
 298			es = UNSTUFF_BITS(card->raw_ssr, 408 - 384, 16);
 299			et = UNSTUFF_BITS(card->raw_ssr, 402 - 384, 6);
 300			if (es && et) {
 301				eo = UNSTUFF_BITS(card->raw_ssr, 400 - 384, 2);
 302				card->ssr.erase_timeout = (et * 1000) / es;
 303				card->ssr.erase_offset = eo * 1000;
 304			}
 305		} else {
 306			pr_warn("%s: SD Status: Invalid Allocation Unit size\n",
 307				mmc_hostname(card->host));
 308		}
 309	}
 310
 311	/*
 312	 * starting SD5.1 discard is supported if DISCARD_SUPPORT (b313) is set
 313	 */
 314	resp[3] = card->raw_ssr[6];
 315	discard_support = UNSTUFF_BITS(resp, 313 - 288, 1);
 316	card->erase_arg = (card->scr.sda_specx && discard_support) ?
 317			    SD_DISCARD_ARG : SD_ERASE_ARG;
 318
 319	return 0;
 320}
 321
 322/*
 323 * Fetches and decodes switch information
 324 */
 325static int mmc_read_switch(struct mmc_card *card)
 326{
 327	int err;
 328	u8 *status;
 329
 330	if (card->scr.sda_vsn < SCR_SPEC_VER_1)
 331		return 0;
 332
 333	if (!(card->csd.cmdclass & CCC_SWITCH)) {
 334		pr_warn("%s: card lacks mandatory switch function, performance might suffer\n",
 335			mmc_hostname(card->host));
 336		return 0;
 337	}
 338
 
 
 339	status = kmalloc(64, GFP_KERNEL);
 340	if (!status)
 
 
 
 341		return -ENOMEM;
 
 342
 343	/*
 344	 * Find out the card's support bits with a mode 0 operation.
 345	 * The argument does not matter, as the support bits do not
 346	 * change with the arguments.
 347	 */
 348	err = mmc_sd_switch(card, 0, 0, 0, status);
 349	if (err) {
 350		/*
 351		 * If the host or the card can't do the switch,
 352		 * fail more gracefully.
 353		 */
 354		if (err != -EINVAL && err != -ENOSYS && err != -EFAULT)
 355			goto out;
 356
 357		pr_warn("%s: problem reading Bus Speed modes\n",
 358			mmc_hostname(card->host));
 359		err = 0;
 360
 361		goto out;
 362	}
 363
 364	if (status[13] & SD_MODE_HIGH_SPEED)
 365		card->sw_caps.hs_max_dtr = HIGH_SPEED_MAX_DTR;
 366
 367	if (card->scr.sda_spec3) {
 368		card->sw_caps.sd3_bus_mode = status[13];
 369		/* Driver Strengths supported by the card */
 370		card->sw_caps.sd3_drv_type = status[9];
 371		card->sw_caps.sd3_curr_limit = status[7] | status[6] << 8;
 372	}
 373
 374out:
 375	kfree(status);
 376
 377	return err;
 378}
 379
 380/*
 381 * Test if the card supports high-speed mode and, if so, switch to it.
 382 */
 383int mmc_sd_switch_hs(struct mmc_card *card)
 384{
 385	int err;
 386	u8 *status;
 387
 388	if (card->scr.sda_vsn < SCR_SPEC_VER_1)
 389		return 0;
 390
 391	if (!(card->csd.cmdclass & CCC_SWITCH))
 392		return 0;
 393
 394	if (!(card->host->caps & MMC_CAP_SD_HIGHSPEED))
 395		return 0;
 396
 397	if (card->sw_caps.hs_max_dtr == 0)
 398		return 0;
 399
 400	status = kmalloc(64, GFP_KERNEL);
 401	if (!status)
 
 
 402		return -ENOMEM;
 
 403
 404	err = mmc_sd_switch(card, 1, 0, HIGH_SPEED_BUS_SPEED, status);
 405	if (err)
 406		goto out;
 407
 408	if ((status[16] & 0xF) != HIGH_SPEED_BUS_SPEED) {
 409		pr_warn("%s: Problem switching card into high-speed mode!\n",
 410			mmc_hostname(card->host));
 411		err = 0;
 412	} else {
 413		err = 1;
 414	}
 415
 416out:
 417	kfree(status);
 418
 419	return err;
 420}
 421
 422static int sd_select_driver_type(struct mmc_card *card, u8 *status)
 423{
 424	int card_drv_type, drive_strength, drv_type;
 425	int err;
 426
 427	card->drive_strength = 0;
 428
 429	card_drv_type = card->sw_caps.sd3_drv_type | SD_DRIVER_TYPE_B;
 430
 431	drive_strength = mmc_select_drive_strength(card,
 432						   card->sw_caps.uhs_max_dtr,
 433						   card_drv_type, &drv_type);
 434
 435	if (drive_strength) {
 436		err = mmc_sd_switch(card, 1, 2, drive_strength, status);
 437		if (err)
 438			return err;
 439		if ((status[15] & 0xF) != drive_strength) {
 440			pr_warn("%s: Problem setting drive strength!\n",
 441				mmc_hostname(card->host));
 442			return 0;
 443		}
 444		card->drive_strength = drive_strength;
 445	}
 446
 447	if (drv_type)
 448		mmc_set_driver_type(card->host, drv_type);
 449
 450	return 0;
 451}
 452
 453static void sd_update_bus_speed_mode(struct mmc_card *card)
 454{
 455	/*
 456	 * If the host doesn't support any of the UHS-I modes, fallback on
 457	 * default speed.
 458	 */
 459	if (!mmc_host_uhs(card->host)) {
 460		card->sd_bus_speed = 0;
 461		return;
 462	}
 463
 464	if ((card->host->caps & MMC_CAP_UHS_SDR104) &&
 465	    (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR104)) {
 466			card->sd_bus_speed = UHS_SDR104_BUS_SPEED;
 467	} else if ((card->host->caps & MMC_CAP_UHS_DDR50) &&
 468		   (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_DDR50)) {
 469			card->sd_bus_speed = UHS_DDR50_BUS_SPEED;
 470	} else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
 471		    MMC_CAP_UHS_SDR50)) && (card->sw_caps.sd3_bus_mode &
 472		    SD_MODE_UHS_SDR50)) {
 473			card->sd_bus_speed = UHS_SDR50_BUS_SPEED;
 474	} else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
 475		    MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25)) &&
 476		   (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR25)) {
 477			card->sd_bus_speed = UHS_SDR25_BUS_SPEED;
 478	} else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
 479		    MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25 |
 480		    MMC_CAP_UHS_SDR12)) && (card->sw_caps.sd3_bus_mode &
 481		    SD_MODE_UHS_SDR12)) {
 482			card->sd_bus_speed = UHS_SDR12_BUS_SPEED;
 483	}
 484}
 485
 486static int sd_set_bus_speed_mode(struct mmc_card *card, u8 *status)
 487{
 488	int err;
 489	unsigned int timing = 0;
 490
 491	switch (card->sd_bus_speed) {
 492	case UHS_SDR104_BUS_SPEED:
 493		timing = MMC_TIMING_UHS_SDR104;
 494		card->sw_caps.uhs_max_dtr = UHS_SDR104_MAX_DTR;
 495		break;
 496	case UHS_DDR50_BUS_SPEED:
 497		timing = MMC_TIMING_UHS_DDR50;
 498		card->sw_caps.uhs_max_dtr = UHS_DDR50_MAX_DTR;
 499		break;
 500	case UHS_SDR50_BUS_SPEED:
 501		timing = MMC_TIMING_UHS_SDR50;
 502		card->sw_caps.uhs_max_dtr = UHS_SDR50_MAX_DTR;
 503		break;
 504	case UHS_SDR25_BUS_SPEED:
 505		timing = MMC_TIMING_UHS_SDR25;
 506		card->sw_caps.uhs_max_dtr = UHS_SDR25_MAX_DTR;
 507		break;
 508	case UHS_SDR12_BUS_SPEED:
 509		timing = MMC_TIMING_UHS_SDR12;
 510		card->sw_caps.uhs_max_dtr = UHS_SDR12_MAX_DTR;
 511		break;
 512	default:
 513		return 0;
 514	}
 515
 516	err = mmc_sd_switch(card, 1, 0, card->sd_bus_speed, status);
 517	if (err)
 518		return err;
 519
 520	if ((status[16] & 0xF) != card->sd_bus_speed)
 521		pr_warn("%s: Problem setting bus speed mode!\n",
 522			mmc_hostname(card->host));
 523	else {
 524		mmc_set_timing(card->host, timing);
 525		mmc_set_clock(card->host, card->sw_caps.uhs_max_dtr);
 526	}
 527
 528	return 0;
 529}
 530
 531/* Get host's max current setting at its current voltage */
 532static u32 sd_get_host_max_current(struct mmc_host *host)
 533{
 534	u32 voltage, max_current;
 535
 536	voltage = 1 << host->ios.vdd;
 537	switch (voltage) {
 538	case MMC_VDD_165_195:
 539		max_current = host->max_current_180;
 540		break;
 541	case MMC_VDD_29_30:
 542	case MMC_VDD_30_31:
 543		max_current = host->max_current_300;
 544		break;
 545	case MMC_VDD_32_33:
 546	case MMC_VDD_33_34:
 547		max_current = host->max_current_330;
 548		break;
 549	default:
 550		max_current = 0;
 551	}
 552
 553	return max_current;
 554}
 555
 556static int sd_set_current_limit(struct mmc_card *card, u8 *status)
 557{
 558	int current_limit = SD_SET_CURRENT_NO_CHANGE;
 559	int err;
 560	u32 max_current;
 561
 562	/*
 563	 * Current limit switch is only defined for SDR50, SDR104, and DDR50
 564	 * bus speed modes. For other bus speed modes, we do not change the
 565	 * current limit.
 566	 */
 567	if ((card->sd_bus_speed != UHS_SDR50_BUS_SPEED) &&
 568	    (card->sd_bus_speed != UHS_SDR104_BUS_SPEED) &&
 569	    (card->sd_bus_speed != UHS_DDR50_BUS_SPEED))
 570		return 0;
 571
 572	/*
 573	 * Host has different current capabilities when operating at
 574	 * different voltages, so find out its max current first.
 575	 */
 576	max_current = sd_get_host_max_current(card->host);
 577
 578	/*
 579	 * We only check host's capability here, if we set a limit that is
 580	 * higher than the card's maximum current, the card will be using its
 581	 * maximum current, e.g. if the card's maximum current is 300ma, and
 582	 * when we set current limit to 200ma, the card will draw 200ma, and
 583	 * when we set current limit to 400/600/800ma, the card will draw its
 584	 * maximum 300ma from the host.
 585	 *
 586	 * The above is incorrect: if we try to set a current limit that is
 587	 * not supported by the card, the card can rightfully error out the
 588	 * attempt, and remain at the default current limit.  This results
 589	 * in a 300mA card being limited to 200mA even though the host
 590	 * supports 800mA. Failures seen with SanDisk 8GB UHS cards with
 591	 * an iMX6 host. --rmk
 592	 */
 593	if (max_current >= 800 &&
 594	    card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_800)
 595		current_limit = SD_SET_CURRENT_LIMIT_800;
 596	else if (max_current >= 600 &&
 597		 card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_600)
 598		current_limit = SD_SET_CURRENT_LIMIT_600;
 599	else if (max_current >= 400 &&
 600		 card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_400)
 601		current_limit = SD_SET_CURRENT_LIMIT_400;
 602	else if (max_current >= 200 &&
 603		 card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_200)
 604		current_limit = SD_SET_CURRENT_LIMIT_200;
 605
 606	if (current_limit != SD_SET_CURRENT_NO_CHANGE) {
 607		err = mmc_sd_switch(card, 1, 3, current_limit, status);
 608		if (err)
 609			return err;
 610
 611		if (((status[15] >> 4) & 0x0F) != current_limit)
 612			pr_warn("%s: Problem setting current limit!\n",
 613				mmc_hostname(card->host));
 614
 615	}
 616
 617	return 0;
 618}
 619
 620/*
 621 * UHS-I specific initialization procedure
 622 */
 623static int mmc_sd_init_uhs_card(struct mmc_card *card)
 624{
 625	int err;
 626	u8 *status;
 627
 
 
 
 628	if (!(card->csd.cmdclass & CCC_SWITCH))
 629		return 0;
 630
 631	status = kmalloc(64, GFP_KERNEL);
 632	if (!status)
 
 
 633		return -ENOMEM;
 
 634
 635	/* Set 4-bit bus width */
 636	err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
 637	if (err)
 638		goto out;
 
 
 639
 640	mmc_set_bus_width(card->host, MMC_BUS_WIDTH_4);
 
 641
 642	/*
 643	 * Select the bus speed mode depending on host
 644	 * and card capability.
 645	 */
 646	sd_update_bus_speed_mode(card);
 647
 648	/* Set the driver strength for the card */
 649	err = sd_select_driver_type(card, status);
 650	if (err)
 651		goto out;
 652
 653	/* Set current limit for the card */
 654	err = sd_set_current_limit(card, status);
 655	if (err)
 656		goto out;
 657
 658	/* Set bus speed mode of the card */
 659	err = sd_set_bus_speed_mode(card, status);
 660	if (err)
 661		goto out;
 662
 663	/*
 664	 * SPI mode doesn't define CMD19 and tuning is only valid for SDR50 and
 665	 * SDR104 mode SD-cards. Note that tuning is mandatory for SDR104.
 666	 */
 667	if (!mmc_host_is_spi(card->host) &&
 668		(card->host->ios.timing == MMC_TIMING_UHS_SDR50 ||
 669		 card->host->ios.timing == MMC_TIMING_UHS_DDR50 ||
 670		 card->host->ios.timing == MMC_TIMING_UHS_SDR104)) {
 671		err = mmc_execute_tuning(card);
 672
 673		/*
 674		 * As SD Specifications Part1 Physical Layer Specification
 675		 * Version 3.01 says, CMD19 tuning is available for unlocked
 676		 * cards in transfer state of 1.8V signaling mode. The small
 677		 * difference between v3.00 and 3.01 spec means that CMD19
 678		 * tuning is also available for DDR50 mode.
 679		 */
 680		if (err && card->host->ios.timing == MMC_TIMING_UHS_DDR50) {
 681			pr_warn("%s: ddr50 tuning failed\n",
 682				mmc_hostname(card->host));
 683			err = 0;
 684		}
 685	}
 686
 687out:
 688	kfree(status);
 689
 690	return err;
 691}
 692
 693MMC_DEV_ATTR(cid, "%08x%08x%08x%08x\n", card->raw_cid[0], card->raw_cid[1],
 694	card->raw_cid[2], card->raw_cid[3]);
 695MMC_DEV_ATTR(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1],
 696	card->raw_csd[2], card->raw_csd[3]);
 697MMC_DEV_ATTR(scr, "%08x%08x\n", card->raw_scr[0], card->raw_scr[1]);
 698MMC_DEV_ATTR(ssr,
 699	"%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x\n",
 700		card->raw_ssr[0], card->raw_ssr[1], card->raw_ssr[2],
 701		card->raw_ssr[3], card->raw_ssr[4], card->raw_ssr[5],
 702		card->raw_ssr[6], card->raw_ssr[7], card->raw_ssr[8],
 703		card->raw_ssr[9], card->raw_ssr[10], card->raw_ssr[11],
 704		card->raw_ssr[12], card->raw_ssr[13], card->raw_ssr[14],
 705		card->raw_ssr[15]);
 706MMC_DEV_ATTR(date, "%02d/%04d\n", card->cid.month, card->cid.year);
 707MMC_DEV_ATTR(erase_size, "%u\n", card->erase_size << 9);
 708MMC_DEV_ATTR(preferred_erase_size, "%u\n", card->pref_erase << 9);
 709MMC_DEV_ATTR(fwrev, "0x%x\n", card->cid.fwrev);
 710MMC_DEV_ATTR(hwrev, "0x%x\n", card->cid.hwrev);
 711MMC_DEV_ATTR(manfid, "0x%06x\n", card->cid.manfid);
 712MMC_DEV_ATTR(name, "%s\n", card->cid.prod_name);
 713MMC_DEV_ATTR(oemid, "0x%04x\n", card->cid.oemid);
 714MMC_DEV_ATTR(serial, "0x%08x\n", card->cid.serial);
 715MMC_DEV_ATTR(ocr, "0x%08x\n", card->ocr);
 716MMC_DEV_ATTR(rca, "0x%04x\n", card->rca);
 717
 718
 719static ssize_t mmc_dsr_show(struct device *dev, struct device_attribute *attr,
 720			    char *buf)
 721{
 722	struct mmc_card *card = mmc_dev_to_card(dev);
 723	struct mmc_host *host = card->host;
 724
 725	if (card->csd.dsr_imp && host->dsr_req)
 726		return sysfs_emit(buf, "0x%x\n", host->dsr);
 727	/* return default DSR value */
 728	return sysfs_emit(buf, "0x%x\n", 0x404);
 729}
 730
 731static DEVICE_ATTR(dsr, S_IRUGO, mmc_dsr_show, NULL);
 732
 733MMC_DEV_ATTR(vendor, "0x%04x\n", card->cis.vendor);
 734MMC_DEV_ATTR(device, "0x%04x\n", card->cis.device);
 735MMC_DEV_ATTR(revision, "%u.%u\n", card->major_rev, card->minor_rev);
 736
 737#define sdio_info_attr(num)									\
 738static ssize_t info##num##_show(struct device *dev, struct device_attribute *attr, char *buf)	\
 739{												\
 740	struct mmc_card *card = mmc_dev_to_card(dev);						\
 741												\
 742	if (num > card->num_info)								\
 743		return -ENODATA;								\
 744	if (!card->info[num - 1][0])								\
 745		return 0;									\
 746	return sysfs_emit(buf, "%s\n", card->info[num - 1]);					\
 747}												\
 748static DEVICE_ATTR_RO(info##num)
 749
 750sdio_info_attr(1);
 751sdio_info_attr(2);
 752sdio_info_attr(3);
 753sdio_info_attr(4);
 754
 755static struct attribute *sd_std_attrs[] = {
 756	&dev_attr_vendor.attr,
 757	&dev_attr_device.attr,
 758	&dev_attr_revision.attr,
 759	&dev_attr_info1.attr,
 760	&dev_attr_info2.attr,
 761	&dev_attr_info3.attr,
 762	&dev_attr_info4.attr,
 763	&dev_attr_cid.attr,
 764	&dev_attr_csd.attr,
 765	&dev_attr_scr.attr,
 766	&dev_attr_ssr.attr,
 767	&dev_attr_date.attr,
 768	&dev_attr_erase_size.attr,
 769	&dev_attr_preferred_erase_size.attr,
 770	&dev_attr_fwrev.attr,
 771	&dev_attr_hwrev.attr,
 772	&dev_attr_manfid.attr,
 773	&dev_attr_name.attr,
 774	&dev_attr_oemid.attr,
 775	&dev_attr_serial.attr,
 776	&dev_attr_ocr.attr,
 777	&dev_attr_rca.attr,
 778	&dev_attr_dsr.attr,
 779	NULL,
 780};
 
 781
 782static umode_t sd_std_is_visible(struct kobject *kobj, struct attribute *attr,
 783				 int index)
 784{
 785	struct device *dev = kobj_to_dev(kobj);
 786	struct mmc_card *card = mmc_dev_to_card(dev);
 787
 788	/* CIS vendor and device ids, revision and info string are available only for Combo cards */
 789	if ((attr == &dev_attr_vendor.attr ||
 790	     attr == &dev_attr_device.attr ||
 791	     attr == &dev_attr_revision.attr ||
 792	     attr == &dev_attr_info1.attr ||
 793	     attr == &dev_attr_info2.attr ||
 794	     attr == &dev_attr_info3.attr ||
 795	     attr == &dev_attr_info4.attr
 796	    ) &&!mmc_card_sd_combo(card))
 797		return 0;
 798
 799	return attr->mode;
 800}
 801
 802static const struct attribute_group sd_std_group = {
 803	.attrs = sd_std_attrs,
 804	.is_visible = sd_std_is_visible,
 805};
 806__ATTRIBUTE_GROUPS(sd_std);
 807
 808const struct device_type sd_type = {
 809	.groups = sd_std_groups,
 810};
 811
 812/*
 813 * Fetch CID from card.
 814 */
 815int mmc_sd_get_cid(struct mmc_host *host, u32 ocr, u32 *cid, u32 *rocr)
 816{
 817	int err;
 818	u32 max_current;
 819	int retries = 10;
 820	u32 pocr = ocr;
 821
 822try_again:
 823	if (!retries) {
 824		ocr &= ~SD_OCR_S18R;
 825		pr_warn("%s: Skipping voltage switch\n", mmc_hostname(host));
 826	}
 827
 828	/*
 829	 * Since we're changing the OCR value, we seem to
 830	 * need to tell some cards to go back to the idle
 831	 * state.  We wait 1ms to give cards time to
 832	 * respond.
 833	 */
 834	mmc_go_idle(host);
 835
 836	/*
 837	 * If SD_SEND_IF_COND indicates an SD 2.0
 838	 * compliant card and we should set bit 30
 839	 * of the ocr to indicate that we can handle
 840	 * block-addressed SDHC cards.
 841	 */
 842	err = mmc_send_if_cond(host, ocr);
 843	if (!err)
 844		ocr |= SD_OCR_CCS;
 845
 846	/*
 847	 * If the host supports one of UHS-I modes, request the card
 848	 * to switch to 1.8V signaling level. If the card has failed
 849	 * repeatedly to switch however, skip this.
 850	 */
 851	if (retries && mmc_host_uhs(host))
 852		ocr |= SD_OCR_S18R;
 853
 854	/*
 855	 * If the host can supply more than 150mA at current voltage,
 856	 * XPC should be set to 1.
 857	 */
 858	max_current = sd_get_host_max_current(host);
 859	if (max_current > 150)
 860		ocr |= SD_OCR_XPC;
 861
 862	err = mmc_send_app_op_cond(host, ocr, rocr);
 863	if (err)
 864		return err;
 865
 866	/*
 867	 * In case the S18A bit is set in the response, let's start the signal
 868	 * voltage switch procedure. SPI mode doesn't support CMD11.
 869	 * Note that, according to the spec, the S18A bit is not valid unless
 870	 * the CCS bit is set as well. We deliberately deviate from the spec in
 871	 * regards to this, which allows UHS-I to be supported for SDSC cards.
 872	 */
 873	if (!mmc_host_is_spi(host) && (ocr & SD_OCR_S18R) &&
 874	    rocr && (*rocr & SD_ROCR_S18A)) {
 875		err = mmc_set_uhs_voltage(host, pocr);
 876		if (err == -EAGAIN) {
 877			retries--;
 878			goto try_again;
 879		} else if (err) {
 880			retries = 0;
 881			goto try_again;
 882		}
 883	}
 884
 885	err = mmc_send_cid(host, cid);
 
 
 
 
 886	return err;
 887}
 888
 889int mmc_sd_get_csd(struct mmc_card *card)
 890{
 891	int err;
 892
 893	/*
 894	 * Fetch CSD from card.
 895	 */
 896	err = mmc_send_csd(card, card->raw_csd);
 897	if (err)
 898		return err;
 899
 900	err = mmc_decode_csd(card);
 901	if (err)
 902		return err;
 903
 904	return 0;
 905}
 906
 907static int mmc_sd_get_ro(struct mmc_host *host)
 908{
 909	int ro;
 910
 911	/*
 912	 * Some systems don't feature a write-protect pin and don't need one.
 913	 * E.g. because they only have micro-SD card slot. For those systems
 914	 * assume that the SD card is always read-write.
 915	 */
 916	if (host->caps2 & MMC_CAP2_NO_WRITE_PROTECT)
 917		return 0;
 918
 919	if (!host->ops->get_ro)
 920		return -1;
 921
 922	ro = host->ops->get_ro(host);
 923
 924	return ro;
 925}
 926
 927int mmc_sd_setup_card(struct mmc_host *host, struct mmc_card *card,
 928	bool reinit)
 929{
 930	int err;
 931
 932	if (!reinit) {
 933		/*
 934		 * Fetch SCR from card.
 935		 */
 936		err = mmc_app_send_scr(card);
 937		if (err)
 938			return err;
 939
 940		err = mmc_decode_scr(card);
 941		if (err)
 942			return err;
 943
 944		/*
 945		 * Fetch and process SD Status register.
 946		 */
 947		err = mmc_read_ssr(card);
 948		if (err)
 949			return err;
 950
 951		/* Erase init depends on CSD and SSR */
 952		mmc_init_erase(card);
 
 
 
 
 
 
 
 953	}
 954
 955	/*
 956	 * Fetch switch information from card. Note, sd3_bus_mode can change if
 957	 * voltage switch outcome changes, so do this always.
 958	 */
 959	err = mmc_read_switch(card);
 960	if (err)
 961		return err;
 962
 963	/*
 964	 * For SPI, enable CRC as appropriate.
 965	 * This CRC enable is located AFTER the reading of the
 966	 * card registers because some SDHC cards are not able
 967	 * to provide valid CRCs for non-512-byte blocks.
 968	 */
 969	if (mmc_host_is_spi(host)) {
 970		err = mmc_spi_set_crc(host, use_spi_crc);
 971		if (err)
 972			return err;
 973	}
 974
 975	/*
 976	 * Check if read-only switch is active.
 977	 */
 978	if (!reinit) {
 979		int ro = mmc_sd_get_ro(host);
 980
 981		if (ro < 0) {
 982			pr_warn("%s: host does not support reading read-only switch, assuming write-enable\n",
 983				mmc_hostname(host));
 984		} else if (ro > 0) {
 985			mmc_card_set_readonly(card);
 986		}
 987	}
 988
 989	return 0;
 990}
 991
 992unsigned mmc_sd_get_max_clock(struct mmc_card *card)
 993{
 994	unsigned max_dtr = (unsigned int)-1;
 995
 996	if (mmc_card_hs(card)) {
 997		if (max_dtr > card->sw_caps.hs_max_dtr)
 998			max_dtr = card->sw_caps.hs_max_dtr;
 999	} else if (max_dtr > card->csd.max_dtr) {
1000		max_dtr = card->csd.max_dtr;
1001	}
1002
1003	return max_dtr;
1004}
1005
1006static bool mmc_sd_card_using_v18(struct mmc_card *card)
1007{
1008	/*
1009	 * According to the SD spec., the Bus Speed Mode (function group 1) bits
1010	 * 2 to 4 are zero if the card is initialized at 3.3V signal level. Thus
1011	 * they can be used to determine if the card has already switched to
1012	 * 1.8V signaling.
1013	 */
1014	return card->sw_caps.sd3_bus_mode &
1015	       (SD_MODE_UHS_SDR50 | SD_MODE_UHS_SDR104 | SD_MODE_UHS_DDR50);
1016}
1017
1018static int sd_write_ext_reg(struct mmc_card *card, u8 fno, u8 page, u16 offset,
1019			    u8 reg_data)
1020{
1021	struct mmc_host *host = card->host;
1022	struct mmc_request mrq = {};
1023	struct mmc_command cmd = {};
1024	struct mmc_data data = {};
1025	struct scatterlist sg;
1026	u8 *reg_buf;
1027
1028	reg_buf = kzalloc(512, GFP_KERNEL);
1029	if (!reg_buf)
1030		return -ENOMEM;
1031
1032	mrq.cmd = &cmd;
1033	mrq.data = &data;
1034
1035	/*
1036	 * Arguments of CMD49:
1037	 * [31:31] MIO (0 = memory).
1038	 * [30:27] FNO (function number).
1039	 * [26:26] MW - mask write mode (0 = disable).
1040	 * [25:18] page number.
1041	 * [17:9] offset address.
1042	 * [8:0] length (0 = 1 byte).
1043	 */
1044	cmd.arg = fno << 27 | page << 18 | offset << 9;
1045
1046	/* The first byte in the buffer is the data to be written. */
1047	reg_buf[0] = reg_data;
1048
1049	data.flags = MMC_DATA_WRITE;
1050	data.blksz = 512;
1051	data.blocks = 1;
1052	data.sg = &sg;
1053	data.sg_len = 1;
1054	sg_init_one(&sg, reg_buf, 512);
1055
1056	cmd.opcode = SD_WRITE_EXTR_SINGLE;
1057	cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC;
1058
1059	mmc_set_data_timeout(&data, card);
1060	mmc_wait_for_req(host, &mrq);
1061
1062	kfree(reg_buf);
1063
1064	/*
1065	 * Note that, the SD card is allowed to signal busy on DAT0 up to 1s
1066	 * after the CMD49. Although, let's leave this to be managed by the
1067	 * caller.
1068	 */
1069
1070	if (cmd.error)
1071		return cmd.error;
1072	if (data.error)
1073		return data.error;
1074
1075	return 0;
1076}
1077
1078static int sd_read_ext_reg(struct mmc_card *card, u8 fno, u8 page,
1079			   u16 offset, u16 len, u8 *reg_buf)
1080{
1081	u32 cmd_args;
1082
1083	/*
1084	 * Command arguments of CMD48:
1085	 * [31:31] MIO (0 = memory).
1086	 * [30:27] FNO (function number).
1087	 * [26:26] reserved (0).
1088	 * [25:18] page number.
1089	 * [17:9] offset address.
1090	 * [8:0] length (0 = 1 byte, 1ff = 512 bytes).
1091	 */
1092	cmd_args = fno << 27 | page << 18 | offset << 9 | (len -1);
1093
1094	return mmc_send_adtc_data(card, card->host, SD_READ_EXTR_SINGLE,
1095				  cmd_args, reg_buf, 512);
1096}
1097
1098static int sd_parse_ext_reg_power(struct mmc_card *card, u8 fno, u8 page,
1099				  u16 offset)
1100{
1101	int err;
1102	u8 *reg_buf;
1103
1104	reg_buf = kzalloc(512, GFP_KERNEL);
1105	if (!reg_buf)
1106		return -ENOMEM;
1107
1108	/* Read the extension register for power management function. */
1109	err = sd_read_ext_reg(card, fno, page, offset, 512, reg_buf);
1110	if (err) {
1111		pr_warn("%s: error %d reading PM func of ext reg\n",
1112			mmc_hostname(card->host), err);
1113		goto out;
1114	}
1115
1116	/* PM revision consists of 4 bits. */
1117	card->ext_power.rev = reg_buf[0] & 0xf;
1118
1119	/* Power Off Notification support at bit 4. */
1120	if (reg_buf[1] & BIT(4))
1121		card->ext_power.feature_support |= SD_EXT_POWER_OFF_NOTIFY;
1122
1123	/* Power Sustenance support at bit 5. */
1124	if (reg_buf[1] & BIT(5))
1125		card->ext_power.feature_support |= SD_EXT_POWER_SUSTENANCE;
1126
1127	/* Power Down Mode support at bit 6. */
1128	if (reg_buf[1] & BIT(6))
1129		card->ext_power.feature_support |= SD_EXT_POWER_DOWN_MODE;
1130
1131	card->ext_power.fno = fno;
1132	card->ext_power.page = page;
1133	card->ext_power.offset = offset;
1134
1135out:
1136	kfree(reg_buf);
1137	return err;
1138}
1139
1140static int sd_parse_ext_reg_perf(struct mmc_card *card, u8 fno, u8 page,
1141				 u16 offset)
1142{
1143	int err;
1144	u8 *reg_buf;
1145
1146	reg_buf = kzalloc(512, GFP_KERNEL);
1147	if (!reg_buf)
1148		return -ENOMEM;
1149
1150	err = sd_read_ext_reg(card, fno, page, offset, 512, reg_buf);
1151	if (err) {
1152		pr_warn("%s: error %d reading PERF func of ext reg\n",
1153			mmc_hostname(card->host), err);
1154		goto out;
1155	}
1156
1157	/* PERF revision. */
1158	card->ext_perf.rev = reg_buf[0];
1159
1160	/* FX_EVENT support at bit 0. */
1161	if (reg_buf[1] & BIT(0))
1162		card->ext_perf.feature_support |= SD_EXT_PERF_FX_EVENT;
1163
1164	/* Card initiated self-maintenance support at bit 0. */
1165	if (reg_buf[2] & BIT(0))
1166		card->ext_perf.feature_support |= SD_EXT_PERF_CARD_MAINT;
1167
1168	/* Host initiated self-maintenance support at bit 1. */
1169	if (reg_buf[2] & BIT(1))
1170		card->ext_perf.feature_support |= SD_EXT_PERF_HOST_MAINT;
1171
1172	/* Cache support at bit 0. */
1173	if ((reg_buf[4] & BIT(0)) && !mmc_card_broken_sd_cache(card))
1174		card->ext_perf.feature_support |= SD_EXT_PERF_CACHE;
1175
1176	/* Command queue support indicated via queue depth bits (0 to 4). */
1177	if (reg_buf[6] & 0x1f)
1178		card->ext_perf.feature_support |= SD_EXT_PERF_CMD_QUEUE;
1179
1180	card->ext_perf.fno = fno;
1181	card->ext_perf.page = page;
1182	card->ext_perf.offset = offset;
1183
1184out:
1185	kfree(reg_buf);
1186	return err;
1187}
1188
1189static int sd_parse_ext_reg(struct mmc_card *card, u8 *gen_info_buf,
1190			    u16 *next_ext_addr)
1191{
1192	u8 num_regs, fno, page;
1193	u16 sfc, offset, ext = *next_ext_addr;
1194	u32 reg_addr;
1195
1196	/*
1197	 * Parse only one register set per extension, as that is sufficient to
1198	 * support the standard functions. This means another 48 bytes in the
1199	 * buffer must be available.
1200	 */
1201	if (ext + 48 > 512)
1202		return -EFAULT;
1203
1204	/* Standard Function Code */
1205	memcpy(&sfc, &gen_info_buf[ext], 2);
1206
1207	/* Address to the next extension. */
1208	memcpy(next_ext_addr, &gen_info_buf[ext + 40], 2);
1209
1210	/* Number of registers for this extension. */
1211	num_regs = gen_info_buf[ext + 42];
1212
1213	/* We support only one register per extension. */
1214	if (num_regs != 1)
1215		return 0;
1216
1217	/* Extension register address. */
1218	memcpy(&reg_addr, &gen_info_buf[ext + 44], 4);
1219
1220	/* 9 bits (0 to 8) contains the offset address. */
1221	offset = reg_addr & 0x1ff;
1222
1223	/* 8 bits (9 to 16) contains the page number. */
1224	page = reg_addr >> 9 & 0xff ;
1225
1226	/* 4 bits (18 to 21) contains the function number. */
1227	fno = reg_addr >> 18 & 0xf;
1228
1229	/* Standard Function Code for power management. */
1230	if (sfc == 0x1)
1231		return sd_parse_ext_reg_power(card, fno, page, offset);
1232
1233	/* Standard Function Code for performance enhancement. */
1234	if (sfc == 0x2)
1235		return sd_parse_ext_reg_perf(card, fno, page, offset);
1236
1237	return 0;
1238}
1239
1240static int sd_read_ext_regs(struct mmc_card *card)
1241{
1242	int err, i;
1243	u8 num_ext, *gen_info_buf;
1244	u16 rev, len, next_ext_addr;
1245
1246	if (mmc_host_is_spi(card->host))
1247		return 0;
1248
1249	if (!(card->scr.cmds & SD_SCR_CMD48_SUPPORT))
1250		return 0;
1251
1252	gen_info_buf = kzalloc(512, GFP_KERNEL);
1253	if (!gen_info_buf)
1254		return -ENOMEM;
1255
1256	/*
1257	 * Read 512 bytes of general info, which is found at function number 0,
1258	 * at page 0 and with no offset.
1259	 */
1260	err = sd_read_ext_reg(card, 0, 0, 0, 512, gen_info_buf);
1261	if (err) {
1262		pr_err("%s: error %d reading general info of SD ext reg\n",
1263			mmc_hostname(card->host), err);
1264		goto out;
1265	}
1266
1267	/* General info structure revision. */
1268	memcpy(&rev, &gen_info_buf[0], 2);
1269
1270	/* Length of general info in bytes. */
1271	memcpy(&len, &gen_info_buf[2], 2);
1272
1273	/* Number of extensions to be find. */
1274	num_ext = gen_info_buf[4];
1275
1276	/*
1277	 * We only support revision 0 and limit it to 512 bytes for simplicity.
1278	 * No matter what, let's return zero to allow us to continue using the
1279	 * card, even if we can't support the features from the SD function
1280	 * extensions registers.
1281	 */
1282	if (rev != 0 || len > 512) {
1283		pr_warn("%s: non-supported SD ext reg layout\n",
1284			mmc_hostname(card->host));
1285		goto out;
1286	}
1287
1288	/*
1289	 * Parse the extension registers. The first extension should start
1290	 * immediately after the general info header (16 bytes).
1291	 */
1292	next_ext_addr = 16;
1293	for (i = 0; i < num_ext; i++) {
1294		err = sd_parse_ext_reg(card, gen_info_buf, &next_ext_addr);
1295		if (err) {
1296			pr_err("%s: error %d parsing SD ext reg\n",
1297				mmc_hostname(card->host), err);
1298			goto out;
1299		}
1300	}
1301
1302out:
1303	kfree(gen_info_buf);
1304	return err;
1305}
1306
1307static bool sd_cache_enabled(struct mmc_host *host)
1308{
1309	return host->card->ext_perf.feature_enabled & SD_EXT_PERF_CACHE;
1310}
1311
1312static int sd_flush_cache(struct mmc_host *host)
1313{
1314	struct mmc_card *card = host->card;
1315	u8 *reg_buf, fno, page;
1316	u16 offset;
1317	int err;
1318
1319	if (!sd_cache_enabled(host))
1320		return 0;
1321
1322	reg_buf = kzalloc(512, GFP_KERNEL);
1323	if (!reg_buf)
1324		return -ENOMEM;
1325
1326	/*
1327	 * Set Flush Cache at bit 0 in the performance enhancement register at
1328	 * 261 bytes offset.
1329	 */
1330	fno = card->ext_perf.fno;
1331	page = card->ext_perf.page;
1332	offset = card->ext_perf.offset + 261;
1333
1334	err = sd_write_ext_reg(card, fno, page, offset, BIT(0));
1335	if (err) {
1336		pr_warn("%s: error %d writing Cache Flush bit\n",
1337			mmc_hostname(host), err);
1338		goto out;
1339	}
1340
1341	err = mmc_poll_for_busy(card, SD_WRITE_EXTR_SINGLE_TIMEOUT_MS, false,
1342				MMC_BUSY_EXTR_SINGLE);
1343	if (err)
1344		goto out;
1345
1346	/*
1347	 * Read the Flush Cache bit. The card shall reset it, to confirm that
1348	 * it's has completed the flushing of the cache.
1349	 */
1350	err = sd_read_ext_reg(card, fno, page, offset, 1, reg_buf);
1351	if (err) {
1352		pr_warn("%s: error %d reading Cache Flush bit\n",
1353			mmc_hostname(host), err);
1354		goto out;
1355	}
1356
1357	if (reg_buf[0] & BIT(0))
1358		err = -ETIMEDOUT;
1359out:
1360	kfree(reg_buf);
1361	return err;
1362}
1363
1364static int sd_enable_cache(struct mmc_card *card)
1365{
1366	u8 *reg_buf;
1367	int err;
1368
1369	card->ext_perf.feature_enabled &= ~SD_EXT_PERF_CACHE;
1370
1371	reg_buf = kzalloc(512, GFP_KERNEL);
1372	if (!reg_buf)
1373		return -ENOMEM;
1374
1375	/*
1376	 * Set Cache Enable at bit 0 in the performance enhancement register at
1377	 * 260 bytes offset.
1378	 */
1379	err = sd_write_ext_reg(card, card->ext_perf.fno, card->ext_perf.page,
1380			       card->ext_perf.offset + 260, BIT(0));
1381	if (err) {
1382		pr_warn("%s: error %d writing Cache Enable bit\n",
1383			mmc_hostname(card->host), err);
1384		goto out;
1385	}
1386
1387	err = mmc_poll_for_busy(card, SD_WRITE_EXTR_SINGLE_TIMEOUT_MS, false,
1388				MMC_BUSY_EXTR_SINGLE);
1389	if (!err)
1390		card->ext_perf.feature_enabled |= SD_EXT_PERF_CACHE;
1391
1392out:
1393	kfree(reg_buf);
1394	return err;
1395}
1396
1397/*
1398 * Handle the detection and initialisation of a card.
1399 *
1400 * In the case of a resume, "oldcard" will contain the card
1401 * we're trying to reinitialise.
1402 */
1403static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
1404	struct mmc_card *oldcard)
1405{
1406	struct mmc_card *card;
1407	int err;
1408	u32 cid[4];
1409	u32 rocr = 0;
1410	bool v18_fixup_failed = false;
1411
 
1412	WARN_ON(!host->claimed);
1413retry:
1414	err = mmc_sd_get_cid(host, ocr, cid, &rocr);
1415	if (err)
1416		return err;
1417
1418	if (oldcard) {
1419		if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0) {
1420			pr_debug("%s: Perhaps the card was replaced\n",
1421				mmc_hostname(host));
1422			return -ENOENT;
1423		}
1424
1425		card = oldcard;
1426	} else {
1427		/*
1428		 * Allocate card structure.
1429		 */
1430		card = mmc_alloc_card(host, &sd_type);
1431		if (IS_ERR(card))
1432			return PTR_ERR(card);
1433
1434		card->ocr = ocr;
1435		card->type = MMC_TYPE_SD;
1436		memcpy(card->raw_cid, cid, sizeof(card->raw_cid));
1437	}
1438
1439	/*
1440	 * Call the optional HC's init_card function to handle quirks.
1441	 */
1442	if (host->ops->init_card)
1443		host->ops->init_card(host, card);
1444
1445	/*
1446	 * For native busses:  get card RCA and quit open drain mode.
1447	 */
1448	if (!mmc_host_is_spi(host)) {
1449		err = mmc_send_relative_addr(host, &card->rca);
1450		if (err)
1451			goto free_card;
1452	}
1453
1454	if (!oldcard) {
1455		err = mmc_sd_get_csd(card);
1456		if (err)
1457			goto free_card;
1458
1459		mmc_decode_cid(card);
1460	}
1461
1462	/*
1463	 * handling only for cards supporting DSR and hosts requesting
1464	 * DSR configuration
1465	 */
1466	if (card->csd.dsr_imp && host->dsr_req)
1467		mmc_set_dsr(host);
1468
1469	/*
1470	 * Select card, as all following commands rely on that.
1471	 */
1472	if (!mmc_host_is_spi(host)) {
1473		err = mmc_select_card(card);
1474		if (err)
1475			goto free_card;
1476	}
1477
1478	err = mmc_sd_setup_card(host, card, oldcard != NULL);
1479	if (err)
1480		goto free_card;
1481
1482	/*
1483	 * If the card has not been power cycled, it may still be using 1.8V
1484	 * signaling. Detect that situation and try to initialize a UHS-I (1.8V)
1485	 * transfer mode.
1486	 */
1487	if (!v18_fixup_failed && !mmc_host_is_spi(host) && mmc_host_uhs(host) &&
1488	    mmc_sd_card_using_v18(card) &&
1489	    host->ios.signal_voltage != MMC_SIGNAL_VOLTAGE_180) {
1490		if (mmc_host_set_uhs_voltage(host) ||
1491		    mmc_sd_init_uhs_card(card)) {
1492			v18_fixup_failed = true;
1493			mmc_power_cycle(host, ocr);
1494			if (!oldcard)
1495				mmc_remove_card(card);
1496			goto retry;
1497		}
1498		goto cont;
1499	}
1500
1501	/* Initialization sequence for UHS-I cards */
1502	if (rocr & SD_ROCR_S18A && mmc_host_uhs(host)) {
1503		err = mmc_sd_init_uhs_card(card);
1504		if (err)
1505			goto free_card;
1506	} else {
1507		/*
1508		 * Attempt to change to high-speed (if supported)
1509		 */
1510		err = mmc_sd_switch_hs(card);
1511		if (err > 0)
1512			mmc_set_timing(card->host, MMC_TIMING_SD_HS);
1513		else if (err)
1514			goto free_card;
1515
1516		/*
1517		 * Set bus speed.
1518		 */
1519		mmc_set_clock(host, mmc_sd_get_max_clock(card));
1520
1521		if (host->ios.timing == MMC_TIMING_SD_HS &&
1522			host->ops->prepare_sd_hs_tuning) {
1523			err = host->ops->prepare_sd_hs_tuning(host, card);
1524			if (err)
1525				goto free_card;
1526		}
1527
1528		/*
1529		 * Switch to wider bus (if supported).
1530		 */
1531		if ((host->caps & MMC_CAP_4_BIT_DATA) &&
1532			(card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {
1533			err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
1534			if (err)
1535				goto free_card;
1536
1537			mmc_set_bus_width(host, MMC_BUS_WIDTH_4);
1538		}
1539
1540		if (host->ios.timing == MMC_TIMING_SD_HS &&
1541			host->ops->execute_sd_hs_tuning) {
1542			err = host->ops->execute_sd_hs_tuning(host, card);
1543			if (err)
1544				goto free_card;
1545		}
1546	}
1547cont:
1548	if (!oldcard) {
1549		/* Read/parse the extension registers. */
1550		err = sd_read_ext_regs(card);
1551		if (err)
1552			goto free_card;
1553	}
1554
1555	/* Enable internal SD cache if supported. */
1556	if (card->ext_perf.feature_support & SD_EXT_PERF_CACHE) {
1557		err = sd_enable_cache(card);
1558		if (err)
1559			goto free_card;
1560	}
1561
1562	if (host->cqe_ops && !host->cqe_enabled) {
1563		err = host->cqe_ops->cqe_enable(host, card);
1564		if (!err) {
1565			host->cqe_enabled = true;
1566			host->hsq_enabled = true;
1567			pr_info("%s: Host Software Queue enabled\n",
1568				mmc_hostname(host));
1569		}
1570	}
1571
1572	if (host->caps2 & MMC_CAP2_AVOID_3_3V &&
1573	    host->ios.signal_voltage == MMC_SIGNAL_VOLTAGE_330) {
1574		pr_err("%s: Host failed to negotiate down from 3.3V\n",
1575			mmc_hostname(host));
1576		err = -EINVAL;
1577		goto free_card;
1578	}
1579
1580	host->card = card;
1581	return 0;
1582
1583free_card:
1584	if (!oldcard)
1585		mmc_remove_card(card);
1586
1587	return err;
1588}
1589
1590/*
1591 * Host is being removed. Free up the current card.
1592 */
1593static void mmc_sd_remove(struct mmc_host *host)
1594{
 
 
 
1595	mmc_remove_card(host->card);
1596	host->card = NULL;
1597}
1598
1599/*
1600 * Card detection - card is alive.
1601 */
1602static int mmc_sd_alive(struct mmc_host *host)
1603{
1604	return mmc_send_status(host->card, NULL);
1605}
1606
1607/*
1608 * Card detection callback from host.
1609 */
1610static void mmc_sd_detect(struct mmc_host *host)
1611{
1612	int err;
1613
1614	mmc_get_card(host->card, NULL);
 
 
 
1615
1616	/*
1617	 * Just check if our card has been removed.
1618	 */
1619	err = _mmc_detect_card_removed(host);
1620
1621	mmc_put_card(host->card, NULL);
1622
1623	if (err) {
1624		mmc_sd_remove(host);
1625
1626		mmc_claim_host(host);
1627		mmc_detach_bus(host);
1628		mmc_power_off(host);
1629		mmc_release_host(host);
1630	}
1631}
1632
1633static int sd_can_poweroff_notify(struct mmc_card *card)
1634{
1635	return card->ext_power.feature_support & SD_EXT_POWER_OFF_NOTIFY;
1636}
1637
1638static int sd_busy_poweroff_notify_cb(void *cb_data, bool *busy)
1639{
1640	struct sd_busy_data *data = cb_data;
1641	struct mmc_card *card = data->card;
1642	int err;
1643
1644	/*
1645	 * Read the status register for the power management function. It's at
1646	 * one byte offset and is one byte long. The Power Off Notification
1647	 * Ready is bit 0.
1648	 */
1649	err = sd_read_ext_reg(card, card->ext_power.fno, card->ext_power.page,
1650			      card->ext_power.offset + 1, 1, data->reg_buf);
1651	if (err) {
1652		pr_warn("%s: error %d reading status reg of PM func\n",
1653			mmc_hostname(card->host), err);
1654		return err;
1655	}
1656
1657	*busy = !(data->reg_buf[0] & BIT(0));
1658	return 0;
1659}
1660
1661static int sd_poweroff_notify(struct mmc_card *card)
1662{
1663	struct sd_busy_data cb_data;
1664	u8 *reg_buf;
1665	int err;
1666
1667	reg_buf = kzalloc(512, GFP_KERNEL);
1668	if (!reg_buf)
1669		return -ENOMEM;
1670
1671	/*
1672	 * Set the Power Off Notification bit in the power management settings
1673	 * register at 2 bytes offset.
1674	 */
1675	err = sd_write_ext_reg(card, card->ext_power.fno, card->ext_power.page,
1676			       card->ext_power.offset + 2, BIT(0));
1677	if (err) {
1678		pr_warn("%s: error %d writing Power Off Notify bit\n",
1679			mmc_hostname(card->host), err);
1680		goto out;
1681	}
1682
1683	/* Find out when the command is completed. */
1684	err = mmc_poll_for_busy(card, SD_WRITE_EXTR_SINGLE_TIMEOUT_MS, false,
1685				MMC_BUSY_EXTR_SINGLE);
1686	if (err)
1687		goto out;
1688
1689	cb_data.card = card;
1690	cb_data.reg_buf = reg_buf;
1691	err = __mmc_poll_for_busy(card->host, 0, SD_POWEROFF_NOTIFY_TIMEOUT_MS,
1692				  &sd_busy_poweroff_notify_cb, &cb_data);
1693
1694out:
1695	kfree(reg_buf);
1696	return err;
1697}
1698
1699static int _mmc_sd_suspend(struct mmc_host *host)
1700{
1701	struct mmc_card *card = host->card;
1702	int err = 0;
1703
 
 
 
1704	mmc_claim_host(host);
1705
1706	if (mmc_card_suspended(card))
1707		goto out;
1708
1709	if (sd_can_poweroff_notify(card))
1710		err = sd_poweroff_notify(card);
1711	else if (!mmc_host_is_spi(host))
1712		err = mmc_deselect_cards(host);
1713
1714	if (!err) {
1715		mmc_power_off(host);
1716		mmc_card_set_suspended(card);
1717	}
1718
1719out:
1720	mmc_release_host(host);
1721	return err;
1722}
1723
1724/*
1725 * Callback for suspend
1726 */
1727static int mmc_sd_suspend(struct mmc_host *host)
1728{
1729	int err;
1730
1731	err = _mmc_sd_suspend(host);
1732	if (!err) {
1733		pm_runtime_disable(&host->card->dev);
1734		pm_runtime_set_suspended(&host->card->dev);
1735	}
1736
1737	return err;
1738}
1739
1740/*
1741 * This function tries to determine if the same card is still present
1742 * and, if so, restore all state to it.
1743 */
1744static int _mmc_sd_resume(struct mmc_host *host)
1745{
1746	int err = 0;
1747
 
 
 
1748	mmc_claim_host(host);
1749
1750	if (!mmc_card_suspended(host->card))
1751		goto out;
1752
1753	mmc_power_up(host, host->card->ocr);
1754	err = mmc_sd_init_card(host, host->card->ocr, host->card);
1755	mmc_card_clr_suspended(host->card);
1756
1757out:
1758	mmc_release_host(host);
1759	return err;
1760}
1761
1762/*
1763 * Callback for resume
1764 */
1765static int mmc_sd_resume(struct mmc_host *host)
1766{
1767	pm_runtime_enable(&host->card->dev);
1768	return 0;
1769}
1770
1771/*
1772 * Callback for runtime_suspend.
1773 */
1774static int mmc_sd_runtime_suspend(struct mmc_host *host)
1775{
1776	int err;
1777
1778	if (!(host->caps & MMC_CAP_AGGRESSIVE_PM))
1779		return 0;
1780
1781	err = _mmc_sd_suspend(host);
1782	if (err)
1783		pr_err("%s: error %d doing aggressive suspend\n",
1784			mmc_hostname(host), err);
1785
1786	return err;
1787}
1788
1789/*
1790 * Callback for runtime_resume.
1791 */
1792static int mmc_sd_runtime_resume(struct mmc_host *host)
1793{
1794	int err;
1795
1796	err = _mmc_sd_resume(host);
1797	if (err && err != -ENOMEDIUM)
1798		pr_err("%s: error %d doing runtime resume\n",
1799			mmc_hostname(host), err);
1800
1801	return 0;
1802}
1803
1804static int mmc_sd_hw_reset(struct mmc_host *host)
1805{
1806	mmc_power_cycle(host, host->card->ocr);
1807	return mmc_sd_init_card(host, host->card->ocr, host->card);
1808}
1809
1810static const struct mmc_bus_ops mmc_sd_ops = {
1811	.remove = mmc_sd_remove,
1812	.detect = mmc_sd_detect,
1813	.runtime_suspend = mmc_sd_runtime_suspend,
1814	.runtime_resume = mmc_sd_runtime_resume,
1815	.suspend = mmc_sd_suspend,
1816	.resume = mmc_sd_resume,
1817	.alive = mmc_sd_alive,
1818	.shutdown = mmc_sd_suspend,
1819	.hw_reset = mmc_sd_hw_reset,
1820	.cache_enabled = sd_cache_enabled,
1821	.flush_cache = sd_flush_cache,
1822};
1823
1824/*
1825 * Starting point for SD card init.
1826 */
1827int mmc_attach_sd(struct mmc_host *host)
1828{
1829	int err;
1830	u32 ocr, rocr;
1831
 
1832	WARN_ON(!host->claimed);
1833
1834	err = mmc_send_app_op_cond(host, 0, &ocr);
1835	if (err)
1836		return err;
1837
1838	mmc_attach_bus(host, &mmc_sd_ops);
1839	if (host->ocr_avail_sd)
1840		host->ocr_avail = host->ocr_avail_sd;
1841
1842	/*
1843	 * We need to get OCR a different way for SPI.
1844	 */
1845	if (mmc_host_is_spi(host)) {
1846		mmc_go_idle(host);
1847
1848		err = mmc_spi_read_ocr(host, 0, &ocr);
1849		if (err)
1850			goto err;
1851	}
1852
1853	/*
1854	 * Some SD cards claims an out of spec VDD voltage range. Let's treat
1855	 * these bits as being in-valid and especially also bit7.
1856	 */
1857	ocr &= ~0x7FFF;
1858
1859	rocr = mmc_select_voltage(host, ocr);
1860
1861	/*
1862	 * Can we support the voltage(s) of the card(s)?
1863	 */
1864	if (!rocr) {
1865		err = -EINVAL;
1866		goto err;
1867	}
1868
1869	/*
1870	 * Detect and init the card.
1871	 */
1872	err = mmc_sd_init_card(host, rocr, NULL);
1873	if (err)
1874		goto err;
1875
1876	mmc_release_host(host);
1877	err = mmc_add_card(host->card);
1878	if (err)
1879		goto remove_card;
1880
1881	mmc_claim_host(host);
1882	return 0;
1883
1884remove_card:
1885	mmc_remove_card(host->card);
1886	host->card = NULL;
1887	mmc_claim_host(host);
1888err:
1889	mmc_detach_bus(host);
1890
1891	pr_err("%s: error %d whilst initialising SD card\n",
1892		mmc_hostname(host), err);
1893
1894	return err;
1895}