core.c 44.5 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2
 *  linux/drivers/mmc/core/core.c
L
Linus Torvalds 已提交
3 4
 *
 *  Copyright (C) 2003-2004 Russell King, All Rights Reserved.
P
Pierre Ossman 已提交
5
 *  SD support Copyright (C) 2004 Ian Molton, All Rights Reserved.
6
 *  Copyright (C) 2005-2008 Pierre Ossman, All Rights Reserved.
7
 *  MMCv4 support Copyright (C) 2006 Philip Langdale, All Rights Reserved.
L
Linus Torvalds 已提交
8 9 10 11 12 13 14 15 16 17 18 19 20
 *
 * 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/module.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/completion.h>
#include <linux/device.h>
#include <linux/delay.h>
#include <linux/pagemap.h>
#include <linux/err.h>
P
Pierre Ossman 已提交
21
#include <linux/leds.h>
P
Pierre Ossman 已提交
22
#include <linux/scatterlist.h>
23
#include <linux/log2.h>
D
David Brownell 已提交
24
#include <linux/regulator/consumer.h>
25
#include <linux/pm_runtime.h>
L
Linus Torvalds 已提交
26 27 28

#include <linux/mmc/card.h>
#include <linux/mmc/host.h>
P
Pierre Ossman 已提交
29 30
#include <linux/mmc/mmc.h>
#include <linux/mmc/sd.h>
L
Linus Torvalds 已提交
31

32
#include "core.h"
33 34
#include "bus.h"
#include "host.h"
P
Pierre Ossman 已提交
35
#include "sdio_bus.h"
P
Pierre Ossman 已提交
36 37 38

#include "mmc_ops.h"
#include "sd_ops.h"
P
Pierre Ossman 已提交
39
#include "sdio_ops.h"
L
Linus Torvalds 已提交
40

41 42
static struct workqueue_struct *workqueue;

D
David Brownell 已提交
43 44 45 46 47 48 49 50
/*
 * Enabling software CRCs on the data blocks can be a significant (30%)
 * performance cost, and for other reasons may not always be desired.
 * So we allow it it to be disabled.
 */
int use_spi_crc = 1;
module_param(use_spi_crc, bool, 0);

51 52 53 54 55 56 57 58 59 60 61
/*
 * We normally treat cards as removed during suspend if they are not
 * known to be on a non-removable bus, to avoid the risk of writing
 * back data to a different card after resume.  Allow this to be
 * overridden if necessary.
 */
#ifdef CONFIG_MMC_UNSAFE_RESUME
int mmc_assume_removable;
#else
int mmc_assume_removable = 1;
#endif
62
EXPORT_SYMBOL(mmc_assume_removable);
63 64 65 66 67
module_param_named(removable, mmc_assume_removable, bool, 0644);
MODULE_PARM_DESC(
	removable,
	"MMC/SD cards are removable and may be removed during suspend");

68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84
/*
 * Internal function. Schedule delayed work in the MMC work queue.
 */
static int mmc_schedule_delayed_work(struct delayed_work *work,
				     unsigned long delay)
{
	return queue_delayed_work(workqueue, work, delay);
}

/*
 * Internal function. Flush all scheduled work from the MMC work queue.
 */
static void mmc_flush_scheduled_work(void)
{
	flush_workqueue(workqueue);
}

L
Linus Torvalds 已提交
85
/**
86 87 88
 *	mmc_request_done - finish processing an MMC request
 *	@host: MMC host which completed request
 *	@mrq: MMC request which request
L
Linus Torvalds 已提交
89 90
 *
 *	MMC drivers should call this function when they have completed
91
 *	their processing of a request.
L
Linus Torvalds 已提交
92 93 94 95
 */
void mmc_request_done(struct mmc_host *host, struct mmc_request *mrq)
{
	struct mmc_command *cmd = mrq->cmd;
96 97
	int err = cmd->error;

D
David Brownell 已提交
98 99 100 101 102
	if (err && cmd->retries && mmc_host_is_spi(host)) {
		if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND)
			cmd->retries = 0;
	}

L
Linus Torvalds 已提交
103
	if (err && cmd->retries) {
104 105 106
		pr_debug("%s: req failed (CMD%u): %d, retrying...\n",
			mmc_hostname(host), cmd->opcode, err);

L
Linus Torvalds 已提交
107 108 109
		cmd->retries--;
		cmd->error = 0;
		host->ops->request(host, mrq);
110
	} else {
P
Pierre Ossman 已提交
111 112
		led_trigger_event(host->led, LED_OFF);

113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133
		pr_debug("%s: req done (CMD%u): %d: %08x %08x %08x %08x\n",
			mmc_hostname(host), cmd->opcode, err,
			cmd->resp[0], cmd->resp[1],
			cmd->resp[2], cmd->resp[3]);

		if (mrq->data) {
			pr_debug("%s:     %d bytes transferred: %d\n",
				mmc_hostname(host),
				mrq->data->bytes_xfered, mrq->data->error);
		}

		if (mrq->stop) {
			pr_debug("%s:     (CMD%u): %d: %08x %08x %08x %08x\n",
				mmc_hostname(host), mrq->stop->opcode,
				mrq->stop->error,
				mrq->stop->resp[0], mrq->stop->resp[1],
				mrq->stop->resp[2], mrq->stop->resp[3]);
		}

		if (mrq->done)
			mrq->done(mrq);
134 135

		mmc_host_clk_gate(host);
L
Linus Torvalds 已提交
136 137 138 139 140
	}
}

EXPORT_SYMBOL(mmc_request_done);

141
static void
L
Linus Torvalds 已提交
142 143
mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
{
P
Pierre Ossman 已提交
144 145
#ifdef CONFIG_MMC_DEBUG
	unsigned int i, sz;
146
	struct scatterlist *sg;
P
Pierre Ossman 已提交
147 148
#endif

149 150 151
	pr_debug("%s: starting CMD%u arg %08x flags %08x\n",
		 mmc_hostname(host), mrq->cmd->opcode,
		 mrq->cmd->arg, mrq->cmd->flags);
L
Linus Torvalds 已提交
152

153 154 155 156 157
	if (mrq->data) {
		pr_debug("%s:     blksz %d blocks %d flags %08x "
			"tsac %d ms nsac %d\n",
			mmc_hostname(host), mrq->data->blksz,
			mrq->data->blocks, mrq->data->flags,
158
			mrq->data->timeout_ns / 1000000,
159 160 161 162 163 164 165 166 167
			mrq->data->timeout_clks);
	}

	if (mrq->stop) {
		pr_debug("%s:     CMD%u arg %08x flags %08x\n",
			 mmc_hostname(host), mrq->stop->opcode,
			 mrq->stop->arg, mrq->stop->flags);
	}

P
Pierre Ossman 已提交
168
	WARN_ON(!host->claimed);
L
Linus Torvalds 已提交
169 170 171 172

	mrq->cmd->error = 0;
	mrq->cmd->mrq = mrq;
	if (mrq->data) {
173
		BUG_ON(mrq->data->blksz > host->max_blk_size);
174 175 176
		BUG_ON(mrq->data->blocks > host->max_blk_count);
		BUG_ON(mrq->data->blocks * mrq->data->blksz >
			host->max_req_size);
177

P
Pierre Ossman 已提交
178 179
#ifdef CONFIG_MMC_DEBUG
		sz = 0;
180 181
		for_each_sg(mrq->data->sg, sg, mrq->data->sg_len, i)
			sz += sg->length;
P
Pierre Ossman 已提交
182 183 184
		BUG_ON(sz != mrq->data->blocks * mrq->data->blksz);
#endif

L
Linus Torvalds 已提交
185 186 187 188 189 190 191 192 193
		mrq->cmd->data = mrq->data;
		mrq->data->error = 0;
		mrq->data->mrq = mrq;
		if (mrq->stop) {
			mrq->data->stop = mrq->stop;
			mrq->stop->error = 0;
			mrq->stop->mrq = mrq;
		}
	}
194
	mmc_host_clk_ungate(host);
195
	led_trigger_event(host->led, LED_FULL);
L
Linus Torvalds 已提交
196 197 198 199 200 201 202 203
	host->ops->request(host, mrq);
}

static void mmc_wait_done(struct mmc_request *mrq)
{
	complete(mrq->done_data);
}

P
Pierre Ossman 已提交
204 205 206 207 208 209 210 211 212 213
/**
 *	mmc_wait_for_req - start a request and wait for completion
 *	@host: MMC host to start command
 *	@mrq: MMC request to start
 *
 *	Start a new MMC custom command request for a host, and wait
 *	for the command to complete. Does not attempt to parse the
 *	response.
 */
