sd.c 14 KB
Newer Older
Pierre Ossman's avatar
Pierre Ossman committed
1
/*
2
 *  linux/drivers/mmc/core/sd.c
Pierre Ossman's avatar
Pierre Ossman committed
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
 *
 *  Copyright (C) 2003-2004 Russell King, All Rights Reserved.
 *  SD support Copyright (C) 2004 Ian Molton, All Rights Reserved.
 *  Copyright (C) 2005-2007 Pierre Ossman, All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/err.h>

#include <linux/mmc/host.h>
#include <linux/mmc/card.h>
#include <linux/mmc/mmc.h>
18
#include <linux/mmc/sd.h>
Pierre Ossman's avatar
Pierre Ossman committed
19 20 21

#include "core.h"
#include "sysfs.h"
Pierre Ossman's avatar
Pierre Ossman committed
22
#include "bus.h"
Pierre Ossman's avatar
Pierre Ossman committed
23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90
#include "mmc_ops.h"
#include "sd_ops.h"

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

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

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

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

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

/*
 * Given the decoded CSD structure, decode the raw CID to our CID structure.
 */
static void mmc_decode_cid(struct mmc_card *card)
{
	u32 *resp = card->raw_cid;

	memset(&card->cid, 0, sizeof(struct mmc_cid));

	/*
	 * SD doesn't currently have a version field so we will
	 * have to assume we can parse this.
	 */
	card->cid.manfid		= UNSTUFF_BITS(resp, 120, 8);
	card->cid.oemid			= UNSTUFF_BITS(resp, 104, 16);
	card->cid.prod_name[0]		= UNSTUFF_BITS(resp, 96, 8);
	card->cid.prod_name[1]		= UNSTUFF_BITS(resp, 88, 8);
	card->cid.prod_name[2]		= UNSTUFF_BITS(resp, 80, 8);
	card->cid.prod_name[3]		= UNSTUFF_BITS(resp, 72, 8);
	card->cid.prod_name[4]		= UNSTUFF_BITS(resp, 64, 8);
	card->cid.hwrev			= UNSTUFF_BITS(resp, 60, 4);
	card->cid.fwrev			= UNSTUFF_BITS(resp, 56, 4);
	card->cid.serial		= UNSTUFF_BITS(resp, 24, 32);
	card->cid.year			= UNSTUFF_BITS(resp, 12, 8);
	card->cid.month			= UNSTUFF_BITS(resp, 8, 4);

	card->cid.year += 2000; /* SD cards year offset */
}

/*
 * Given a 128-bit response, decode to our card CSD structure.
 */
Pierre Ossman's avatar
Pierre Ossman committed
91
static int mmc_decode_csd(struct mmc_card *card)
Pierre Ossman's avatar
Pierre Ossman committed
92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151
{
	struct mmc_csd *csd = &card->csd;
	unsigned int e, m, csd_struct;
	u32 *resp = card->raw_csd;

	csd_struct = UNSTUFF_BITS(resp, 126, 2);

	switch (csd_struct) {
	case 0:
		m = UNSTUFF_BITS(resp, 115, 4);
		e = UNSTUFF_BITS(resp, 112, 3);
		csd->tacc_ns	 = (tacc_exp[e] * tacc_mant[m] + 9) / 10;
		csd->tacc_clks	 = UNSTUFF_BITS(resp, 104, 8) * 100;

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

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

		csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4);
		csd->read_partial = UNSTUFF_BITS(resp, 79, 1);
		csd->write_misalign = UNSTUFF_BITS(resp, 78, 1);
		csd->read_misalign = UNSTUFF_BITS(resp, 77, 1);
		csd->r2w_factor = UNSTUFF_BITS(resp, 26, 3);
		csd->write_blkbits = UNSTUFF_BITS(resp, 22, 4);
		csd->write_partial = UNSTUFF_BITS(resp, 21, 1);
		break;
	case 1:
		/*
		 * This is a block-addressed SDHC card. Most
		 * interesting fields are unused and have fixed
		 * values. To avoid getting tripped by buggy cards,
		 * we assume those fixed values ourselves.
		 */
		mmc_card_set_blockaddr(card);

		csd->tacc_ns	 = 0; /* Unused */
		csd->tacc_clks	 = 0; /* Unused */

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

		m = UNSTUFF_BITS(resp, 48, 22);
		csd->capacity     = (1 + m) << 10;

		csd->read_blkbits = 9;
		csd->read_partial = 0;
		csd->write_misalign = 0;
		csd->read_misalign = 0;
		csd->r2w_factor = 4; /* Unused */
		csd->write_blkbits = 9;
		csd->write_partial = 0;
		break;
	default:
152
		printk(KERN_ERR "%s: unrecognised CSD structure version %d\n",
Pierre Ossman's avatar
Pierre Ossman committed
153
			mmc_hostname(card->host), csd_struct);
Pierre Ossman's avatar
Pierre Ossman committed
154
		return -EINVAL;
Pierre Ossman's avatar
Pierre Ossman committed
155
	}
