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