void mmc_wait_for_req(struct mmc_host *host, struct mmc_request *mrq)
L
Linus Torvalds 已提交
214
{
215
	DECLARE_COMPLETION_ONSTACK(complete);
L
Linus Torvalds 已提交
216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238

	mrq->done_data = &complete;
	mrq->done = mmc_wait_done;

	mmc_start_request(host, mrq);

	wait_for_completion(&complete);
}

EXPORT_SYMBOL(mmc_wait_for_req);

/**
 *	mmc_wait_for_cmd - start a command and wait for completion
 *	@host: MMC host to start command
 *	@cmd: MMC command to start
 *	@retries: maximum number of retries
 *
 *	Start a new MMC command for a host, and wait for the command
 *	to complete.  Return any error that occurred while the command
 *	was executing.  Do not attempt to parse the response.
 */
int mmc_wait_for_cmd(struct mmc_host *host, struct mmc_command *cmd, int retries)
{
239
	struct mmc_request mrq = {0};
L
Linus Torvalds 已提交
240

P
Pierre Ossman 已提交
241
	WARN_ON(!host->claimed);
L
Linus Torvalds 已提交
242 243 244 245 246 247 248 249 250 251 252 253 254 255

	memset(cmd->resp, 0, sizeof(cmd->resp));
	cmd->retries = retries;

	mrq.cmd = cmd;
	cmd->data = NULL;

	mmc_wait_for_req(host, &mrq);

	return cmd->error;
}

EXPORT_SYMBOL(mmc_wait_for_cmd);

256 257 258 259
/**
 *	mmc_set_data_timeout - set the timeout for a data command
 *	@data: data phase for command
 *	@card: the MMC card associated with the data transfer
P
Pierre Ossman 已提交
260 261 262
 *
 *	Computes the data timeout parameters according to the
 *	correct algorithm given the card type.
263
 */
264
void mmc_set_data_timeout(struct mmc_data *data, const struct mmc_card *card)
265 266 267
{
	unsigned int mult;

268 269 270 271 272 273 274 275 276
	/*
	 * SDIO cards only define an upper 1 s limit on access.
	 */
	if (mmc_card_sdio(card)) {
		data->timeout_ns = 1000000000;
		data->timeout_clks = 0;
		return;
	}

277 278 279 280 281 282 283 284 285
	/*
	 * SD cards use a 100 multiplier rather than 10
	 */
	mult = mmc_card_sd(card) ? 100 : 10;

	/*
	 * Scale up the multiplier (and therefore the timeout) by
	 * the r2w factor for writes.
	 */
286
	if (data->flags & MMC_DATA_WRITE)
287 288 289 290 291 292 293 294 295 296 297 298
		mult <<= card->csd.r2w_factor;

	data->timeout_ns = card->csd.tacc_ns * mult;
	data->timeout_clks = card->csd.tacc_clks * mult;

	/*
	 * SD cards also have an upper limit on the timeout.
	 */
	if (mmc_card_sd(card)) {
		unsigned int timeout_us, limit_us;

		timeout_us = data->timeout_ns / 1000;
299 300 301
		if (mmc_host_clk_rate(card->host))
			timeout_us += data->timeout_clks * 1000 /
				(mmc_host_clk_rate(card->host) / 1000);
302

303
		if (data->flags & MMC_DATA_WRITE)
304 305 306 307 308
			/*
			 * The limit is really 250 ms, but that is
			 * insufficient for some crappy cards.
			 */
			limit_us = 300000;
309 310 311
		else
			limit_us = 100000;

312 313 314 315
		/*
		 * SDHC cards always use these fixed values.
		 */
		if (timeout_us > limit_us || mmc_card_blockaddr(card)) {
316 317 318 319
			data->timeout_ns = limit_us * 1000;
			data->timeout_clks = 0;
		}
	}
320 321 322 323 324 325 326 327 328 329 330 331 332 333 334
	/*
	 * Some cards need very high timeouts if driven in SPI mode.
	 * The worst observed timeout was 900ms after writing a
	 * continuous stream of data until the internal logic
	 * overflowed.
	 */
	if (mmc_host_is_spi(card->host)) {
		if (data->flags & MMC_DATA_WRITE) {
			if (data->timeout_ns < 1000000000)
				data->timeout_ns = 1000000000;	/* 1s */
		} else {
			if (data->timeout_ns < 100000000)
				data->timeout_ns =  100000000;	/* 100ms */
		}
	}
335 336 337
}
EXPORT_SYMBOL(mmc_set_data_timeout);

338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364
/**
 *	mmc_align_data_size - pads a transfer size to a more optimal value
 *	@card: the MMC card associated with the data transfer
 *	@sz: original transfer size
 *
 *	Pads the original data size with a number of extra bytes in
 *	order to avoid controller bugs and/or performance hits
 *	(e.g. some controllers revert to PIO for certain sizes).
 *
 *	Returns the improved size, which might be unmodified.
 *
 *	Note that this function is only relevant when issuing a
 *	single scatter gather entry.
 */
unsigned int mmc_align_data_size(struct mmc_card *card, unsigned int sz)
{
	/*
	 * FIXME: We don't have a system for the controller to tell
	 * the core about its problems yet, so for now we just 32-bit
	 * align the size.
	 */
	sz = ((sz + 3) / 4) * 4;

	return sz;
}
EXPORT_SYMBOL(mmc_align_data_size);

365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459
/**
 *	mmc_host_enable - enable a host.
 *	@host: mmc host to enable
 *
 *	Hosts that support power saving can use the 'enable' and 'disable'
 *	methods to exit and enter power saving states. For more information
 *	see comments for struct mmc_host_ops.
 */
int mmc_host_enable(struct mmc_host *host)
{
	if (!(host->caps & MMC_CAP_DISABLE))
		return 0;

	if (host->en_dis_recurs)
		return 0;

	if (host->nesting_cnt++)
		return 0;

	cancel_delayed_work_sync(&host->disable);

	if (host->enabled)
		return 0;

	if (host->ops->enable) {
		int err;

		host->en_dis_recurs = 1;
		err = host->ops->enable(host);
		host->en_dis_recurs = 0;

		if (err) {
			pr_debug("%s: enable error %d\n",
				 mmc_hostname(host), err);
			return err;
		}
	}
	host->enabled = 1;
	return 0;
}
EXPORT_SYMBOL(mmc_host_enable);

static int mmc_host_do_disable(struct mmc_host *host, int lazy)
{
	if (host->ops->disable) {
		int err;

		host->en_dis_recurs = 1;
		err = host->ops->disable(host, lazy);
		host->en_dis_recurs = 0;

		if (err < 0) {
			pr_debug("%s: disable error %d\n",
				 mmc_hostname(host), err);
			return err;
		}
		if (err > 0) {
			unsigned long delay = msecs_to_jiffies(err);

			mmc_schedule_delayed_work(&host->disable, delay);
		}
	}
	host->enabled = 0;
	return 0;
}

/**
 *	mmc_host_disable - disable a host.
 *	@host: mmc host to disable
 *
 *	Hosts that support power saving can use the 'enable' and 'disable'
 *	methods to exit and enter power saving states. For more information
 *	see comments for struct mmc_host_ops.
 */
int mmc_host_disable(struct mmc_host *host)
{
	int err;

	if (!(host->caps & MMC_CAP_DISABLE))
		return 0;

	if (host->en_dis_recurs)
		return 0;

	if (--host->nesting_cnt)
		return 0;

	if (!host->enabled)
		return 0;

	err = mmc_host_do_disable(host, 0);
	return err;
}
EXPORT_SYMBOL(mmc_host_disable);

L
Linus Torvalds 已提交
460
/**
461
 *	__mmc_claim_host - exclusively claim a host
L
Linus Torvalds 已提交
462
 *	@host: mmc host to claim
463
 *	@abort: whether or not the operation should be aborted
L
Linus Torvalds 已提交
464
 *
465 466 467 468
 *	Claim a host for a set of operations.  If @abort is non null and
 *	dereference a non-zero value then this will return prematurely with
 *	that non-zero value without acquiring the lock.  Returns zero
 *	with the lock held otherwise.
L
Linus Torvalds 已提交
469
 */