Pierre Ossman's avatar
Pierre Ossman committed
156 157

	return 0;
Pierre Ossman's avatar
Pierre Ossman committed
158 159 160 161 162
}

/*
 * Given a 64-bit response, decode to our card SCR structure.
 */
Pierre Ossman's avatar
Pierre Ossman committed
163
static int mmc_decode_scr(struct mmc_card *card)
Pierre Ossman's avatar
Pierre Ossman committed
164 165 166 167 168 169 170 171 172 173 174 175
{
	struct sd_scr *scr = &card->scr;
	unsigned int scr_struct;
	u32 resp[4];

	BUG_ON(!mmc_card_sd(card));

	resp[3] = card->raw_scr[1];
	resp[2] = card->raw_scr[0];

	scr_struct = UNSTUFF_BITS(resp, 60, 4);
	if (scr_struct != 0) {
176
		printk(KERN_ERR "%s: unrecognised SCR structure version %d\n",
Pierre Ossman's avatar
Pierre Ossman committed
177
			mmc_hostname(card->host), scr_struct);
Pierre Ossman's avatar
Pierre Ossman committed
178
		return -EINVAL;
Pierre Ossman's avatar
Pierre Ossman committed
179 180 181 182
	}

	scr->sda_vsn = UNSTUFF_BITS(resp, 56, 4);
	scr->bus_widths = UNSTUFF_BITS(resp, 48, 4);
Pierre Ossman's avatar
Pierre Ossman committed
183 184

	return 0;
Pierre Ossman's avatar
Pierre Ossman committed
185 186 187
}

/*
188
 * Fetches and decodes switch information
Pierre Ossman's avatar
Pierre Ossman committed
189
 */
190
static int mmc_read_switch(struct mmc_card *card)
Pierre Ossman's avatar
Pierre Ossman committed
191 192 193 194
{
	int err;
	u8 *status;

195
	if (card->scr.sda_vsn < SCR_SPEC_VER_1)
196
		return 0;
197 198 199 200 201

	if (!(card->csd.cmdclass & CCC_SWITCH)) {
		printk(KERN_WARNING "%s: card lacks mandatory switch "
			"function, performance might suffer.\n",
			mmc_hostname(card->host));
202
		return 0;
203 204
	}

205
	err = -EIO;
Pierre Ossman's avatar
Pierre Ossman committed
206 207 208

	status = kmalloc(64, GFP_KERNEL);
	if (!status) {
209 210
		printk(KERN_ERR "%s: could not allocate a buffer for "
			"switch capabilities.\n", mmc_hostname(card->host));
211
		return -ENOMEM;
Pierre Ossman's avatar
Pierre Ossman committed
212 213 214
	}

	err = mmc_sd_switch(card, 0, 0, 1, status);
215
	if (err) {
216 217 218
		printk(KERN_WARNING "%s: problem reading switch "
			"capabilities, performance might suffer.\n",
			mmc_hostname(card->host));
219
		err = 0;
Pierre Ossman's avatar
Pierre Ossman committed
220 221 222 223 224 225
		goto out;
	}

	if (status[13] & 0x02)
		card->sw_caps.hs_max_dtr = 50000000;

226 227 228 229 230 231 232 233 234 235 236 237 238 239
out:
	kfree(status);

	return err;
}

/*
 * Test if the card supports high-speed mode and, if so, switch to it.
 */
