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
  16#include <linux/mmc/host.h>
  17#include <linux/mmc/card.h>
  18#include <linux/mmc/mmc.h>
  19#include <linux/mmc/sd.h>
  20
  21#include "core.h"
  22#include "card.h"
  23#include "host.h"
  24#include "bus.h"
  25#include "mmc_ops.h"
  26#include "sd.h"
  27#include "sd_ops.h"
  28
  29static const unsigned int tran_exp[] = {
  30	10000,		100000,		1000000,	10000000,
  31	0,		0,		0,		0
  32};
  33
  34static const unsigned char tran_mant[] = {
  35	0,	10,	12,	13,	15,	20,	25,	30,
  36	35,	40,	45,	50,	55,	60,	70,	80,
  37};
  38
  39static const unsigned int taac_exp[] = {
  40	1,	10,	100,	1000,	10000,	100000,	1000000, 10000000,
  41};
  42
  43static const unsigned int taac_mant[] = {
  44	0,	10,	12,	13,	15,	20,	25,	30,
  45	35,	40,	45,	50,	55,	60,	70,	80,
  46};
  47
  48static const unsigned int sd_au_size[] = {
  49	0,		SZ_16K / 512,		SZ_32K / 512,	SZ_64K / 512,
  50	SZ_128K / 512,	SZ_256K / 512,		SZ_512K / 512,	SZ_1M / 512,
  51	SZ_2M / 512,	SZ_4M / 512,		SZ_8M / 512,	(SZ_8M + SZ_4M) / 512,
  52	SZ_16M / 512,	(SZ_16M + SZ_8M) / 512,	SZ_32M / 512,	SZ_64M / 512,
  53};
  54
  55#define UNSTUFF_BITS(resp,start,size)					\
  56	({								\
  57		const int __size = size;				\
  58		const u32 __mask = (__size < 32 ? 1 << __size : 0) - 1;	\
  59		const int __off = 3 - ((start) / 32);			\
  60		const int __shft = (start) & 31;			\
  61		u32 __res;						\
  62									\
  63		__res = resp[__off] >> __shft;				\
  64		if (__size + __shft > 32)				\
  65			__res |= resp[__off-1] << ((32 - __shft) % 32);	\
  66		__res & __mask;						\
  67	})
  68
  69/*
  70 * Given the decoded CSD structure, decode the raw CID to our CID structure.
  71 */
  72void mmc_decode_cid(struct mmc_card *card)
  73{
  74	u32 *resp = card->raw_cid;
  75
  76	/*
  77	 * SD doesn't currently have a version field so we will
  78	 * have to assume we can parse this.
  79	 */
  80	card->cid.manfid		= UNSTUFF_BITS(resp, 120, 8);
  81	card->cid.oemid			= UNSTUFF_BITS(resp, 104, 16);
  82	card->cid.prod_name[0]		= UNSTUFF_BITS(resp, 96, 8);
  83	card->cid.prod_name[1]		= UNSTUFF_BITS(resp, 88, 8);
  84	card->cid.prod_name[2]		= UNSTUFF_BITS(resp, 80, 8);
  85	card->cid.prod_name[3]		= UNSTUFF_BITS(resp, 72, 8);
  86	card->cid.prod_name[4]		= UNSTUFF_BITS(resp, 64, 8);
  87	card->cid.hwrev			= UNSTUFF_BITS(resp, 60, 4);
  88	card->cid.fwrev			= UNSTUFF_BITS(resp, 56, 4);
  89	card->cid.serial		= UNSTUFF_BITS(resp, 24, 32);
  90	card->cid.year			= UNSTUFF_BITS(resp, 12, 8);
  91	card->cid.month			= UNSTUFF_BITS(resp, 8, 4);
  92
  93	card->cid.year += 2000; /* SD cards year offset */
  94}
  95
  96/*
  97 * Given a 128-bit response, decode to our card CSD structure.
  98 */
  99static int mmc_decode_csd(struct mmc_card *card)
 100{
 101	struct mmc_csd *csd = &card->csd;
 102	unsigned int e, m, csd_struct;
 103	u32 *resp = card->raw_csd;
 104
 105	csd_struct = UNSTUFF_BITS(resp, 126, 2);
 106
 107	switch (csd_struct) {
 108	case 0:
 109		m = UNSTUFF_BITS(resp, 115, 4);
 110		e = UNSTUFF_BITS(resp, 112, 3);
 111		csd->taac_ns	 = (taac_exp[e] * taac_mant[m] + 9) / 10;
 112		csd->taac_clks	 = UNSTUFF_BITS(resp, 104, 8) * 100;
 113
 114		m = UNSTUFF_BITS(resp, 99, 4);
 115		e = UNSTUFF_BITS(resp, 96, 3);
 116		csd->max_dtr	  = tran_exp[e] * tran_mant[m];
 117		csd->cmdclass	  = UNSTUFF_BITS(resp, 84, 12);
 118
 119		e = UNSTUFF_BITS(resp, 47, 3);
 120		m = UNSTUFF_BITS(resp, 62, 12);
 121		csd->capacity	  = (1 + m) << (e + 2);
 122
 123		csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4);
 124		csd->read_partial = UNSTUFF_BITS(resp, 79, 1);
 125		csd->write_misalign = UNSTUFF_BITS(resp, 78, 1);
 126		csd->read_misalign = UNSTUFF_BITS(resp, 77, 1);
 127		csd->dsr_imp = UNSTUFF_BITS(resp, 76, 1);
 128		csd->r2w_factor = UNSTUFF_BITS(resp, 26, 3);
 129		csd->write_blkbits = UNSTUFF_BITS(resp, 22, 4);
 130		csd->write_partial = UNSTUFF_BITS(resp, 21, 1);
 131
 132		if (UNSTUFF_BITS(resp, 46, 1)) {
 133			csd->erase_size = 1;
 134		} else if (csd->write_blkbits >= 9) {
 135			csd->erase_size = UNSTUFF_BITS(resp, 39, 7) + 1;
 136			csd->erase_size <<= csd->write_blkbits - 9;
 137		}
 138		break;
 139	case 1:
 140		/*
 141		 * This is a block-addressed SDHC or SDXC card. Most
 142		 * interesting fields are unused and have fixed
 143		 * values. To avoid getting tripped by buggy cards,
 144		 * we assume those fixed values ourselves.
 145		 */
 146		mmc_card_set_blockaddr(card);
 147
 148		csd->taac_ns	 = 0; /* Unused */
 149		csd->taac_clks	 = 0; /* Unused */
 150
 151		m = UNSTUFF_BITS(resp, 99, 4);
 152		e = UNSTUFF_BITS(resp, 96, 3);
 153		csd->max_dtr	  = tran_exp[e] * tran_mant[m];
 154		csd->cmdclass	  = UNSTUFF_BITS(resp, 84, 12);
 155		csd->c_size	  = UNSTUFF_BITS(resp, 48, 22);
 156
 157		/* SDXC cards have a minimum C_SIZE of 0x00FFFF */
 158		if (csd->c_size >= 0xFFFF)
 159			mmc_card_set_ext_capacity(card);
 160
 161		m = UNSTUFF_BITS(resp, 48, 22);
 162		csd->capacity     = (1 + m) << 10;
 163
 164		csd->read_blkbits = 9;
 165		csd->read_partial = 0;
 166		csd->write_misalign = 0;
 167		csd->read_misalign = 0;
 168		csd->r2w_factor = 4; /* Unused */
 169		csd->write_blkbits = 9;
 170		csd->write_partial = 0;
 171		csd->erase_size = 1;
 172		break;
 173	default:
 174		pr_err("%s: unrecognised CSD structure version %d\n",
 175			mmc_hostname(card->host), csd_struct);
 176		return -EINVAL;
 177	}
 178
 179	card->erase_size = csd->erase_size;
 180
 181	return 0;
 182}
 183
 184/*
 185 * Given a 64-bit response, decode to our card SCR structure.
 186 */
 187static int mmc_decode_scr(struct mmc_card *card)
 188{
 189	struct sd_scr *scr = &card->scr;
 190	unsigned int scr_struct;
 191	u32 resp[4];
 192
 193	resp[3] = card->raw_scr[1];
 194	resp[2] = card->raw_scr[0];
 195
 196	scr_struct = UNSTUFF_BITS(resp, 60, 4);
 197	if (scr_struct != 0) {
 198		pr_err("%s: unrecognised SCR structure version %d\n",
 199			mmc_hostname(card->host), scr_struct);
 200		return -EINVAL;
 201	}
 202
 203	scr->sda_vsn = UNSTUFF_BITS(resp, 56, 4);
 204	scr->bus_widths = UNSTUFF_BITS(resp, 48, 4);
 205	if (scr->sda_vsn == SCR_SPEC_VER_2)
 206		/* Check if Physical Layer Spec v3.0 is supported */
 207		scr->sda_spec3 = UNSTUFF_BITS(resp, 47, 1);
 208
 209	if (scr->sda_spec3) {
 210		scr->sda_spec4 = UNSTUFF_BITS(resp, 42, 1);
 211		scr->sda_specx = UNSTUFF_BITS(resp, 38, 4);
 212	}
 213
 214	if (UNSTUFF_BITS(resp, 55, 1))
 215		card->erased_byte = 0xFF;
 216	else
 217		card->erased_byte = 0x0;
 218
 219	if (scr->sda_spec3)
 220		scr->cmds = UNSTUFF_BITS(resp, 32, 2);
 221
 222	/* SD Spec says: any SD Card shall set at least bits 0 and 2 */
 223	if (!(scr->bus_widths & SD_SCR_BUS_WIDTH_1) ||
 224	    !(scr->bus_widths & SD_SCR_BUS_WIDTH_4)) {
 225		pr_err("%s: invalid bus width\n", mmc_hostname(card->host));
 226		return -EINVAL;
 227	}
 228
 229	return 0;
 230}
 231
 232/*
 233 * Fetch and process SD Status register.
 234 */
 235static int mmc_read_ssr(struct mmc_card *card)
 236{
 237	unsigned int au, es, et, eo;
 238	__be32 *raw_ssr;
 239	u32 resp[4] = {};
 240	u8 discard_support;
 241	int i;
 242
 243	if (!(card->csd.cmdclass & CCC_APP_SPEC)) {
 244		pr_warn("%s: card lacks mandatory SD Status function\n",
 245			mmc_hostname(card->host));
 246		return 0;
 247	}
 248
 249	raw_ssr = kmalloc(sizeof(card->raw_ssr), GFP_KERNEL);
 250	if (!raw_ssr)
 251		return -ENOMEM;
 252
 253	if (mmc_app_sd_status(card, raw_ssr)) {
 254		pr_warn("%s: problem reading SD Status register\n",
 255			mmc_hostname(card->host));
 256		kfree(raw_ssr);
 257		return 0;
 258	}
 259
 260	for (i = 0; i < 16; i++)
 261		card->raw_ssr[i] = be32_to_cpu(raw_ssr[i]);
 262
 263	kfree(raw_ssr);
 264
 265	/*
 266	 * UNSTUFF_BITS only works with four u32s so we have to offset the
 267	 * bitfield positions accordingly.
 268	 */
 269	au = UNSTUFF_BITS(card->raw_ssr, 428 - 384, 4);
 270	if (au) {
 271		if (au <= 9 || card->scr.sda_spec3) {
 272			card->ssr.au = sd_au_size[au];
 273			es = UNSTUFF_BITS(card->raw_ssr, 408 - 384, 16);
 274			et = UNSTUFF_BITS(card->raw_ssr, 402 - 384, 6);
 275			if (es && et) {
 276				eo = UNSTUFF_BITS(card->raw_ssr, 400 - 384, 2);
 277				card->ssr.erase_timeout = (et * 1000) / es;
 278				card->ssr.erase_offset = eo * 1000;
 279			}
 280		} else {
 281			pr_warn("%s: SD Status: Invalid Allocation Unit size\n",
 282				mmc_hostname(card->host));
 283		}
 284	}
 285
 286	/*
 287	 * starting SD5.1 discard is supported if DISCARD_SUPPORT (b313) is set
 288	 */
 289	resp[3] = card->raw_ssr[6];
 290	discard_support = UNSTUFF_BITS(resp, 313 - 288, 1);
 291	card->erase_arg = (card->scr.sda_specx && discard_support) ?
 292			    SD_DISCARD_ARG : SD_ERASE_ARG;
 293
 294	return 0;
 295}
 296
 297/*
 298 * Fetches and decodes switch information
 299 */
 300static int mmc_read_switch(struct mmc_card *card)
 301{
 302	int err;
 303	u8 *status;
 304
 305	if (card->scr.sda_vsn < SCR_SPEC_VER_1)
 306		return 0;
 307
 308	if (!(card->csd.cmdclass & CCC_SWITCH)) {
 309		pr_warn("%s: card lacks mandatory switch function, performance might suffer\n",
 310			mmc_hostname(card->host));
 311		return 0;
 312	}
 313
 314	status = kmalloc(64, GFP_KERNEL);
 315	if (!status)
 316		return -ENOMEM;
 317
 318	/*
 319	 * Find out the card's support bits with a mode 0 operation.
 320	 * The argument does not matter, as the support bits do not
 321	 * change with the arguments.
 322	 */
 323	err = mmc_sd_switch(card, 0, 0, 0, status);
 324	if (err) {
 325		/*
 326		 * If the host or the card can't do the switch,
 327		 * fail more gracefully.
 328		 */
 329		if (err != -EINVAL && err != -ENOSYS && err != -EFAULT)
 330			goto out;
 331
 332		pr_warn("%s: problem reading Bus Speed modes\n",
 333			mmc_hostname(card->host));
 334		err = 0;
 335
 336		goto out;
 337	}
 338
 339	if (status[13] & SD_MODE_HIGH_SPEED)
 340		card->sw_caps.hs_max_dtr = HIGH_SPEED_MAX_DTR;
 341
 342	if (card->scr.sda_spec3) {
 343		card->sw_caps.sd3_bus_mode = status[13];
 344		/* Driver Strengths supported by the card */
 345		card->sw_caps.sd3_drv_type = status[9];
 346		card->sw_caps.sd3_curr_limit = status[7] | status[6] << 8;
 347	}
 348
 349out:
 350	kfree(status);
 351
 352	return err;
 353}
 354
 355/*
 356 * Test if the card supports high-speed mode and, if so, switch to it.
 357 */
 358int mmc_sd_switch_hs(struct mmc_card *card)
 359{
 360	int err;
 361	u8 *status;
 362
 363	if (card->scr.sda_vsn < SCR_SPEC_VER_1)
 364		return 0;
 365
 366	if (!(card->csd.cmdclass & CCC_SWITCH))
 367		return 0;
 368
 369	if (!(card->host->caps & MMC_CAP_SD_HIGHSPEED))
 370		return 0;
 371
 372	if (card->sw_caps.hs_max_dtr == 0)
 373		return 0;
 374
 375	status = kmalloc(64, GFP_KERNEL);
 376	if (!status)
 377		return -ENOMEM;
 378
 379	err = mmc_sd_switch(card, 1, 0, HIGH_SPEED_BUS_SPEED, status);
 380	if (err)
 381		goto out;
 382
 383	if ((status[16] & 0xF) != HIGH_SPEED_BUS_SPEED) {
 384		pr_warn("%s: Problem switching card into high-speed mode!\n",
 385			mmc_hostname(card->host));
 386		err = 0;
 387	} else {
 388		err = 1;
 389	}
 390
 391out:
 392	kfree(status);
 393
 394	return err;
 395}
 396
 397static int sd_select_driver_type(struct mmc_card *card, u8 *status)
 398{
 399	int card_drv_type, drive_strength, drv_type;
 400	int err;
 401
 402	card->drive_strength = 0;
 403
 404	card_drv_type = card->sw_caps.sd3_drv_type | SD_DRIVER_TYPE_B;
 405
 406	drive_strength = mmc_select_drive_strength(card,
 407						   card->sw_caps.uhs_max_dtr,
 408						   card_drv_type, &drv_type);
 409
 410	if (drive_strength) {
 411		err = mmc_sd_switch(card, 1, 2, drive_strength, status);
 412		if (err)
 413			return err;
 414		if ((status[15] & 0xF) != drive_strength) {
 415			pr_warn("%s: Problem setting drive strength!\n",
 416				mmc_hostname(card->host));
 417			return 0;
 418		}
 419		card->drive_strength = drive_strength;
 420	}
 421
 422	if (drv_type)
 423		mmc_set_driver_type(card->host, drv_type);
 424
 425	return 0;
 426}
 427
 428static void sd_update_bus_speed_mode(struct mmc_card *card)
 429{
 430	/*
 431	 * If the host doesn't support any of the UHS-I modes, fallback on
 432	 * default speed.
 433	 */
 434	if (!mmc_host_uhs(card->host)) {
 435		card->sd_bus_speed = 0;
 436		return;
 437	}
 438
 439	if ((card->host->caps & MMC_CAP_UHS_SDR104) &&
 440	    (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR104)) {
 441			card->sd_bus_speed = UHS_SDR104_BUS_SPEED;
 442	} else if ((card->host->caps & MMC_CAP_UHS_DDR50) &&
 443		   (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_DDR50)) {
 444			card->sd_bus_speed = UHS_DDR50_BUS_SPEED;
 445	} else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
 446		    MMC_CAP_UHS_SDR50)) && (card->sw_caps.sd3_bus_mode &
 447		    SD_MODE_UHS_SDR50)) {
 448			card->sd_bus_speed = UHS_SDR50_BUS_SPEED;
 449	} else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
 450		    MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25)) &&
 451		   (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR25)) {
 452			card->sd_bus_speed = UHS_SDR25_BUS_SPEED;
 453	} else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
 454		    MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25 |
 455		    MMC_CAP_UHS_SDR12)) && (card->sw_caps.sd3_bus_mode &
 456		    SD_MODE_UHS_SDR12)) {
 457			card->sd_bus_speed = UHS_SDR12_BUS_SPEED;
 458	}
 459}
 460
 461static int sd_set_bus_speed_mode(struct mmc_card *card, u8 *status)
 462{
 463	int err;
 464	unsigned int timing = 0;
 465
 466	switch (card->sd_bus_speed) {
 467	case UHS_SDR104_BUS_SPEED:
 468		timing = MMC_TIMING_UHS_SDR104;
 469		card->sw_caps.uhs_max_dtr = UHS_SDR104_MAX_DTR;
 470		break;
 471	case UHS_DDR50_BUS_SPEED:
 472		timing = MMC_TIMING_UHS_DDR50;
 473		card->sw_caps.uhs_max_dtr = UHS_DDR50_MAX_DTR;
 474		break;
 475	case UHS_SDR50_BUS_SPEED:
 476		timing = MMC_TIMING_UHS_SDR50;
 477		card->sw_caps.uhs_max_dtr = UHS_SDR50_MAX_DTR;
 478		break;
 479	case UHS_SDR25_BUS_SPEED:
 480		timing = MMC_TIMING_UHS_SDR25;
 481		card->sw_caps.uhs_max_dtr = UHS_SDR25_MAX_DTR;
 482		break;
 483	case UHS_SDR12_BUS_SPEED:
 484		timing = MMC_TIMING_UHS_SDR12;
 485		card->sw_caps.uhs_max_dtr = UHS_SDR12_MAX_DTR;
 486		break;
 487	default:
 488		return 0;
 489	}
 490
 491	err = mmc_sd_switch(card, 1, 0, card->sd_bus_speed, status);
 492	if (err)
 493		return err;
 494
 495	if ((status[16] & 0xF) != card->sd_bus_speed)
 496		pr_warn("%s: Problem setting bus speed mode!\n",
 497			mmc_hostname(card->host));
 498	else {
 499		mmc_set_timing(card->host, timing);
 500		mmc_set_clock(card->host, card->sw_caps.uhs_max_dtr);
 501	}
 502
 503	return 0;
 504}
 505
 506/* Get host's max current setting at its current voltage */
 507static u32 sd_get_host_max_current(struct mmc_host *host)
 508{
 509	u32 voltage, max_current;
 510
 511	voltage = 1 << host->ios.vdd;
 512	switch (voltage) {
 513	case MMC_VDD_165_195:
 514		max_current = host->max_current_180;
 515		break;
 516	case MMC_VDD_29_30:
 517	case MMC_VDD_30_31:
 518		max_current = host->max_current_300;
 519		break;
 520	case MMC_VDD_32_33:
 521	case MMC_VDD_33_34:
 522		max_current = host->max_current_330;
 523		break;
 524	default:
 525		max_current = 0;
 526	}
 527
 528	return max_current;
 529}
 530
 531static int sd_set_current_limit(struct mmc_card *card, u8 *status)
 532{
 533	int current_limit = SD_SET_CURRENT_NO_CHANGE;
 534	int err;
 535	u32 max_current;
 536
 537	/*
 538	 * Current limit switch is only defined for SDR50, SDR104, and DDR50
 539	 * bus speed modes. For other bus speed modes, we do not change the
 540	 * current limit.
 541	 */
 542	if ((card->sd_bus_speed != UHS_SDR50_BUS_SPEED) &&
 543	    (card->sd_bus_speed != UHS_SDR104_BUS_SPEED) &&
 544	    (card->sd_bus_speed != UHS_DDR50_BUS_SPEED))
 545		return 0;
 546
 547	/*
 548	 * Host has different current capabilities when operating at
 549	 * different voltages, so find out its max current first.
 550	 */
 551	max_current = sd_get_host_max_current(card->host);
 552
 553	/*
 554	 * We only check host's capability here, if we set a limit that is
 555	 * higher than the card's maximum current, the card will be using its
 556	 * maximum current, e.g. if the card's maximum current is 300ma, and
 557	 * when we set current limit to 200ma, the card will draw 200ma, and
 558	 * when we set current limit to 400/600/800ma, the card will draw its
 559	 * maximum 300ma from the host.
 560	 *
 561	 * The above is incorrect: if we try to set a current limit that is
 562	 * not supported by the card, the card can rightfully error out the
 563	 * attempt, and remain at the default current limit.  This results
 564	 * in a 300mA card being limited to 200mA even though the host
 565	 * supports 800mA. Failures seen with SanDisk 8GB UHS cards with
 566	 * an iMX6 host. --rmk
 567	 */
 568	if (max_current >= 800 &&
 569	    card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_800)
 570		current_limit = SD_SET_CURRENT_LIMIT_800;
 571	else if (max_current >= 600 &&
 572		 card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_600)
 573		current_limit = SD_SET_CURRENT_LIMIT_600;
 574	else if (max_current >= 400 &&
 575		 card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_400)
 576		current_limit = SD_SET_CURRENT_LIMIT_400;
 577	else if (max_current >= 200 &&
 578		 card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_200)
 579		current_limit = SD_SET_CURRENT_LIMIT_200;
 580
 581	if (current_limit != SD_SET_CURRENT_NO_CHANGE) {
 582		err = mmc_sd_switch(card, 1, 3, current_limit, status);
 583		if (err)
 584			return err;
 585
 586		if (((status[15] >> 4) & 0x0F) != current_limit)
 587			pr_warn("%s: Problem setting current limit!\n",
 588				mmc_hostname(card->host));
 589
 590	}
 591
 592	return 0;
 593}
 594
 595/*
 596 * UHS-I specific initialization procedure
 597 */
 598static int mmc_sd_init_uhs_card(struct mmc_card *card)
 599{
 600	int err;
 601	u8 *status;
 602
 603	if (!(card->csd.cmdclass & CCC_SWITCH))
 604		return 0;
 605
 606	status = kmalloc(64, GFP_KERNEL);
 607	if (!status)
 608		return -ENOMEM;
 609
 610	/* Set 4-bit bus width */
 611	err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
 612	if (err)
 613		goto out;
 614
 615	mmc_set_bus_width(card->host, MMC_BUS_WIDTH_4);
 616
 617	/*
 618	 * Select the bus speed mode depending on host
 619	 * and card capability.
 620	 */
 621	sd_update_bus_speed_mode(card);
 622
 623	/* Set the driver strength for the card */
 624	err = sd_select_driver_type(card, status);
 625	if (err)
 626		goto out;
 627
 628	/* Set current limit for the card */
 629	err = sd_set_current_limit(card, status);
 630	if (err)
 631		goto out;
 632
 633	/* Set bus speed mode of the card */
 634	err = sd_set_bus_speed_mode(card, status);
 635	if (err)
 636		goto out;
 637
 638	/*
 639	 * SPI mode doesn't define CMD19 and tuning is only valid for SDR50 and
 640	 * SDR104 mode SD-cards. Note that tuning is mandatory for SDR104.
 641	 */
 642	if (!mmc_host_is_spi(card->host) &&
 643		(card->host->ios.timing == MMC_TIMING_UHS_SDR50 ||
 644		 card->host->ios.timing == MMC_TIMING_UHS_DDR50 ||
 645		 card->host->ios.timing == MMC_TIMING_UHS_SDR104)) {
 646		err = mmc_execute_tuning(card);
 647
 648		/*
 649		 * As SD Specifications Part1 Physical Layer Specification
 650		 * Version 3.01 says, CMD19 tuning is available for unlocked
 651		 * cards in transfer state of 1.8V signaling mode. The small
 652		 * difference between v3.00 and 3.01 spec means that CMD19
 653		 * tuning is also available for DDR50 mode.
 654		 */
 655		if (err && card->host->ios.timing == MMC_TIMING_UHS_DDR50) {
 656			pr_warn("%s: ddr50 tuning failed\n",
 657				mmc_hostname(card->host));
 658			err = 0;
 659		}
 660	}
 661
 662out:
 663	kfree(status);
 664
 665	return err;
 666}
 667
 668MMC_DEV_ATTR(cid, "%08x%08x%08x%08x\n", card->raw_cid[0], card->raw_cid[1],
 669	card->raw_cid[2], card->raw_cid[3]);
 670MMC_DEV_ATTR(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1],
 671	card->raw_csd[2], card->raw_csd[3]);
 672MMC_DEV_ATTR(scr, "%08x%08x\n", card->raw_scr[0], card->raw_scr[1]);
 673MMC_DEV_ATTR(ssr,
 674	"%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x\n",
 675		card->raw_ssr[0], card->raw_ssr[1], card->raw_ssr[2],
 676		card->raw_ssr[3], card->raw_ssr[4], card->raw_ssr[5],
 677		card->raw_ssr[6], card->raw_ssr[7], card->raw_ssr[8],
 678		card->raw_ssr[9], card->raw_ssr[10], card->raw_ssr[11],
 679		card->raw_ssr[12], card->raw_ssr[13], card->raw_ssr[14],
 680		card->raw_ssr[15]);
 681MMC_DEV_ATTR(date, "%02d/%04d\n", card->cid.month, card->cid.year);
 682MMC_DEV_ATTR(erase_size, "%u\n", card->erase_size << 9);
 683MMC_DEV_ATTR(preferred_erase_size, "%u\n", card->pref_erase << 9);
 684MMC_DEV_ATTR(fwrev, "0x%x\n", card->cid.fwrev);
 685MMC_DEV_ATTR(hwrev, "0x%x\n", card->cid.hwrev);
 686MMC_DEV_ATTR(manfid, "0x%06x\n", card->cid.manfid);
 687MMC_DEV_ATTR(name, "%s\n", card->cid.prod_name);
 688MMC_DEV_ATTR(oemid, "0x%04x\n", card->cid.oemid);
 689MMC_DEV_ATTR(serial, "0x%08x\n", card->cid.serial);
 690MMC_DEV_ATTR(ocr, "0x%08x\n", card->ocr);
 691MMC_DEV_ATTR(rca, "0x%04x\n", card->rca);
 692
 693
 694static ssize_t mmc_dsr_show(struct device *dev,
 695                           struct device_attribute *attr,
 696                           char *buf)
 697{
 698       struct mmc_card *card = mmc_dev_to_card(dev);
 699       struct mmc_host *host = card->host;
 700
 701       if (card->csd.dsr_imp && host->dsr_req)
 702               return sprintf(buf, "0x%x\n", host->dsr);
 703       else
 704               /* return default DSR value */
 705               return sprintf(buf, "0x%x\n", 0x404);
 706}
 707
 708static DEVICE_ATTR(dsr, S_IRUGO, mmc_dsr_show, NULL);
 709
 710MMC_DEV_ATTR(vendor, "0x%04x\n", card->cis.vendor);
 711MMC_DEV_ATTR(device, "0x%04x\n", card->cis.device);
 712
 713static struct attribute *sd_std_attrs[] = {
 714	&dev_attr_vendor.attr,
 715	&dev_attr_device.attr,
 716	&dev_attr_cid.attr,
 717	&dev_attr_csd.attr,
 718	&dev_attr_scr.attr,
 719	&dev_attr_ssr.attr,
 720	&dev_attr_date.attr,
 721	&dev_attr_erase_size.attr,
 722	&dev_attr_preferred_erase_size.attr,
 723	&dev_attr_fwrev.attr,
 724	&dev_attr_hwrev.attr,
 725	&dev_attr_manfid.attr,
 726	&dev_attr_name.attr,
 727	&dev_attr_oemid.attr,
 728	&dev_attr_serial.attr,
 729	&dev_attr_ocr.attr,
 730	&dev_attr_rca.attr,
 731	&dev_attr_dsr.attr,
 732	NULL,
 733};
 734
 735static umode_t sd_std_is_visible(struct kobject *kobj, struct attribute *attr,
 736				 int index)
 737{
 738	struct device *dev = container_of(kobj, struct device, kobj);
 739	struct mmc_card *card = mmc_dev_to_card(dev);
 740
 741	/* CIS vendor and device ids are available only for Combo cards */
 742	if ((attr == &dev_attr_vendor.attr || attr == &dev_attr_device.attr) &&
 743	    card->type != MMC_TYPE_SD_COMBO)
 744		return 0;
 745
 746	return attr->mode;
 747}
 748
 749static const struct attribute_group sd_std_group = {
 750	.attrs = sd_std_attrs,
 751	.is_visible = sd_std_is_visible,
 752};
 753__ATTRIBUTE_GROUPS(sd_std);
 754
 755struct device_type sd_type = {
 756	.groups = sd_std_groups,
 757};
 758
 759/*
 760 * Fetch CID from card.
 761 */
 762int mmc_sd_get_cid(struct mmc_host *host, u32 ocr, u32 *cid, u32 *rocr)
 763{
 764	int err;
 765	u32 max_current;
 766	int retries = 10;
 767	u32 pocr = ocr;
 768
 769try_again:
 770	if (!retries) {
 771		ocr &= ~SD_OCR_S18R;
 772		pr_warn("%s: Skipping voltage switch\n", mmc_hostname(host));
 773	}
 774
 775	/*
 776	 * Since we're changing the OCR value, we seem to
 777	 * need to tell some cards to go back to the idle
 778	 * state.  We wait 1ms to give cards time to
 779	 * respond.
 780	 */
 781	mmc_go_idle(host);
 782
 783	/*
 784	 * If SD_SEND_IF_COND indicates an SD 2.0
 785	 * compliant card and we should set bit 30
 786	 * of the ocr to indicate that we can handle
 787	 * block-addressed SDHC cards.
 788	 */
 789	err = mmc_send_if_cond(host, ocr);
 790	if (!err)
 791		ocr |= SD_OCR_CCS;
 792
 793	/*
 794	 * If the host supports one of UHS-I modes, request the card
 795	 * to switch to 1.8V signaling level. If the card has failed
 796	 * repeatedly to switch however, skip this.
 797	 */
 798	if (retries && mmc_host_uhs(host))
 799		ocr |= SD_OCR_S18R;
 800
 801	/*
 802	 * If the host can supply more than 150mA at current voltage,
 803	 * XPC should be set to 1.
 804	 */
 805	max_current = sd_get_host_max_current(host);
 806	if (max_current > 150)
 807		ocr |= SD_OCR_XPC;
 808
 809	err = mmc_send_app_op_cond(host, ocr, rocr);
 810	if (err)
 811		return err;
 812
 813	/*
 814	 * In case CCS and S18A in the response is set, start Signal Voltage
 815	 * Switch procedure. SPI mode doesn't support CMD11.
 816	 */
 817	if (!mmc_host_is_spi(host) && rocr &&
 818	   ((*rocr & 0x41000000) == 0x41000000)) {
 819		err = mmc_set_uhs_voltage(host, pocr);
 820		if (err == -EAGAIN) {
 821			retries--;
 822			goto try_again;
 823		} else if (err) {
 824			retries = 0;
 825			goto try_again;
 826		}
 827	}
 828
 829	err = mmc_send_cid(host, cid);
 830	return err;
 831}
 832
 833int mmc_sd_get_csd(struct mmc_host *host, struct mmc_card *card)
 834{
 835	int err;
 836
 837	/*
 838	 * Fetch CSD from card.
 839	 */
 840	err = mmc_send_csd(card, card->raw_csd);
 841	if (err)
 842		return err;
 843
 844	err = mmc_decode_csd(card);
 845	if (err)
 846		return err;
 847
 848	return 0;
 849}
 850
 851static int mmc_sd_get_ro(struct mmc_host *host)
 852{
 853	int ro;
 854
 855	/*
 856	 * Some systems don't feature a write-protect pin and don't need one.
 857	 * E.g. because they only have micro-SD card slot. For those systems
 858	 * assume that the SD card is always read-write.
 859	 */
 860	if (host->caps2 & MMC_CAP2_NO_WRITE_PROTECT)
 861		return 0;
 862
 863	if (!host->ops->get_ro)
 864		return -1;
 865
 866	ro = host->ops->get_ro(host);
 867
 868	return ro;
 869}
 870
 871int mmc_sd_setup_card(struct mmc_host *host, struct mmc_card *card,
 872	bool reinit)
 873{
 874	int err;
 875
 876	if (!reinit) {
 877		/*
 878		 * Fetch SCR from card.
 879		 */
 880		err = mmc_app_send_scr(card);
 881		if (err)
 882			return err;
 883
 884		err = mmc_decode_scr(card);
 885		if (err)
 886			return err;
 887
 888		/*
 889		 * Fetch and process SD Status register.
 890		 */
 891		err = mmc_read_ssr(card);
 892		if (err)
 893			return err;
 894
 895		/* Erase init depends on CSD and SSR */
 896		mmc_init_erase(card);
 897
 898		/*
 899		 * Fetch switch information from card.
 900		 */
 901		err = mmc_read_switch(card);
 902		if (err)
 903			return err;
 904	}
 905
 906	/*
 907	 * For SPI, enable CRC as appropriate.
 908	 * This CRC enable is located AFTER the reading of the
 909	 * card registers because some SDHC cards are not able
 910	 * to provide valid CRCs for non-512-byte blocks.
 911	 */
 912	if (mmc_host_is_spi(host)) {
 913		err = mmc_spi_set_crc(host, use_spi_crc);
 914		if (err)
 915			return err;
 916	}
 917
 918	/*
 919	 * Check if read-only switch is active.
 920	 */
 921	if (!reinit) {
 922		int ro = mmc_sd_get_ro(host);
 923
 924		if (ro < 0) {
 925			pr_warn("%s: host does not support reading read-only switch, assuming write-enable\n",
 926				mmc_hostname(host));
 927		} else if (ro > 0) {
 928			mmc_card_set_readonly(card);
 929		}
 930	}
 931
 932	return 0;
 933}
 934
 935unsigned mmc_sd_get_max_clock(struct mmc_card *card)
 936{
 937	unsigned max_dtr = (unsigned int)-1;
 938
 939	if (mmc_card_hs(card)) {
 940		if (max_dtr > card->sw_caps.hs_max_dtr)
 941			max_dtr = card->sw_caps.hs_max_dtr;
 942	} else if (max_dtr > card->csd.max_dtr) {
 943		max_dtr = card->csd.max_dtr;
 944	}
 945
 946	return max_dtr;
 947}
 948
 949static bool mmc_sd_card_using_v18(struct mmc_card *card)
 950{
 951	/*
 952	 * According to the SD spec., the Bus Speed Mode (function group 1) bits
 953	 * 2 to 4 are zero if the card is initialized at 3.3V signal level. Thus
 954	 * they can be used to determine if the card has already switched to
 955	 * 1.8V signaling.
 956	 */
 957	return card->sw_caps.sd3_bus_mode &
 958	       (SD_MODE_UHS_SDR50 | SD_MODE_UHS_SDR104 | SD_MODE_UHS_DDR50);
 959}
 960
 961/*
 962 * Handle the detection and initialisation of a card.
 963 *
 964 * In the case of a resume, "oldcard" will contain the card
 965 * we're trying to reinitialise.
 966 */
 967static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
 968	struct mmc_card *oldcard)
 969{
 970	struct mmc_card *card;
 971	int err;
 972	u32 cid[4];
 973	u32 rocr = 0;
 974	bool v18_fixup_failed = false;
 975
 976	WARN_ON(!host->claimed);
 977retry:
 978	err = mmc_sd_get_cid(host, ocr, cid, &rocr);
 979	if (err)
 980		return err;
 981
 982	if (oldcard) {
 983		if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0) {
 984			pr_debug("%s: Perhaps the card was replaced\n",
 985				mmc_hostname(host));
 986			return -ENOENT;
 987		}
 988
 989		card = oldcard;
 990	} else {
 991		/*
 992		 * Allocate card structure.
 993		 */
 994		card = mmc_alloc_card(host, &sd_type);
 995		if (IS_ERR(card))
 996			return PTR_ERR(card);
 997
 998		card->ocr = ocr;
 999		card->type = MMC_TYPE_SD;
1000		memcpy(card->raw_cid, cid, sizeof(card->raw_cid));
1001	}
1002
1003	/*
1004	 * Call the optional HC's init_card function to handle quirks.
1005	 */
1006	if (host->ops->init_card)
1007		host->ops->init_card(host, card);
1008
1009	/*
1010	 * For native busses:  get card RCA and quit open drain mode.
1011	 */
1012	if (!mmc_host_is_spi(host)) {
1013		err = mmc_send_relative_addr(host, &card->rca);
1014		if (err)
1015			goto free_card;
1016	}
1017
1018	if (!oldcard) {
1019		err = mmc_sd_get_csd(host, card);
1020		if (err)
1021			goto free_card;
1022
1023		mmc_decode_cid(card);
1024	}
1025
1026	/*
1027	 * handling only for cards supporting DSR and hosts requesting
1028	 * DSR configuration
1029	 */
1030	if (card->csd.dsr_imp && host->dsr_req)
1031		mmc_set_dsr(host);
1032
1033	/*
1034	 * Select card, as all following commands rely on that.
1035	 */
1036	if (!mmc_host_is_spi(host)) {
1037		err = mmc_select_card(card);
1038		if (err)
1039			goto free_card;
1040	}
1041
1042	err = mmc_sd_setup_card(host, card, oldcard != NULL);
1043	if (err)
1044		goto free_card;
1045
1046	/*
1047	 * If the card has not been power cycled, it may still be using 1.8V
1048	 * signaling. Detect that situation and try to initialize a UHS-I (1.8V)
1049	 * transfer mode.
1050	 */
1051	if (!v18_fixup_failed && !mmc_host_is_spi(host) && mmc_host_uhs(host) &&
1052	    mmc_sd_card_using_v18(card) &&
1053	    host->ios.signal_voltage != MMC_SIGNAL_VOLTAGE_180) {
1054		/*
1055		 * Re-read switch information in case it has changed since
1056		 * oldcard was initialized.
1057		 */
1058		if (oldcard) {
1059			err = mmc_read_switch(card);
1060			if (err)
1061				goto free_card;
1062		}
1063		if (mmc_sd_card_using_v18(card)) {
1064			if (mmc_host_set_uhs_voltage(host) ||
1065			    mmc_sd_init_uhs_card(card)) {
1066				v18_fixup_failed = true;
1067				mmc_power_cycle(host, ocr);
1068				if (!oldcard)
1069					mmc_remove_card(card);
1070				goto retry;
1071			}
1072			goto done;
1073		}
1074	}
1075
1076	/* Initialization sequence for UHS-I cards */
1077	if (rocr & SD_ROCR_S18A && mmc_host_uhs(host)) {
1078		err = mmc_sd_init_uhs_card(card);
1079		if (err)
1080			goto free_card;
1081	} else {
1082		/*
1083		 * Attempt to change to high-speed (if supported)
1084		 */
1085		err = mmc_sd_switch_hs(card);
1086		if (err > 0)
1087			mmc_set_timing(card->host, MMC_TIMING_SD_HS);
1088		else if (err)
1089			goto free_card;
1090
1091		/*
1092		 * Set bus speed.
1093		 */
1094		mmc_set_clock(host, mmc_sd_get_max_clock(card));
1095
1096		/*
1097		 * Switch to wider bus (if supported).
1098		 */
1099		if ((host->caps & MMC_CAP_4_BIT_DATA) &&
1100			(card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {
1101			err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
1102			if (err)
1103				goto free_card;
1104
1105			mmc_set_bus_width(host, MMC_BUS_WIDTH_4);
1106		}
1107	}
1108
1109	if (host->cqe_ops && !host->cqe_enabled) {
1110		err = host->cqe_ops->cqe_enable(host, card);
1111		if (!err) {
1112			host->cqe_enabled = true;
1113			host->hsq_enabled = true;
1114			pr_info("%s: Host Software Queue enabled\n",
1115				mmc_hostname(host));
1116		}
1117	}
1118
1119	if (host->caps2 & MMC_CAP2_AVOID_3_3V &&
1120	    host->ios.signal_voltage == MMC_SIGNAL_VOLTAGE_330) {
1121		pr_err("%s: Host failed to negotiate down from 3.3V\n",
1122			mmc_hostname(host));
1123		err = -EINVAL;
1124		goto free_card;
1125	}
1126done:
1127	host->card = card;
1128	return 0;
1129
1130free_card:
1131	if (!oldcard)
1132		mmc_remove_card(card);
1133
1134	return err;
1135}
1136
1137/*
1138 * Host is being removed. Free up the current card.
1139 */
1140static void mmc_sd_remove(struct mmc_host *host)
1141{
1142	mmc_remove_card(host->card);
1143	host->card = NULL;
1144}
1145
1146/*
1147 * Card detection - card is alive.
1148 */
1149static int mmc_sd_alive(struct mmc_host *host)
1150{
1151	return mmc_send_status(host->card, NULL);
1152}
1153
1154/*
1155 * Card detection callback from host.
1156 */
1157static void mmc_sd_detect(struct mmc_host *host)
1158{
1159	int err;
1160
1161	mmc_get_card(host->card, NULL);
1162
1163	/*
1164	 * Just check if our card has been removed.
1165	 */
1166	err = _mmc_detect_card_removed(host);
1167
1168	mmc_put_card(host->card, NULL);
1169
1170	if (err) {
1171		mmc_sd_remove(host);
1172
1173		mmc_claim_host(host);
1174		mmc_detach_bus(host);
1175		mmc_power_off(host);
1176		mmc_release_host(host);
1177	}
1178}
1179
1180static int _mmc_sd_suspend(struct mmc_host *host)
1181{
1182	int err = 0;
1183
1184	mmc_claim_host(host);
1185
1186	if (mmc_card_suspended(host->card))
1187		goto out;
1188
1189	if (!mmc_host_is_spi(host))
1190		err = mmc_deselect_cards(host);
1191
1192	if (!err) {
1193		mmc_power_off(host);
1194		mmc_card_set_suspended(host->card);
1195	}
1196
1197out:
1198	mmc_release_host(host);
1199	return err;
1200}
1201
1202/*
1203 * Callback for suspend
1204 */
1205static int mmc_sd_suspend(struct mmc_host *host)
1206{
1207	int err;
1208
1209	err = _mmc_sd_suspend(host);
1210	if (!err) {
1211		pm_runtime_disable(&host->card->dev);
1212		pm_runtime_set_suspended(&host->card->dev);
1213	}
1214
1215	return err;
1216}
1217
1218/*
1219 * This function tries to determine if the same card is still present
1220 * and, if so, restore all state to it.
1221 */
1222static int _mmc_sd_resume(struct mmc_host *host)
1223{
1224	int err = 0;
1225
1226	mmc_claim_host(host);
1227
1228	if (!mmc_card_suspended(host->card))
1229		goto out;
1230
1231	mmc_power_up(host, host->card->ocr);
1232	err = mmc_sd_init_card(host, host->card->ocr, host->card);
1233	mmc_card_clr_suspended(host->card);
1234
1235out:
1236	mmc_release_host(host);
1237	return err;
1238}
1239
1240/*
1241 * Callback for resume
1242 */
1243static int mmc_sd_resume(struct mmc_host *host)
1244{
1245	pm_runtime_enable(&host->card->dev);
1246	return 0;
1247}
1248
1249/*
1250 * Callback for runtime_suspend.
1251 */
1252static int mmc_sd_runtime_suspend(struct mmc_host *host)
1253{
1254	int err;
1255
1256	if (!(host->caps & MMC_CAP_AGGRESSIVE_PM))
1257		return 0;
1258
1259	err = _mmc_sd_suspend(host);
1260	if (err)
1261		pr_err("%s: error %d doing aggressive suspend\n",
1262			mmc_hostname(host), err);
1263
1264	return err;
1265}
1266
1267/*
1268 * Callback for runtime_resume.
1269 */
1270static int mmc_sd_runtime_resume(struct mmc_host *host)
1271{
1272	int err;
1273
1274	err = _mmc_sd_resume(host);
1275	if (err && err != -ENOMEDIUM)
1276		pr_err("%s: error %d doing runtime resume\n",
1277			mmc_hostname(host), err);
1278
1279	return 0;
1280}
1281
1282static int mmc_sd_hw_reset(struct mmc_host *host)
1283{
1284	mmc_power_cycle(host, host->card->ocr);
1285	return mmc_sd_init_card(host, host->card->ocr, host->card);
1286}
1287
1288static const struct mmc_bus_ops mmc_sd_ops = {
1289	.remove = mmc_sd_remove,
1290	.detect = mmc_sd_detect,
1291	.runtime_suspend = mmc_sd_runtime_suspend,
1292	.runtime_resume = mmc_sd_runtime_resume,
1293	.suspend = mmc_sd_suspend,
1294	.resume = mmc_sd_resume,
1295	.alive = mmc_sd_alive,
1296	.shutdown = mmc_sd_suspend,
1297	.hw_reset = mmc_sd_hw_reset,
1298};
1299
1300/*
1301 * Starting point for SD card init.
1302 */
1303int mmc_attach_sd(struct mmc_host *host)
1304{
1305	int err;
1306	u32 ocr, rocr;
1307
1308	WARN_ON(!host->claimed);
1309
1310	err = mmc_send_app_op_cond(host, 0, &ocr);
1311	if (err)
1312		return err;
1313
1314	mmc_attach_bus(host, &mmc_sd_ops);
1315	if (host->ocr_avail_sd)
1316		host->ocr_avail = host->ocr_avail_sd;
1317
1318	/*
1319	 * We need to get OCR a different way for SPI.
1320	 */
1321	if (mmc_host_is_spi(host)) {
1322		mmc_go_idle(host);
1323
1324		err = mmc_spi_read_ocr(host, 0, &ocr);
1325		if (err)
1326			goto err;
1327	}
1328
1329	/*
1330	 * Some SD cards claims an out of spec VDD voltage range. Let's treat
1331	 * these bits as being in-valid and especially also bit7.
1332	 */
1333	ocr &= ~0x7FFF;
1334
1335	rocr = mmc_select_voltage(host, ocr);
1336
1337	/*
1338	 * Can we support the voltage(s) of the card(s)?
1339	 */
1340	if (!rocr) {
1341		err = -EINVAL;
1342		goto err;
1343	}
1344
1345	/*
1346	 * Detect and init the card.
1347	 */
1348	err = mmc_sd_init_card(host, rocr, NULL);
1349	if (err)
1350		goto err;
1351
1352	mmc_release_host(host);
1353	err = mmc_add_card(host->card);
1354	if (err)
1355		goto remove_card;
1356
1357	mmc_claim_host(host);
1358	return 0;
1359
1360remove_card:
1361	mmc_remove_card(host->card);
1362	host->card = NULL;
1363	mmc_claim_host(host);
1364err:
1365	mmc_detach_bus(host);
1366
1367	pr_err("%s: error %d whilst initialising SD card\n",
1368		mmc_hostname(host), err);
1369
1370	return err;
1371}