470
int __mmc_claim_host(struct mmc_host *host, atomic_t *abort)
L
Linus Torvalds 已提交
471 472 473
{
	DECLARE_WAITQUEUE(wait, current);
	unsigned long flags;
474
	int stop;
L
Linus Torvalds 已提交
475

476 477
	might_sleep();

L
Linus Torvalds 已提交
478 479 480 481
	add_wait_queue(&host->wq, &wait);
	spin_lock_irqsave(&host->lock, flags);
	while (1) {
		set_current_state(TASK_UNINTERRUPTIBLE);
482
		stop = abort ? atomic_read(abort) : 0;
483
		if (stop || !host->claimed || host->claimer == current)
L
Linus Torvalds 已提交
484 485 486 487 488 489
			break;
		spin_unlock_irqrestore(&host->lock, flags);
		schedule();
		spin_lock_irqsave(&host->lock, flags);
	}
	set_current_state(TASK_RUNNING);
490
	if (!stop) {
491
		host->claimed = 1;
492 493 494
		host->claimer = current;
		host->claim_cnt += 1;
	} else
495
		wake_up(&host->wq);
L
Linus Torvalds 已提交
496 497
	spin_unlock_irqrestore(&host->lock, flags);
	remove_wait_queue(&host->wq, &wait);
498 499
	if (!stop)
		mmc_host_enable(host);
500
	return stop;
L
Linus Torvalds 已提交
501 502
}

503
EXPORT_SYMBOL(__mmc_claim_host);
L
Linus Torvalds 已提交
504

505 506 507 508 509 510 511
/**
 *	mmc_try_claim_host - try exclusively to claim a host
 *	@host: mmc host to claim
 *
 *	Returns %1 if the host is claimed, %0 otherwise.
 */
int mmc_try_claim_host(struct mmc_host *host)
512 513 514 515 516
{
	int claimed_host = 0;
	unsigned long flags;

	spin_lock_irqsave(&host->lock, flags);
517
	if (!host->claimed || host->claimer == current) {
518
		host->claimed = 1;
519 520
		host->claimer = current;
		host->claim_cnt += 1;
521 522 523 524 525
		claimed_host = 1;
	}
	spin_unlock_irqrestore(&host->lock, flags);
	return claimed_host;
}
526
EXPORT_SYMBOL(mmc_try_claim_host);
527

528 529 530 531 532 533 534 535
/**
 *	mmc_do_release_host - release a claimed host
 *	@host: mmc host to release
 *
 *	If you successfully claimed a host, this function will
 *	release it again.
 */
void mmc_do_release_host(struct mmc_host *host)
536 537 538 539
{
	unsigned long flags;

	spin_lock_irqsave(&host->lock, flags);
540 541 542 543 544 545 546 547 548
	if (--host->claim_cnt) {
		/* Release for nested claim */
		spin_unlock_irqrestore(&host->lock, flags);
	} else {
		host->claimed = 0;
		host->claimer = NULL;
		spin_unlock_irqrestore(&host->lock, flags);
		wake_up(&host->wq);
	}
549
}
550
EXPORT_SYMBOL(mmc_do_release_host);
551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594

void mmc_host_deeper_disable(struct work_struct *work)
{
	struct mmc_host *host =
		container_of(work, struct mmc_host, disable.work);

	/* If the host is claimed then we do not want to disable it anymore */
	if (!mmc_try_claim_host(host))
		return;
	mmc_host_do_disable(host, 1);
	mmc_do_release_host(host);
}

/**
 *	mmc_host_lazy_disable - lazily disable a host.
 *	@host: mmc host to disable
 *
 *	Hosts that support power saving can use the 'enable' and 'disable'
 *	methods to exit and enter power saving states. For more information
 *	see comments for struct mmc_host_ops.
 */
int mmc_host_lazy_disable(struct mmc_host *host)
{
	if (!(host->caps & MMC_CAP_DISABLE))
		return 0;

	if (host->en_dis_recurs)
		return 0;

	if (--host->nesting_cnt)
		return 0;

	if (!host->enabled)
		return 0;

	if (host->disable_delay) {
		mmc_schedule_delayed_work(&host->disable,
				msecs_to_jiffies(host->disable_delay));
		return 0;
	} else
		return mmc_host_do_disable(host, 1);
}
EXPORT_SYMBOL(mmc_host_lazy_disable);

L
Linus Torvalds 已提交
595 596 597 598 599 600 601 602 603
/**
 *	mmc_release_host - release a host
 *	@host: mmc host to release
 *
 *	Release a MMC host, allowing others to claim the host
 *	for their operations.
 */
void mmc_release_host(struct mmc_host *host)
{
P
Pierre Ossman 已提交
604
	WARN_ON(!host->claimed);
L
Linus Torvalds 已提交
605

606
	mmc_host_lazy_disable(host);
L
Linus Torvalds 已提交
607

608
	mmc_do_release_host(host);
L
Linus Torvalds 已提交
609 610 611 612
}

EXPORT_SYMBOL(mmc_release_host);

P
Pierre Ossman 已提交
613 614 615 616
/*
 * Internal function that does the actual ios call to the host driver,
 * optionally printing some debug output.
 */
617 618 619 620
static inline void mmc_set_ios(struct mmc_host *host)
{
	struct mmc_ios *ios = &host->ios;

621 622
	pr_debug("%s: clock %uHz busmode %u powermode %u cs %u Vdd %u "
		"width %u timing %u\n",
623 624
		 mmc_hostname(host), ios->clock, ios->bus_mode,
		 ios->power_mode, ios->chip_select, ios->vdd,
625
		 ios->bus_width, ios->timing);
626

627 628
	if (ios->clock > 0)
		mmc_set_ungated(host);
629 630 631
	host->ops->set_ios(host, ios);
}

P
Pierre Ossman 已提交
632 633 634
/*
 * Control chip select pin on a host.
 */
P
Pierre Ossman 已提交
635
void mmc_set_chip_select(struct mmc_host *host, int mode)
L
Linus Torvalds 已提交
636
{
P
Pierre Ossman 已提交
637 638
	host->ios.chip_select = mode;
	mmc_set_ios(host);
L
Linus Torvalds 已提交
639 640
}

P
Pierre Ossman 已提交
641 642 643 644 645 646 647 648 649 650 651 652 653 654 655
/*
 * Sets the host clock to the highest possible frequency that
 * is below "hz".
 */
void mmc_set_clock(struct mmc_host *host, unsigned int hz)
{
	WARN_ON(hz < host->f_min);

	if (hz > host->f_max)
		hz = host->f_max;

	host->ios.clock = hz;
	mmc_set_ios(host);
}

656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710
#ifdef CONFIG_MMC_CLKGATE
/*
 * This gates the clock by setting it to 0 Hz.
 */
void mmc_gate_clock(struct mmc_host *host)
{
	unsigned long flags;

	spin_lock_irqsave(&host->clk_lock, flags);
	host->clk_old = host->ios.clock;
	host->ios.clock = 0;
	host->clk_gated = true;
	spin_unlock_irqrestore(&host->clk_lock, flags);
	mmc_set_ios(host);
}

/*
 * This restores the clock from gating by using the cached
 * clock value.
 */
void mmc_ungate_clock(struct mmc_host *host)
{
	/*
	 * We should previously have gated the clock, so the clock shall
	 * be 0 here! The clock may however be 0 during initialization,
	 * when some request operations are performed before setting
	 * the frequency. When ungate is requested in that situation
	 * we just ignore the call.
	 */
	if (host->clk_old) {
		BUG_ON(host->ios.clock);
		/* This call will also set host->clk_gated to false */
		mmc_set_clock(host, host->clk_old);
	}
}

void mmc_set_ungated(struct mmc_host *host)
{
	unsigned long flags;

	/*
	 * We've been given a new frequency while the clock is gated,
	 * so make sure we regard this as ungating it.
	 */
	spin_lock_irqsave(&host->clk_lock, flags);
	host->clk_gated = false;
	spin_unlock_irqrestore(&host->clk_lock, flags);
}

#else
void mmc_set_ungated(struct mmc_host *host)
{
}
#endif

P
Pierre Ossman 已提交
711 712 713 714 715 716 717 718 719 720
/*
 * Change the bus mode (open drain/push-pull) of a host.
 */
void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode)
{
	host->ios.bus_mode = mode;
	mmc_set_ios(host);
}

/*
721
 * Change data bus width and DDR mode of a host.
P
Pierre Ossman 已提交
722
 */
A
Adrian Hunter 已提交
723 724
void mmc_set_bus_width_ddr(struct mmc_host *host, unsigned int width,
			   unsigned int ddr)
P
Pierre Ossman 已提交
725 726
{
	host->ios.bus_width = width;
A
Adrian Hunter 已提交
727
	host->ios.ddr = ddr;
P
Pierre Ossman 已提交
728 729 730
	mmc_set_ios(host);
}

731 732 733 734 735
/*
 * Change data bus width of a host.
 */
void mmc_set_bus_width(struct mmc_host *host, unsigned int width)
{
A
Adrian Hunter 已提交
736
	mmc_set_bus_width_ddr(host, width, MMC_SDR_MODE);
737 738
}