static int mmc_switch_hs(struct mmc_card *card)
{
	int err;
	u8 *status;

240
	if (card->scr.sda_vsn < SCR_SPEC_VER_1)
241
		return 0;
242 243

	if (!(card->csd.cmdclass & CCC_SWITCH))
244
		return 0;
245

246
	if (!(card->host->caps & MMC_CAP_SD_HIGHSPEED))
247
		return 0;
248 249

	if (card->sw_caps.hs_max_dtr == 0)
250
		return 0;
251

252
	err = -EIO;
253 254 255

	status = kmalloc(64, GFP_KERNEL);
	if (!status) {
256 257
		printk(KERN_ERR "%s: could not allocate a buffer for "
			"switch capabilities.\n", mmc_hostname(card->host));
258
		return -ENOMEM;
259 260
	}

Pierre Ossman's avatar
Pierre Ossman committed
261
	err = mmc_sd_switch(card, 1, 0, 1, status);
262
	if (err)
Pierre Ossman's avatar
Pierre Ossman committed
263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280
		goto out;

	if ((status[16] & 0xF) != 1) {
		printk(KERN_WARNING "%s: Problem switching card "
			"into high-speed mode!\n",
			mmc_hostname(card->host));
	} else {
		mmc_card_set_highspeed(card);
		mmc_set_timing(card->host, MMC_TIMING_SD_HS);
	}

out:
	kfree(status);

	return err;
}

/*
281 282 283 284
 * Handle the detection and initialisation of a card.
 *
 * In the case of a resume, "curcard" will contain the card
 * we're trying to reinitialise.
Pierre Ossman's avatar
Pierre Ossman committed
285
 */
286 287
static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
	struct mmc_card *oldcard)
Pierre Ossman's avatar
Pierre Ossman committed
288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310
{
	struct mmc_card *card;
	int err;
	u32 cid[4];
	unsigned int max_dtr;

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

	/*
	 * Since we're changing the OCR value, we seem to
	 * need to tell some cards to go back to the idle
	 * state.  We wait 1ms to give cards time to
	 * respond.
	 */
	mmc_go_idle(host);

	/*
	 * If SD_SEND_IF_COND indicates an SD 2.0
	 * compliant card and we should set bit 30
	 * of the ocr to indicate that we can handle
	 * block-addressed SDHC cards.
	 */
311
	err = mmc_send_if_cond(host, ocr);
312
	if (!err)
313
		ocr |= 1 << 30;
Pierre Ossman's avatar
Pierre Ossman committed
314

315
	err = mmc_send_app_op_cond(host, ocr, NULL);
316
	if (err)
317
		goto err;
Pierre Ossman's avatar
Pierre Ossman committed
318 319 320 321 322

	/*
	 * Fetch CID from card.
	 */
	err = mmc_all_send_cid(host, cid);
323
	if (err)
Pierre Ossman's avatar
Pierre Ossman committed
324 325
		goto err;

326 327 328
	if (oldcard) {
		if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0)
			goto err;
Pierre Ossman's avatar
Pierre Ossman committed
329

330 331 332 333 334 335 336 337 338 339 340 341
		card = oldcard;
	} else {
		/*
		 * Allocate card structure.
		 */
		card = mmc_alloc_card(host);
		if (IS_ERR(card))
			goto err;

		card->type = MMC_TYPE_SD;
		memcpy(card->raw_cid, cid, sizeof(card->raw_cid));
	}
Pierre Ossman's avatar
Pierre Ossman committed
342 343 344 345 346

	/*
	 * Set card RCA.
	 */
	err = mmc_send_relative_addr(host, &card->rca);
347
	if (err)
Pierre Ossman's avatar
Pierre Ossman committed
348 349 350 351
		goto free_card;

	mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL);

352 353 354 355 356
	if (!oldcard) {
		/*
		 * Fetch CSD from card.
		 */
		err = mmc_send_csd(card, card->raw_csd);
357
		if (err)
358
			goto free_card;
Pierre Ossman's avatar
Pierre Ossman committed
359

Pierre Ossman's avatar
Pierre Ossman committed
360 361 362 363
		err = mmc_decode_csd(card);
		if (err < 0)
			goto free_card;

364 365
		mmc_decode_cid(card);
	}
Pierre Ossman's avatar
Pierre Ossman committed
366 367

	/*
368
	 * Select card, as all following commands rely on that.
Pierre Ossman's avatar
Pierre Ossman committed
369 370
	 */
	err = mmc_select_card(card);
371
	if (err)
Pierre Ossman's avatar
Pierre Ossman committed
372 373
		goto free_card;

