sd.c

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