739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812
/**
 * mmc_vdd_to_ocrbitnum - Convert a voltage to the OCR bit number
 * @vdd:	voltage (mV)
 * @low_bits:	prefer low bits in boundary cases
 *
 * This function returns the OCR bit number according to the provided @vdd
 * value. If conversion is not possible a negative errno value returned.
 *
 * Depending on the @low_bits flag the function prefers low or high OCR bits
 * on boundary voltages. For example,
 * with @low_bits = true, 3300 mV translates to ilog2(MMC_VDD_32_33);
 * with @low_bits = false, 3300 mV translates to ilog2(MMC_VDD_33_34);
 *
 * Any value in the [1951:1999] range translates to the ilog2(MMC_VDD_20_21).
 */
static int mmc_vdd_to_ocrbitnum(int vdd, bool low_bits)
{
	const int max_bit = ilog2(MMC_VDD_35_36);
	int bit;

	if (vdd < 1650 || vdd > 3600)
		return -EINVAL;

	if (vdd >= 1650 && vdd <= 1950)
		return ilog2(MMC_VDD_165_195);

	if (low_bits)
		vdd -= 1;

	/* Base 2000 mV, step 100 mV, bit's base 8. */
	bit = (vdd - 2000) / 100 + 8;
	if (bit > max_bit)
		return max_bit;
	return bit;
}

/**
 * mmc_vddrange_to_ocrmask - Convert a voltage range to the OCR mask
 * @vdd_min:	minimum voltage value (mV)
 * @vdd_max:	maximum voltage value (mV)
 *
 * This function returns the OCR mask bits according to the provided @vdd_min
 * and @vdd_max values. If conversion is not possible the function returns 0.
 *
 * Notes wrt boundary cases:
 * This function sets the OCR bits for all boundary voltages, for example
 * [3300:3400] range is translated to MMC_VDD_32_33 | MMC_VDD_33_34 |
 * MMC_VDD_34_35 mask.
 */
u32 mmc_vddrange_to_ocrmask(int vdd_min, int vdd_max)
{
	u32 mask = 0;

	if (vdd_max < vdd_min)
		return 0;

	/* Prefer high bits for the boundary vdd_max values. */
	vdd_max = mmc_vdd_to_ocrbitnum(vdd_max, false);
	if (vdd_max < 0)
		return 0;

	/* Prefer low bits for the boundary vdd_min values. */
	vdd_min = mmc_vdd_to_ocrbitnum(vdd_min, true);
	if (vdd_min < 0)
		return 0;

	/* Fill the mask, from max bit to min bit. */
	while (vdd_max >= vdd_min)
		mask |= 1 << vdd_max--;

	return mask;
}
EXPORT_SYMBOL(mmc_vddrange_to_ocrmask);

D
David Brownell 已提交
813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851
#ifdef CONFIG_REGULATOR

/**
 * mmc_regulator_get_ocrmask - return mask of supported voltages
 * @supply: regulator to use
 *
 * This returns either a negative errno, or a mask of voltages that
 * can be provided to MMC/SD/SDIO devices using the specified voltage
 * regulator.  This would normally be called before registering the
 * MMC host adapter.
 */
int mmc_regulator_get_ocrmask(struct regulator *supply)
{
	int			result = 0;
	int			count;
	int			i;

	count = regulator_count_voltages(supply);
	if (count < 0)
		return count;

	for (i = 0; i < count; i++) {
		int		vdd_uV;
		int		vdd_mV;

		vdd_uV = regulator_list_voltage(supply, i);
		if (vdd_uV <= 0)
			continue;

		vdd_mV = vdd_uV / 1000;
		result |= mmc_vddrange_to_ocrmask(vdd_mV, vdd_mV);
	}

	return result;
}
EXPORT_SYMBOL(mmc_regulator_get_ocrmask);

/**
 * mmc_regulator_set_ocr - set regulator to match host->ios voltage
852
 * @mmc: the host to regulate
D
David Brownell 已提交
853
 * @supply: regulator to use
854
 * @vdd_bit: zero for power off, else a bit number (host->ios.vdd)
D
David Brownell 已提交
855 856 857 858 859 860 861
 *
 * Returns zero on success, else negative errno.
 *
 * MMC host drivers may use this to enable or disable a regulator using
 * a particular supply voltage.  This would normally be called from the
 * set_ios() method.
 */
862 863 864
int mmc_regulator_set_ocr(struct mmc_host *mmc,
			struct regulator *supply,
			unsigned short vdd_bit)
D
David Brownell 已提交
865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897
{
	int			result = 0;
	int			min_uV, max_uV;

	if (vdd_bit) {
		int		tmp;
		int		voltage;

		/* REVISIT mmc_vddrange_to_ocrmask() may have set some
		 * bits this regulator doesn't quite support ... don't
		 * be too picky, most cards and regulators are OK with
		 * a 0.1V range goof (it's a small error percentage).
		 */
		tmp = vdd_bit - ilog2(MMC_VDD_165_195);
		if (tmp == 0) {
			min_uV = 1650 * 1000;
			max_uV = 1950 * 1000;
		} else {
			min_uV = 1900 * 1000 + tmp * 100 * 1000;
			max_uV = min_uV + 100 * 1000;
		}

		/* avoid needless changes to this voltage; the regulator
		 * might not allow this operation
		 */
		voltage = regulator_get_voltage(supply);
		if (voltage < 0)
			result = voltage;
		else if (voltage < min_uV || voltage > max_uV)
			result = regulator_set_voltage(supply, min_uV, max_uV);
		else
			result = 0;

898
		if (result == 0 && !mmc->regulator_enabled) {
D
David Brownell 已提交
899
			result = regulator_enable(supply);
900 901 902 903
			if (!result)
				mmc->regulator_enabled = true;
		}
	} else if (mmc->regulator_enabled) {
D
David Brownell 已提交
904
		result = regulator_disable(supply);
905 906
		if (result == 0)
			mmc->regulator_enabled = false;
D
David Brownell 已提交
907 908
	}

909 910 911
	if (result)
		dev_err(mmc_dev(mmc),
			"could not set regulator OCR (%d)\n", result);
D
David Brownell 已提交
912 913 914 915
	return result;
}
EXPORT_SYMBOL(mmc_regulator_set_ocr);

916
#endif /* CONFIG_REGULATOR */
D
David Brownell 已提交
917

L
Linus Torvalds 已提交
918 919 920 921
/*
 * Mask off any voltages we don't support and select
 * the lowest voltage
 */
P
Pierre Ossman 已提交
922
u32 mmc_select_voltage(struct mmc_host *host, u32 ocr)
L
Linus Torvalds 已提交
923 924 925 926 927 928 929 930 931
{
	int bit;

	ocr &= host->ocr_avail;

	bit = ffs(ocr);
	if (bit) {
		bit -= 1;

932
		ocr &= 3 << bit;
L
Linus Torvalds 已提交
933 934

		host->ios.vdd = bit;
935
		mmc_set_ios(host);
L
Linus Torvalds 已提交
936
	} else {
937 938
		pr_warning("%s: host doesn't support card's voltages\n",
				mmc_hostname(host));
L
Linus Torvalds 已提交
939 940 941 942 943 944
		ocr = 0;
	}

	return ocr;
}

945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976
int mmc_set_signal_voltage(struct mmc_host *host, int signal_voltage)
{
	struct mmc_command cmd = {0};
	int err = 0;

	BUG_ON(!host);

	/*
	 * Send CMD11 only if the request is to switch the card to
	 * 1.8V signalling.
	 */
	if (signal_voltage == MMC_SIGNAL_VOLTAGE_180) {
		cmd.opcode = SD_SWITCH_VOLTAGE;
		cmd.arg = 0;
		cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;

		err = mmc_wait_for_cmd(host, &cmd, 0);
		if (err)
			return err;

		if (!mmc_host_is_spi(host) && (cmd.resp[0] & R1_ERROR))
			return -EIO;
	}

	host->ios.signal_voltage = signal_voltage;

	if (host->ops->start_signal_voltage_switch)
		err = host->ops->start_signal_voltage_switch(host, &host->ios);

	return err;
}

P
Pierre Ossman 已提交
977
/*
P
Pierre Ossman 已提交
978
 * Select timing parameters for host.
P
Pierre Ossman 已提交
979
 */
P
Pierre Ossman 已提交
980
void mmc_set_timing(struct mmc_host *host, unsigned int timing)
P
Pierre Ossman 已提交
981
{
P
Pierre Ossman 已提交
982 983
	host->ios.timing = timing;
	mmc_set_ios(host);
P
Pierre Ossman 已提交
984 985
}