374 375 376 377 378
	if (!oldcard) {
		/*
		 * Fetch SCR from card.
		 */
		err = mmc_app_send_scr(card, card->raw_scr);
379
		if (err)
380
			goto free_card;
Pierre Ossman's avatar
Pierre Ossman committed
381

Pierre Ossman's avatar
Pierre Ossman committed
382 383 384
		err = mmc_decode_scr(card);
		if (err < 0)
			goto free_card;
Pierre Ossman's avatar
Pierre Ossman committed
385

386 387 388 389
		/*
		 * Fetch switch information from card.
		 */
		err = mmc_read_switch(card);
390
		if (err)
391 392
			goto free_card;
	}
393 394 395

	/*
	 * Attempt to change to high-speed (if supported)
Pierre Ossman's avatar
Pierre Ossman committed
396 397
	 */
	err = mmc_switch_hs(card);
398
	if (err)
Pierre Ossman's avatar
Pierre Ossman committed
399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417
		goto free_card;

	/*
	 * Compute bus speed.
	 */
	max_dtr = (unsigned int)-1;

	if (mmc_card_highspeed(card)) {
		if (max_dtr > card->sw_caps.hs_max_dtr)
			max_dtr = card->sw_caps.hs_max_dtr;
	} else if (max_dtr > card->csd.max_dtr) {
		max_dtr = card->csd.max_dtr;
	}

	mmc_set_clock(host, max_dtr);

	/*
	 * Switch to wider bus (if supported).
	 */
Pierre Ossman's avatar
Pierre Ossman committed
418
	if ((host->caps & MMC_CAP_4_BIT_DATA) &&
Pierre Ossman's avatar
Pierre Ossman committed
419 420
		(card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {
		err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
421
		if (err)
Pierre Ossman's avatar
Pierre Ossman committed
422 423 424 425 426
			goto free_card;

		mmc_set_bus_width(host, MMC_BUS_WIDTH_4);
	}

427 428 429 430 431 432 433 434 435 436 437 438 439 440 441
	/*
	 * Check if read-only switch is active.
	 */
	if (!oldcard) {
		if (!host->ops->get_ro) {
			printk(KERN_WARNING "%s: host does not "
				"support reading read-only "
				"switch. assuming write-enable.\n",
				mmc_hostname(host));
		} else {
			if (host->ops->get_ro(host))
				mmc_card_set_readonly(card);
		}
	}

442 443 444
	if (!oldcard)
		host->card = card;

445
	return 0;
446 447 448 449 450 451

free_card:
	if (!oldcard)
		mmc_remove_card(card);
err:

452
	return -EIO;
453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482
}

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

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

/*
 * Card detection callback from host.
 */
static void mmc_sd_detect(struct mmc_host *host)
{
	int err;

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

	mmc_claim_host(host);

	/*
	 * Just check if our card has been removed.
	 */
	err = mmc_send_status(host->card, NULL);
Pierre Ossman's avatar
Pierre Ossman committed
483 484 485

	mmc_release_host(host);

486
	if (err) {
Pierre Ossman's avatar
Pierre Ossman committed
487
		mmc_sd_remove(host);
488 489 490 491 492 493 494

		mmc_claim_host(host);
		mmc_detach_bus(host);
		mmc_release_host(host);
	}
}

Pierre Ossman's avatar
Pierre Ossman committed
495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543
MMC_ATTR_FN(cid, "%08x%08x%08x%08x\n", card->raw_cid[0], card->raw_cid[1],
	card->raw_cid[2], card->raw_cid[3]);
MMC_ATTR_FN(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1],
	card->raw_csd[2], card->raw_csd[3]);
MMC_ATTR_FN(scr, "%08x%08x\n", card->raw_scr[0], card->raw_scr[1]);
MMC_ATTR_FN(date, "%02d/%04d\n", card->cid.month, card->cid.year);
MMC_ATTR_FN(fwrev, "0x%x\n", card->cid.fwrev);
MMC_ATTR_FN(hwrev, "0x%x\n", card->cid.hwrev);
MMC_ATTR_FN(manfid, "0x%06x\n", card->cid.manfid);
MMC_ATTR_FN(name, "%s\n", card->cid.prod_name);
MMC_ATTR_FN(oemid, "0x%04x\n", card->cid.oemid);
MMC_ATTR_FN(serial, "0x%08x\n", card->cid.serial);

static struct device_attribute mmc_sd_dev_attrs[] = {
	MMC_ATTR_RO(cid),
	MMC_ATTR_RO(csd),
	MMC_ATTR_RO(scr),
	MMC_ATTR_RO(date),
	MMC_ATTR_RO(fwrev),
	MMC_ATTR_RO(hwrev),
	MMC_ATTR_RO(manfid),
	MMC_ATTR_RO(name),
	MMC_ATTR_RO(oemid),
	MMC_ATTR_RO(serial),
	__ATTR_NULL,
};

