sd.c 14.7 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
{
	struct sd_scr *scr = &card->scr;
	unsigned int scr_struct;
	u32 resp[4];

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

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

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

	return 0;
Pierre Ossman's avatar
Pierre Ossman committed
183 184 185
}

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

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

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

203
	err = -EIO;
Pierre Ossman's avatar
Pierre Ossman committed
204 205 206

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

	err = mmc_sd_switch(card, 0, 0, 1, status);
213
	if (err) {
214 215 216 217 218 219 220
		/*
		 * We all hosts that cannot perform the command
		 * to fail more gracefully
		 */
		if (err != -EINVAL)
			goto out;

221 222 223
		printk(KERN_WARNING "%s: problem reading switch "
			"capabilities, performance might suffer.\n",
			mmc_hostname(card->host));
224
		err = 0;
225

Pierre Ossman's avatar
Pierre Ossman committed
226 227 228 229 230 231
		goto out;
	}

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

232 233 234 235 236 237 238 239 240 241 242 243 244 245
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;

246
	if (card->scr.sda_vsn < SCR_SPEC_VER_1)
247
		return 0;
248 249

	if (!(card->csd.cmdclass & CCC_SWITCH))
250
		return 0;
251

252
	if (!(card->host->caps & MMC_CAP_SD_HIGHSPEED))
253
		return 0;
254 255

	if (card->sw_caps.hs_max_dtr == 0)
256
		return 0;
257

258
	err = -EIO;
259 260 261

	status = kmalloc(64, GFP_KERNEL);
	if (!status) {
262 263
		printk(KERN_ERR "%s: could not allocate a buffer for "
			"switch capabilities.\n", mmc_hostname(card->host));
264
		return -ENOMEM;
265 266
	}

Pierre Ossman's avatar
Pierre Ossman committed
267
	err = mmc_sd_switch(card, 1, 0, 1, status);
268
	if (err)
Pierre Ossman's avatar
Pierre Ossman committed
269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286
		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;
}

/*
287 288 289 290
 * 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
291
 */
292 293
static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
	struct mmc_card *oldcard)
Pierre Ossman's avatar
Pierre Ossman committed
294 295 296 297 298 299 300
{
	struct mmc_card *card;
	int err;
	u32 cid[4];
	unsigned int max_dtr;

	BUG_ON(!host);
301
	WARN_ON(!host->claimed);
Pierre Ossman's avatar
Pierre Ossman committed
302 303 304 305 306 307 308 309 310 311 312 313 314 315 316

	/*
	 * 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.
	 */
317
	err = mmc_send_if_cond(host, ocr);
318
	if (!err)
319
		ocr |= 1 << 30;
Pierre Ossman's avatar
Pierre Ossman committed
320

321
	err = mmc_send_app_op_cond(host, ocr, NULL);
322
	if (err)
323
		goto err;
Pierre Ossman's avatar
Pierre Ossman committed
324

David Brownell's avatar
David Brownell committed
325 326 327 328 329 330 331 332 333
	/*
	 * For SPI, enable CRC as appropriate.
	 */
	if (mmc_host_is_spi(host)) {
		err = mmc_spi_set_crc(host, use_spi_crc);
		if (err)
			goto err;
	}

Pierre Ossman's avatar
Pierre Ossman committed
334 335 336
	/*
	 * Fetch CID from card.
	 */
David Brownell's avatar
David Brownell committed
337 338 339 340
	if (mmc_host_is_spi(host))
		err = mmc_send_cid(host, cid);
	else
		err = mmc_all_send_cid(host, cid);
341
	if (err)
Pierre Ossman's avatar
Pierre Ossman committed
342 343
		goto err;

344
	if (oldcard) {
345 346
		if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0) {
			err = -ENOENT;
347
			goto err;
348
		}
Pierre Ossman's avatar
Pierre Ossman committed
349

350 351 352 353 354 355
		card = oldcard;
	} else {
		/*
		 * Allocate card structure.
		 */
		card = mmc_alloc_card(host);
356 357
		if (IS_ERR(card)) {
			err = PTR_ERR(card);
358
			goto err;
359
		}
360 361 362 363

		card->type = MMC_TYPE_SD;
		memcpy(card->raw_cid, cid, sizeof(card->raw_cid));
	}
Pierre Ossman's avatar
Pierre Ossman committed
364 365

	/*
David Brownell's avatar
David Brownell committed
366
	 * For native busses:  get card RCA and quit open drain mode.
Pierre Ossman's avatar
Pierre Ossman committed
367
	 */
David Brownell's avatar
David Brownell committed
368 369 370 371
	if (!mmc_host_is_spi(host)) {
		err = mmc_send_relative_addr(host, &card->rca);
		if (err)
			goto free_card;
Pierre Ossman's avatar
Pierre Ossman committed
372

David Brownell's avatar
David Brownell committed
373 374
		mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL);
	}
Pierre Ossman's avatar
Pierre Ossman committed
375