L
Linus Torvalds 已提交
986
/*
987 988 989 990 991 992 993 994 995
 * Apply power to the MMC stack.  This is a two-stage process.
 * First, we enable power to the card without the clock running.
 * We then wait a bit for the power to stabilise.  Finally,
 * enable the bus drivers and clock to the card.
 *
 * We must _NOT_ enable the clock prior to power stablising.
 *
 * If a host does all the power sequencing itself, ignore the
 * initial MMC_POWER_UP stage.
L
Linus Torvalds 已提交
996 997 998
 */
static void mmc_power_up(struct mmc_host *host)
{
999 1000 1001 1002 1003 1004 1005
	int bit;

	/* If ocr is set, we use it */
	if (host->ocr)
		bit = ffs(host->ocr) - 1;
	else
		bit = fls(host->ocr_avail) - 1;
L
Linus Torvalds 已提交
1006 1007

	host->ios.vdd = bit;
D
David Brownell 已提交
1008 1009 1010 1011 1012 1013 1014
	if (mmc_host_is_spi(host)) {
		host->ios.chip_select = MMC_CS_HIGH;
		host->ios.bus_mode = MMC_BUSMODE_PUSHPULL;
	} else {
		host->ios.chip_select = MMC_CS_DONTCARE;
		host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
	}
L
Linus Torvalds 已提交
1015
	host->ios.power_mode = MMC_POWER_UP;
P
Pierre Ossman 已提交
1016
	host->ios.bus_width = MMC_BUS_WIDTH_1;
1017
	host->ios.timing = MMC_TIMING_LEGACY;
1018
	mmc_set_ios(host);
L
Linus Torvalds 已提交
1019

P
Pierre Ossman 已提交
1020 1021 1022 1023
	/*
	 * This delay should be sufficient to allow the power supply
	 * to reach the minimum voltage.
	 */
1024
	mmc_delay(10);
L
Linus Torvalds 已提交
1025

H
Hein Tibosch 已提交
1026
	host->ios.clock = host->f_init;
1027

L
Linus Torvalds 已提交
1028
	host->ios.power_mode = MMC_POWER_ON;
1029
	mmc_set_ios(host);
L
Linus Torvalds 已提交
1030

P
Pierre Ossman 已提交
1031 1032 1033 1034
	/*
	 * This delay must be at least 74 clock sizes, or 1 ms, or the
	 * time required to reach a stable voltage.
	 */
1035
	mmc_delay(10);
L
Linus Torvalds 已提交
1036 1037 1038 1039 1040 1041
}

static void mmc_power_off(struct mmc_host *host)
{
	host->ios.clock = 0;
	host->ios.vdd = 0;
1042 1043 1044 1045 1046 1047 1048

	/*
	 * Reset ocr mask to be the highest possible voltage supported for
	 * this mmc host. This value will be used at next power up.
	 */
	host->ocr = 1 << (fls(host->ocr_avail) - 1);

D
David Brownell 已提交
1049 1050 1051 1052
	if (!mmc_host_is_spi(host)) {
		host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
		host->ios.chip_select = MMC_CS_DONTCARE;
	}
L
Linus Torvalds 已提交
1053
	host->ios.power_mode = MMC_POWER_OFF;
P
Pierre Ossman 已提交
1054
	host->ios.bus_width = MMC_BUS_WIDTH_1;
1055
	host->ios.timing = MMC_TIMING_LEGACY;
1056
	mmc_set_ios(host);
L
Linus Torvalds 已提交
1057 1058
}

1059 1060 1061
/*
 * Cleanup when the last reference to the bus operator is dropped.
 */
1062
static void __mmc_release_bus(struct mmc_host *host)
1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097
{
	BUG_ON(!host);
	BUG_ON(host->bus_refs);
	BUG_ON(!host->bus_dead);

	host->bus_ops = NULL;
}

/*
 * Increase reference count of bus operator
 */
static inline void mmc_bus_get(struct mmc_host *host)
{
	unsigned long flags;

	spin_lock_irqsave(&host->lock, flags);
	host->bus_refs++;
	spin_unlock_irqrestore(&host->lock, flags);
}

/*
 * Decrease reference count of bus operator and free it if
 * it is the last reference.
 */
static inline void mmc_bus_put(struct mmc_host *host)
{
	unsigned long flags;

	spin_lock_irqsave(&host->lock, flags);
	host->bus_refs--;
	if ((host->bus_refs == 0) && host->bus_ops)
		__mmc_release_bus(host);
	spin_unlock_irqrestore(&host->lock, flags);
}

L
Linus Torvalds 已提交
1098
/*
P
Pierre Ossman 已提交
1099 1100
 * Assign a mmc bus handler to a host. Only one bus handler may control a
 * host at any given time.
L
Linus Torvalds 已提交
1101
 */
P
Pierre Ossman 已提交
1102
void mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops)
L
Linus Torvalds 已提交
1103
{
P
Pierre Ossman 已提交
1104
	unsigned long flags;
1105

P
Pierre Ossman 已提交
1106 1107
	BUG_ON(!host);
	BUG_ON(!ops);
P
Pierre Ossman 已提交
1108

P
Pierre Ossman 已提交
1109
	WARN_ON(!host->claimed);
1110

P
Pierre Ossman 已提交
1111
	spin_lock_irqsave(&host->lock, flags);
1112

P
Pierre Ossman 已提交
1113 1114
	BUG_ON(host->bus_ops);
	BUG_ON(host->bus_refs);
P
Pierre Ossman 已提交
1115

P
Pierre Ossman 已提交
1116 1117 1118
	host->bus_ops = ops;
	host->bus_refs = 1;
	host->bus_dead = 0;
P
Pierre Ossman 已提交
1119

P
Pierre Ossman 已提交
1120
	spin_unlock_irqrestore(&host->lock, flags);
P
Pierre Ossman 已提交
1121 1122
}

P
Pierre Ossman 已提交
1123 1124 1125 1126 1127
/*
 * Remove the current bus handler from a host. Assumes that there are
 * no interesting cards left, so the bus is powered down.
 */
void mmc_detach_bus(struct mmc_host *host)
1128
{
P
Pierre Ossman 已提交
1129
	unsigned long flags;
1130

P
Pierre Ossman 已提交
1131
	BUG_ON(!host);
1132

P
Pierre Ossman 已提交
1133 1134
	WARN_ON(!host->claimed);
	WARN_ON(!host->bus_ops);
1135

P
Pierre Ossman 已提交
1136
	spin_lock_irqsave(&host->lock, flags);
1137

P
Pierre Ossman 已提交
1138
	host->bus_dead = 1;
1139

P
Pierre Ossman 已提交
1140
	spin_unlock_irqrestore(&host->lock, flags);
L
Linus Torvalds 已提交
1141

P
Pierre Ossman 已提交
1142
	mmc_power_off(host);
L
Linus Torvalds 已提交
1143

P
Pierre Ossman 已提交
1144
	mmc_bus_put(host);
L
Linus Torvalds 已提交
1145 1146 1147 1148 1149
}

/**
 *	mmc_detect_change - process change of state on a MMC socket
 *	@host: host which changed state.
1150
 *	@delay: optional delay to wait before detection (jiffies)
L
Linus Torvalds 已提交
1151
 *
P
Pierre Ossman 已提交
1152 1153 1154 1155
 *	MMC drivers should call this when they detect a card has been
 *	inserted or removed. The MMC layer will confirm that any
 *	present card is still functional, and initialize any newly
 *	inserted.
L
Linus Torvalds 已提交
1156
 */
1157
void mmc_detect_change(struct mmc_host *host, unsigned long delay)
L
Linus Torvalds 已提交
1158
{
1159
#ifdef CONFIG_MMC_DEBUG
1160
	unsigned long flags;
A
Andrew Morton 已提交
1161
	spin_lock_irqsave(&host->lock, flags);
P
Pierre Ossman 已提交
1162
	WARN_ON(host->removed);
A
Andrew Morton 已提交
1163
	spin_unlock_irqrestore(&host->lock, flags);
1164 1165
#endif

D
David Howells 已提交
1166
	mmc_schedule_delayed_work(&host->detect, delay);
L
Linus Torvalds 已提交
1167 1168 1169 1170
}

EXPORT_SYMBOL(mmc_detect_change);