/*
 * Adds sysfs entries as relevant.
 */
static int mmc_sd_sysfs_add(struct mmc_host *host, struct mmc_card *card)
{
	int ret;

	ret = mmc_add_attrs(card, mmc_sd_dev_attrs);
	if (ret < 0)
		return ret;

	return 0;
}

/*
 * Removes the sysfs entries added by mmc_sysfs_add().
 */
static void mmc_sd_sysfs_remove(struct mmc_host *host, struct mmc_card *card)
{
	mmc_remove_attrs(card, mmc_sd_dev_attrs);
}

544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574
#ifdef CONFIG_MMC_UNSAFE_RESUME

/*
 * Suspend callback from host.
 */
static void mmc_sd_suspend(struct mmc_host *host)
{
	BUG_ON(!host);
	BUG_ON(!host->card);

	mmc_claim_host(host);
	mmc_deselect_cards(host);
	host->card->state &= ~MMC_STATE_HIGHSPEED;
	mmc_release_host(host);
}

/*
 * Resume callback from host.
 *
 * This function tries to determine if the same card is still present
 * and, if so, restore all state to it.
 */
static void mmc_sd_resume(struct mmc_host *host)
{
	int err;

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

	mmc_claim_host(host);
	err = mmc_sd_init_card(host, host->ocr, host->card);
575 576
	mmc_release_host(host);

577
	if (err) {
Pierre Ossman's avatar
Pierre Ossman committed
578
		mmc_sd_remove(host);
579 580

		mmc_claim_host(host);
581
		mmc_detach_bus(host);
582
		mmc_release_host(host);
583 584 585 586 587 588 589 590 591 592 593 594 595 596
	}

}

#else

#define mmc_sd_suspend NULL
#define mmc_sd_resume NULL

#endif

static const struct mmc_bus_ops mmc_sd_ops = {
	.remove = mmc_sd_remove,
	.detect = mmc_sd_detect,
Pierre Ossman's avatar
Pierre Ossman committed
597 598
	.sysfs_add = mmc_sd_sysfs_add,
	.sysfs_remove = mmc_sd_sysfs_remove,
599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637
	.suspend = mmc_sd_suspend,
	.resume = mmc_sd_resume,
};

/*
 * Starting point for SD card init.
 */
int mmc_attach_sd(struct mmc_host *host, u32 ocr)
{
	int err;

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

	mmc_attach_bus(host, &mmc_sd_ops);

	/*
	 * Sanity check the voltages that the card claims to
	 * support.
	 */
	if (ocr & 0x7F) {
		printk(KERN_WARNING "%s: card claims to support voltages "
		       "below the defined range. These will be ignored.\n",
		       mmc_hostname(host));
		ocr &= ~0x7F;
	}

	if (ocr & MMC_VDD_165_195) {
		printk(KERN_WARNING "%s: SD card claims to support the "
		       "incompletely defined 'low voltage range'. This "
		       "will be ignored.\n", mmc_hostname(host));
		ocr &= ~MMC_VDD_165_195;
	}

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

	/*
	 * Can we support the voltage(s) of the card(s)?
	 */
638 639
	if (!host->ocr) {
		err = -EINVAL;
640
		goto err;
641
	}
642 643 644 645 646

	/*
	 * Detect and init the card.
	 */
	err = mmc_sd_init_card(host, host->ocr, NULL);
647
	if (err)
648 649 650 651
		goto err;

	mmc_release_host(host);

Pierre Ossman's avatar
Pierre Ossman committed
652
	err = mmc_add_card(host->card);
Pierre Ossman's avatar
Pierre Ossman committed
653
	if (err)
654
		goto remove_card;
Pierre Ossman's avatar
Pierre Ossman committed
655 656 657

	return 0;

658
remove_card:
659
	mmc_remove_card(host->card);
Pierre Ossman's avatar
Pierre Ossman committed
660
	host->card = NULL;
661
	mmc_claim_host(host);
Pierre Ossman's avatar
Pierre Ossman committed
662 663 664 665
err:
	mmc_detach_bus(host);
	mmc_release_host(host);

666 667 668
	printk(KERN_ERR "%s: error %d whilst initialising SD card\n",
		mmc_hostname(host), err);

Pierre Ossman's avatar
Pierre Ossman committed
669 670 671
	return 0;
}