376 377 378 379 380
	if (!oldcard) {
		/*
		 * Fetch CSD from card.
		 */
		err = mmc_send_csd(card, card->raw_csd);
381
		if (err)
382
			goto free_card;
Pierre Ossman's avatar
Pierre Ossman committed
383

Pierre Ossman's avatar
Pierre Ossman committed
384
		err = mmc_decode_csd(card);
385
		if (err)
Pierre Ossman's avatar
Pierre Ossman committed
386 387
			goto free_card;

388 389
		mmc_decode_cid(card);
	}
Pierre Ossman's avatar
Pierre Ossman committed
390 391

	/*
392
	 * Select card, as all following commands rely on that.
Pierre Ossman's avatar
Pierre Ossman committed
393
	 */
David Brownell's avatar
David Brownell committed
394 395 396 397 398
	if (!mmc_host_is_spi(host)) {
		err = mmc_select_card(card);
		if (err)
			goto free_card;
	}
Pierre Ossman's avatar
Pierre Ossman committed
399

400 401 402 403 404
	if (!oldcard) {
		/*
		 * Fetch SCR from card.
		 */
		err = mmc_app_send_scr(card, card->raw_scr);
405
		if (err)
406
			goto free_card;
Pierre Ossman's avatar
Pierre Ossman committed
407

Pierre Ossman's avatar
Pierre Ossman committed
408 409 410
		err = mmc_decode_scr(card);
		if (err < 0)
			goto free_card;
Pierre Ossman's avatar
Pierre Ossman committed
411

412 413 414 415
		/*
		 * Fetch switch information from card.
		 */
		err = mmc_read_switch(card);
416
		if (err)
417 418
			goto free_card;
	}
419 420 421

	/*
	 * Attempt to change to high-speed (if supported)
Pierre Ossman's avatar
Pierre Ossman committed
422 423
	 */
	err = mmc_switch_hs(card);
424
	if (err)
Pierre Ossman's avatar
Pierre Ossman committed
425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443
		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
444
	if ((host->caps & MMC_CAP_4_BIT_DATA) &&
Pierre Ossman's avatar
Pierre Ossman committed
445 446
		(card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {
		err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
447
		if (err)
Pierre Ossman's avatar
Pierre Ossman committed
448 449 450 451 452
			goto free_card;

		mmc_set_bus_width(host, MMC_BUS_WIDTH_4);
	}

453 454 455 456 457 458 459 460 461 462 463 464 465 466 467
	/*
	 * 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);
		}
	}

468 469 470
	if (!oldcard)
		host->card = card;

471
	return 0;
472 473 474 475 476 477

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

478
	return err;
479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508
}

/*
 * 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
509 510 511

	mmc_release_host(host);

512
	if (err) {
Pierre Ossman's avatar
Pierre Ossman committed
513
		mmc_sd_remove(host);
514 515 516 517 518 519 520

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

Pierre Ossman's avatar
Pierre Ossman committed
521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 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
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);
}

570 571 572 573 574 575 576 577 578 579 580
#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);
David Brownell's avatar
David Brownell committed
581 582
	if (!mmc_host_is_spi(host))
		mmc_deselect_cards(host);
583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601
	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);
602 603
	mmc_release_host(host);

604
	if (err) {
Pierre Ossman's avatar
Pierre Ossman committed
605
		mmc_sd_remove(host);
606 607

		mmc_claim_host(host);
608
		mmc_detach_bus(host);
609
		mmc_release_host(host);
610 611 612 613 614 615 616 617 618 619 620 621 622 623
	}

}

#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
624 625
	.sysfs_add = mmc_sd_sysfs_add,
	.sysfs_remove = mmc_sd_sysfs_remove,
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);
638
	WARN_ON(!host->claimed);
639 640 641

	mmc_attach_bus(host, &mmc_sd_ops);

David Brownell's avatar
David Brownell committed
642 643 644 645 646 647 648 649 650 651 652
	/*
	 * We need to get OCR a different way for SPI.
	 */
	if (mmc_host_is_spi(host)) {
		mmc_go_idle(host);

		err = mmc_spi_read_ocr(host, 0, &ocr);
		if (err)
			goto err;
	}

653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675
	/*
	 * 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)?
	 */
676 677
	if (!host->ocr) {
		err = -EINVAL;
678
		goto err;
679
	}
680 681 682 683 684

	/*
	 * Detect and init the card.
	 */
	err = mmc_sd_init_card(host, host->ocr, NULL);
685
	if (err)
686 687 688 689
		goto err;

	mmc_release_host(host);

Pierre Ossman's avatar
Pierre Ossman committed
690
	err = mmc_add_card(host->card);
Pierre Ossman's avatar
Pierre Ossman committed
691
	if (err)
692
		goto remove_card;
Pierre Ossman's avatar
Pierre Ossman committed
693 694 695

	return 0;

696
remove_card:
697
	mmc_remove_card(host->card);
Pierre Ossman's avatar
Pierre Ossman committed
698
	host->card = NULL;
699
	mmc_claim_host(host);
Pierre Ossman's avatar
Pierre Ossman committed
700 701 702 703
err:
	mmc_detach_bus(host);
	mmc_release_host(host);

704 705 706
	printk(KERN_ERR "%s: error %d whilst initialising SD card\n",
		mmc_hostname(host), err);

707
	return err;
Pierre Ossman's avatar
Pierre Ossman committed
708 709
}