1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219
void mmc_init_erase(struct mmc_card *card)
{
	unsigned int sz;

	if (is_power_of_2(card->erase_size))
		card->erase_shift = ffs(card->erase_size) - 1;
	else
		card->erase_shift = 0;

	/*
	 * It is possible to erase an arbitrarily large area of an SD or MMC
	 * card.  That is not desirable because it can take a long time
	 * (minutes) potentially delaying more important I/O, and also the
	 * timeout calculations become increasingly hugely over-estimated.
	 * Consequently, 'pref_erase' is defined as a guide to limit erases
	 * to that size and alignment.
	 *
	 * For SD cards that define Allocation Unit size, limit erases to one
	 * Allocation Unit at a time.  For MMC cards that define High Capacity
	 * Erase Size, whether it is switched on or not, limit to that size.
	 * Otherwise just have a stab at a good value.  For modern cards it
	 * will end up being 4MiB.  Note that if the value is too small, it
	 * can end up taking longer to erase.
	 */
	if (mmc_card_sd(card) && card->ssr.au) {
		card->pref_erase = card->ssr.au;
		card->erase_shift = ffs(card->ssr.au) - 1;
	} else if (card->ext_csd.hc_erase_size) {
		card->pref_erase = card->ext_csd.hc_erase_size;
	} else {
		sz = (card->csd.capacity << (card->csd.read_blkbits - 9)) >> 11;
		if (sz < 128)
			card->pref_erase = 512 * 1024 / 512;
		else if (sz < 512)
			card->pref_erase = 1024 * 1024 / 512;
		else if (sz < 1024)
			card->pref_erase = 2 * 1024 * 1024 / 512;
		else
			card->pref_erase = 4 * 1024 * 1024 / 512;
		if (card->pref_erase < card->erase_size)
			card->pref_erase = card->erase_size;
		else {
			sz = card->pref_erase % card->erase_size;
			if (sz)
				card->pref_erase += card->erase_size - sz;
		}
	}
}

1220 1221
static unsigned int mmc_mmc_erase_timeout(struct mmc_card *card,
				          unsigned int arg, unsigned int qty)
1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277
{
	unsigned int erase_timeout;

	if (card->ext_csd.erase_group_def & 1) {
		/* High Capacity Erase Group Size uses HC timeouts */
		if (arg == MMC_TRIM_ARG)
			erase_timeout = card->ext_csd.trim_timeout;
		else
			erase_timeout = card->ext_csd.hc_erase_timeout;
	} else {
		/* CSD Erase Group Size uses write timeout */
		unsigned int mult = (10 << card->csd.r2w_factor);
		unsigned int timeout_clks = card->csd.tacc_clks * mult;
		unsigned int timeout_us;

		/* Avoid overflow: e.g. tacc_ns=80000000 mult=1280 */
		if (card->csd.tacc_ns < 1000000)
			timeout_us = (card->csd.tacc_ns * mult) / 1000;
		else
			timeout_us = (card->csd.tacc_ns / 1000) * mult;

		/*
		 * ios.clock is only a target.  The real clock rate might be
		 * less but not that much less, so fudge it by multiplying by 2.
		 */
		timeout_clks <<= 1;
		timeout_us += (timeout_clks * 1000) /
			      (card->host->ios.clock / 1000);

		erase_timeout = timeout_us / 1000;

		/*
		 * Theoretically, the calculation could underflow so round up
		 * to 1ms in that case.
		 */
		if (!erase_timeout)
			erase_timeout = 1;
	}

	/* Multiplier for secure operations */
	if (arg & MMC_SECURE_ARGS) {
		if (arg == MMC_SECURE_ERASE_ARG)
			erase_timeout *= card->ext_csd.sec_erase_mult;
		else
			erase_timeout *= card->ext_csd.sec_trim_mult;
	}

	erase_timeout *= qty;

	/*
	 * Ensure at least a 1 second timeout for SPI as per
	 * 'mmc_set_data_timeout()'
	 */
	if (mmc_host_is_spi(card->host) && erase_timeout < 1000)
		erase_timeout = 1000;

1278
	return erase_timeout;
1279 1280
}

1281 1282 1283
static unsigned int mmc_sd_erase_timeout(struct mmc_card *card,
					 unsigned int arg,
					 unsigned int qty)
1284
{
1285 1286
	unsigned int erase_timeout;

1287 1288
	if (card->ssr.erase_timeout) {
		/* Erase timeout specified in SD Status Register (SSR) */
1289 1290
		erase_timeout = card->ssr.erase_timeout * qty +
				card->ssr.erase_offset;
1291 1292 1293 1294 1295
	} else {
		/*
		 * Erase timeout not specified in SD Status Register (SSR) so
		 * use 250ms per write block.
		 */
1296
		erase_timeout = 250 * qty;
1297 1298 1299
	}

	/* Must not be less than 1 second */
1300 1301 1302 1303
	if (erase_timeout < 1000)
		erase_timeout = 1000;

	return erase_timeout;
1304 1305
}

1306 1307 1308
static unsigned int mmc_erase_timeout(struct mmc_card *card,
				      unsigned int arg,
				      unsigned int qty)
1309 1310
{
	if (mmc_card_sd(card))
1311
		return mmc_sd_erase_timeout(card, arg, qty);
1312
	else
1313
		return mmc_mmc_erase_timeout(card, arg, qty);
1314 1315 1316 1317 1318
}

static int mmc_do_erase(struct mmc_card *card, unsigned int from,
			unsigned int to, unsigned int arg)
{
1319
	struct mmc_command cmd = {0};
1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385
	unsigned int qty = 0;
	int err;

	/*
	 * qty is used to calculate the erase timeout which depends on how many
	 * erase groups (or allocation units in SD terminology) are affected.
	 * We count erasing part of an erase group as one erase group.
	 * For SD, the allocation units are always a power of 2.  For MMC, the
	 * erase group size is almost certainly also power of 2, but it does not
	 * seem to insist on that in the JEDEC standard, so we fall back to
	 * division in that case.  SD may not specify an allocation unit size,
	 * in which case the timeout is based on the number of write blocks.
	 *
	 * Note that the timeout for secure trim 2 will only be correct if the
	 * number of erase groups specified is the same as the total of all
	 * preceding secure trim 1 commands.  Since the power may have been
	 * lost since the secure trim 1 commands occurred, it is generally
	 * impossible to calculate the secure trim 2 timeout correctly.
	 */
	if (card->erase_shift)
		qty += ((to >> card->erase_shift) -
			(from >> card->erase_shift)) + 1;
	else if (mmc_card_sd(card))
		qty += to - from + 1;
	else
		qty += ((to / card->erase_size) -
			(from / card->erase_size)) + 1;

	if (!mmc_card_blockaddr(card)) {
		from <<= 9;
		to <<= 9;
	}

	if (mmc_card_sd(card))
		cmd.opcode = SD_ERASE_WR_BLK_START;
	else
		cmd.opcode = MMC_ERASE_GROUP_START;
	cmd.arg = from;
	cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
	err = mmc_wait_for_cmd(card->host, &cmd, 0);
	if (err) {
		printk(KERN_ERR "mmc_erase: group start error %d, "
		       "status %#x\n", err, cmd.resp[0]);
		err = -EINVAL;
		goto out;
	}

	memset(&cmd, 0, sizeof(struct mmc_command));
	if (mmc_card_sd(card))
		cmd.opcode = SD_ERASE_WR_BLK_END;
	else
		cmd.opcode = MMC_ERASE_GROUP_END;
	cmd.arg = to;
	cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
	err = mmc_wait_for_cmd(card->host, &cmd, 0);
	if (err) {
		printk(KERN_ERR "mmc_erase: group end error %d, status %#x\n",
		       err, cmd.resp[0]);
		err = -EINVAL;
		goto out;
	}

	memset(&cmd, 0, sizeof(struct mmc_command));
	cmd.opcode = MMC_ERASE;
	cmd.arg = arg;
	cmd.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC;
1386
	cmd.cmd_timeout_ms = mmc_erase_timeout(card, arg, qty);
1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518
	err = mmc_wait_for_cmd(card->host, &cmd, 0);
	if (err) {
		printk(KERN_ERR "mmc_erase: erase error %d, status %#x\n",
		       err, cmd.resp[0]);
		err = -EIO;
		goto out;
	}

	if (mmc_host_is_spi(card->host))
		goto out;

	do {
		memset(&cmd, 0, sizeof(struct mmc_command));
		cmd.opcode = MMC_SEND_STATUS;
		cmd.arg = card->rca << 16;
		cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
		/* Do not retry else we can't see errors */
		err = mmc_wait_for_cmd(card->host, &cmd, 0);
		if (err || (cmd.resp[0] & 0xFDF92000)) {
			printk(KERN_ERR "error %d requesting status %#x\n",
				err, cmd.resp[0]);
			err = -EIO;
			goto out;
		}
	} while (!(cmd.resp[0] & R1_READY_FOR_DATA) ||
		 R1_CURRENT_STATE(cmd.resp[0]) == 7);
out:
	return err;
}

/**
 * mmc_erase - erase sectors.
 * @card: card to erase
 * @from: first sector to erase
 * @nr: number of sectors to erase
 * @arg: erase command argument (SD supports only %MMC_ERASE_ARG)
 *
 * Caller must claim host before calling this function.
 */
int mmc_erase(struct mmc_card *card, unsigned int from, unsigned int nr,
	      unsigned int arg)
{
	unsigned int rem, to = from + nr;

	if (!(card->host->caps & MMC_CAP_ERASE) ||
	    !(card->csd.cmdclass & CCC_ERASE))
		return -EOPNOTSUPP;

	if (!card->erase_size)
		return -EOPNOTSUPP;

	if (mmc_card_sd(card) && arg != MMC_ERASE_ARG)
		return -EOPNOTSUPP;

	if ((arg & MMC_SECURE_ARGS) &&
	    !(card->ext_csd.sec_feature_support & EXT_CSD_SEC_ER_EN))
		return -EOPNOTSUPP;

	if ((arg & MMC_TRIM_ARGS) &&
	    !(card->ext_csd.sec_feature_support & EXT_CSD_SEC_GB_CL_EN))
		return -EOPNOTSUPP;

	if (arg == MMC_SECURE_ERASE_ARG) {
		if (from % card->erase_size || nr % card->erase_size)
			return -EINVAL;
	}

	if (arg == MMC_ERASE_ARG) {
		rem = from % card->erase_size;
		if (rem) {
			rem = card->erase_size - rem;
			from += rem;
			if (nr > rem)
				nr -= rem;
			else
				return 0;
		}
		rem = nr % card->erase_size;
		if (rem)
			nr -= rem;
	}

	if (nr == 0)
		return 0;

	to = from + nr;

	if (to <= from)
		return -EINVAL;

	/* 'from' and 'to' are inclusive */
	to -= 1;

	return mmc_do_erase(card, from, to, arg);
}
EXPORT_SYMBOL(mmc_erase);

int mmc_can_erase(struct mmc_card *card)
{
	if ((card->host->caps & MMC_CAP_ERASE) &&
	    (card->csd.cmdclass & CCC_ERASE) && card->erase_size)
		return 1;
	return 0;
}
EXPORT_SYMBOL(mmc_can_erase);

int mmc_can_trim(struct mmc_card *card)
{
	if (card->ext_csd.sec_feature_support & EXT_CSD_SEC_GB_CL_EN)
		return 1;
	return 0;
}
EXPORT_SYMBOL(mmc_can_trim);

int mmc_can_secure_erase_trim(struct mmc_card *card)
{
	if (card->ext_csd.sec_feature_support & EXT_CSD_SEC_ER_EN)
		return 1;
	return 0;
}
EXPORT_SYMBOL(mmc_can_secure_erase_trim);

int mmc_erase_group_aligned(struct mmc_card *card, unsigned int from,
			    unsigned int nr)
{
	if (!card->erase_size)
		return 0;
	if (from % card->erase_size || nr % card->erase_size)
		return 0;
	return 1;
}
EXPORT_SYMBOL(mmc_erase_group_aligned);
L
Linus Torvalds 已提交
1519

1520 1521
int mmc_set_blocklen(struct mmc_card *card, unsigned int blocklen)
{
1522
	struct mmc_command cmd = {0};
1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533

	if (mmc_card_blockaddr(card) || mmc_card_ddr_mode(card))
		return 0;

	cmd.opcode = MMC_SET_BLOCKLEN;
	cmd.arg = blocklen;
	cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
	return mmc_wait_for_cmd(card->host, &cmd, 5);
}
EXPORT_SYMBOL(mmc_set_blocklen);

1534 1535 1536 1537 1538 1539 1540 1541 1542
static int mmc_rescan_try_freq(struct mmc_host *host, unsigned freq)
{
	host->f_init = freq;

#ifdef CONFIG_MMC_DEBUG
	pr_info("%s: %s: trying to init card at %u Hz\n",
		mmc_hostname(host), __func__, host->f_init);
#endif
	mmc_power_up(host);
1543 1544 1545 1546 1547 1548

	/*
	 * sdio_reset sends CMD52 to reset card.  Since we do not know
	 * if the card is being re-initialized, just send it.  CMD52
	 * should be ignored by SD/eMMC cards.
	 */
1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565
	sdio_reset(host);
	mmc_go_idle(host);

	mmc_send_if_cond(host, host->ocr_avail);

	/* Order's important: probe SDIO, then SD, then MMC */
	if (!mmc_attach_sdio(host))
		return 0;
	if (!mmc_attach_sd(host))
		return 0;
	if (!mmc_attach_mmc(host))
		return 0;

	mmc_power_off(host);
	return -EIO;
}

1566
void mmc_rescan(struct work_struct *work)
L
Linus Torvalds 已提交
1567
{
1568
	static const unsigned freqs[] = { 400000, 300000, 200000, 100000 };
D
David Howells 已提交
1569 1570
	struct mmc_host *host =
		container_of(work, struct mmc_host, detect.work);
H
Hein Tibosch 已提交
1571
	int i;
1572

1573
	if (host->rescan_disable)
1574
		return;
L
Linus Torvalds 已提交
1575

P
Pierre Ossman 已提交
1576
	mmc_bus_get(host);
P
Pierre Ossman 已提交
1577

1578 1579 1580 1581 1582
	/*
	 * if there is a _removable_ card registered, check whether it is
	 * still present
	 */
	if (host->bus_ops && host->bus_ops->detect && !host->bus_dead
1583
	    && !(host->caps & MMC_CAP_NONREMOVABLE))
1584 1585
		host->bus_ops->detect(host);

1586 1587 1588 1589
	/*
	 * Let mmc_bus_put() free the bus/bus_ops if we've found that
	 * the card is no longer present.
	 */
1590 1591 1592 1593 1594
	mmc_bus_put(host);
	mmc_bus_get(host);

	/* if there still is a card present, stop here */
	if (host->bus_ops != NULL) {
P
Pierre Ossman 已提交
1595
		mmc_bus_put(host);
1596 1597
		goto out;
	}
L
Linus Torvalds 已提交
1598

1599 1600 1601 1602 1603
	/*
	 * Only we can add a new handler, so it's safe to
	 * release the lock here.
	 */
	mmc_bus_put(host);
L
Linus Torvalds 已提交
1604

1605 1606
	if (host->ops->get_cd && host->ops->get_cd(host) == 0)
		goto out;
L
Linus Torvalds 已提交
1607

1608
	mmc_claim_host(host);
H
Hein Tibosch 已提交
1609
	for (i = 0; i < ARRAY_SIZE(freqs); i++) {
1610 1611 1612 1613
		if (!mmc_rescan_try_freq(host, max(freqs[i], host->f_min)))
			break;
		if (freqs[i] < host->f_min)
			break;
H
Hein Tibosch 已提交
1614
	}
1615 1616 1617
	mmc_release_host(host);

 out:
1618 1619
	if (host->caps & MMC_CAP_NEEDS_POLL)
		mmc_schedule_delayed_work(&host->detect, HZ);
L
Linus Torvalds 已提交
1620 1621
}

1622
void mmc_start_host(struct mmc_host *host)
L
Linus Torvalds 已提交
1623
{
1624 1625
	mmc_power_off(host);
	mmc_detect_change(host, 0);
L
Linus Torvalds 已提交
1626 1627
}

1628
void mmc_stop_host(struct mmc_host *host)
L
Linus Torvalds 已提交
1629
{
1630
#ifdef CONFIG_MMC_DEBUG
1631 1632
	unsigned long flags;
	spin_lock_irqsave(&host->lock, flags);
1633
	host->removed = 1;
1634
	spin_unlock_irqrestore(&host->lock, flags);
1635 1636
#endif

1637 1638
	if (host->caps & MMC_CAP_DISABLE)
		cancel_delayed_work(&host->disable);
1639
	cancel_delayed_work_sync(&host->detect);
1640 1641
	mmc_flush_scheduled_work();

1642 1643 1644
	/* clear pm flags now and let card drivers set them as needed */
	host->pm_flags = 0;

P
Pierre Ossman 已提交
1645 1646 1647 1648 1649 1650 1651 1652
	mmc_bus_get(host);
	if (host->bus_ops && !host->bus_dead) {
		if (host->bus_ops->remove)
			host->bus_ops->remove(host);

		mmc_claim_host(host);
		mmc_detach_bus(host);
		mmc_release_host(host);
D
Denis Karpov 已提交
1653 1654
		mmc_bus_put(host);
		return;
L
Linus Torvalds 已提交
1655
	}
P
Pierre Ossman 已提交
1656 1657 1658
	mmc_bus_put(host);

	BUG_ON(host->card);
L
Linus Torvalds 已提交
1659 1660 1661 1662

	mmc_power_off(host);
}

1663
int mmc_power_save_host(struct mmc_host *host)
1664
{
1665 1666
	int ret = 0;

1667 1668 1669 1670
	mmc_bus_get(host);

	if (!host->bus_ops || host->bus_dead || !host->bus_ops->power_restore) {
		mmc_bus_put(host);
1671
		return -EINVAL;
1672 1673 1674
	}

	if (host->bus_ops->power_save)
1675
		ret = host->bus_ops->power_save(host);
1676 1677 1678 1679

	mmc_bus_put(host);

	mmc_power_off(host);
1680 1681

	return ret;
1682 1683 1684
}
EXPORT_SYMBOL(mmc_power_save_host);

1685
int mmc_power_restore_host(struct mmc_host *host)
1686
{
1687 1688
	int ret;

1689 1690 1691 1692
	mmc_bus_get(host);

	if (!host->bus_ops || host->bus_dead || !host->bus_ops->power_restore) {
		mmc_bus_put(host);
1693
		return -EINVAL;
1694 1695 1696
	}

	mmc_power_up(host);
1697
	ret = host->bus_ops->power_restore(host);
1698 1699

	mmc_bus_put(host);
1700 1701

	return ret;
1702 1703 1704
}
EXPORT_SYMBOL(mmc_power_restore_host);

1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744
int mmc_card_awake(struct mmc_host *host)
{
	int err = -ENOSYS;

	mmc_bus_get(host);

	if (host->bus_ops && !host->bus_dead && host->bus_ops->awake)
		err = host->bus_ops->awake(host);

	mmc_bus_put(host);

	return err;
}
EXPORT_SYMBOL(mmc_card_awake);

int mmc_card_sleep(struct mmc_host *host)
{
	int err = -ENOSYS;

	mmc_bus_get(host);

	if (host->bus_ops && !host->bus_dead && host->bus_ops->awake)
		err = host->bus_ops->sleep(host);

	mmc_bus_put(host);

	return err;
}
EXPORT_SYMBOL(mmc_card_sleep);

int mmc_card_can_sleep(struct mmc_host *host)
{
	struct mmc_card *card = host->card;

	if (card && mmc_card_mmc(card) && card->ext_csd.rev >= 3)
		return 1;
	return 0;
}
EXPORT_SYMBOL(mmc_card_can_sleep);

L
Linus Torvalds 已提交
1745 1746 1747 1748 1749 1750
#ifdef CONFIG_PM

/**
 *	mmc_suspend_host - suspend a host
 *	@host: mmc host
 */
1751
int mmc_suspend_host(struct mmc_host *host)
L
Linus Torvalds 已提交
1752
{
1753 1754
	int err = 0;

1755 1756
	if (host->caps & MMC_CAP_DISABLE)
		cancel_delayed_work(&host->disable);
1757
	cancel_delayed_work(&host->detect);
P
Pierre Ossman 已提交
1758 1759
	mmc_flush_scheduled_work();

P
Pierre Ossman 已提交
1760 1761
	mmc_bus_get(host);
	if (host->bus_ops && !host->bus_dead) {
1762
		if (host->bus_ops->suspend)
1763
			err = host->bus_ops->suspend(host);
1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776
		if (err == -ENOSYS || !host->bus_ops->resume) {
			/*
			 * We simply "remove" the card in this case.
			 * It will be redetected on resume.
			 */
			if (host->bus_ops->remove)
				host->bus_ops->remove(host);
			mmc_claim_host(host);
			mmc_detach_bus(host);
			mmc_release_host(host);
			host->pm_flags = 0;
			err = 0;
		}
P
Pierre Ossman 已提交
1777
	}
P
Pierre Ossman 已提交
1778 1779
	mmc_bus_put(host);

1780
	if (!err && !mmc_card_keep_power(host))
1781
		mmc_power_off(host);
L
Linus Torvalds 已提交
1782

1783
	return err;
L
Linus Torvalds 已提交
1784 1785 1786 1787 1788 1789 1790 1791 1792 1793
}

EXPORT_SYMBOL(mmc_suspend_host);

/**
 *	mmc_resume_host - resume a previously suspended host
 *	@host: mmc host
 */
int mmc_resume_host(struct mmc_host *host)
{
1794 1795
	int err = 0;

1796 1797
	mmc_bus_get(host);
	if (host->bus_ops && !host->bus_dead) {
1798
		if (!mmc_card_keep_power(host)) {
1799 1800
			mmc_power_up(host);
			mmc_select_voltage(host, host->ocr);
1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812
			/*
			 * Tell runtime PM core we just powered up the card,
			 * since it still believes the card is powered off.
			 * Note that currently runtime PM is only enabled
			 * for SDIO cards that are MMC_CAP_POWER_OFF_CARD
			 */
			if (mmc_card_sdio(host->card) &&
			    (host->caps & MMC_CAP_POWER_OFF_CARD)) {
				pm_runtime_disable(&host->card->dev);
				pm_runtime_set_active(&host->card->dev);
				pm_runtime_enable(&host->card->dev);
			}
1813
		}
1814
		BUG_ON(!host->bus_ops->resume);
1815 1816 1817 1818 1819 1820 1821
		err = host->bus_ops->resume(host);
		if (err) {
			printk(KERN_WARNING "%s: error %d during resume "
					    "(card was removed?)\n",
					    mmc_hostname(host), err);
			err = 0;
		}
1822 1823 1824
	}
	mmc_bus_put(host);

1825
	return err;
L
Linus Torvalds 已提交
1826 1827 1828
}
EXPORT_SYMBOL(mmc_resume_host);

1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864
/* Do the card removal on suspend if card is assumed removeable
 * Do that in pm notifier while userspace isn't yet frozen, so we will be able
   to sync the card.
*/
int mmc_pm_notify(struct notifier_block *notify_block,
					unsigned long mode, void *unused)
{
	struct mmc_host *host = container_of(
		notify_block, struct mmc_host, pm_notify);
	unsigned long flags;


	switch (mode) {
	case PM_HIBERNATION_PREPARE:
	case PM_SUSPEND_PREPARE:

		spin_lock_irqsave(&host->lock, flags);
		host->rescan_disable = 1;
		spin_unlock_irqrestore(&host->lock, flags);
		cancel_delayed_work_sync(&host->detect);

		if (!host->bus_ops || host->bus_ops->suspend)
			break;

		mmc_claim_host(host);

		if (host->bus_ops->remove)
			host->bus_ops->remove(host);

		mmc_detach_bus(host);
		mmc_release_host(host);
		host->pm_flags = 0;
		break;

	case PM_POST_SUSPEND:
	case PM_POST_HIBERNATION:
1865
	case PM_POST_RESTORE:
1866 1867 1868 1869 1870 1871 1872 1873 1874 1875

		spin_lock_irqsave(&host->lock, flags);
		host->rescan_disable = 0;
		spin_unlock_irqrestore(&host->lock, flags);
		mmc_detect_change(host, 0);

	}

	return 0;
}
L
Linus Torvalds 已提交
1876 1877
#endif

1878 1879 1880 1881
static int __init mmc_init(void)
{
	int ret;

T
Tejun Heo 已提交
1882
	workqueue = alloc_ordered_workqueue("kmmcd", 0);
1883 1884 1885 1886
	if (!workqueue)
		return -ENOMEM;

	ret = mmc_register_bus();
P
Pierre Ossman 已提交
1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906
	if (ret)
		goto destroy_workqueue;

	ret = mmc_register_host_class();
	if (ret)
		goto unregister_bus;

	ret = sdio_register_bus();
	if (ret)
		goto unregister_host_class;

	return 0;

unregister_host_class:
	mmc_unregister_host_class();
unregister_bus:
	mmc_unregister_bus();
destroy_workqueue:
	destroy_workqueue(workqueue);

1907 1908 1909 1910 1911
	return ret;
}

static void __exit mmc_exit(void)
{
P
Pierre Ossman 已提交
1912
	sdio_unregister_bus();
1913 1914 1915 1916 1917
	mmc_unregister_host_class();
	mmc_unregister_bus();
	destroy_workqueue(workqueue);
}

1918
subsys_initcall(mmc_init);
1919 1920
module_exit(mmc_exit);

L
Linus Torvalds 已提交
1921
MODULE_LICENSE("GPL");