core.c 67.1 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>
26
#include <linux/suspend.h>
P
Per Forlin 已提交
27 28
#include <linux/fault-inject.h>
#include <linux/random.h>
29
#include <linux/slab.h>
L
Linus Torvalds 已提交
30 31 32

#include <linux/mmc/card.h>
#include <linux/mmc/host.h>
P
Pierre Ossman 已提交
33 34
#include <linux/mmc/mmc.h>
#include <linux/mmc/sd.h>
L
Linus Torvalds 已提交
35

36
#include "core.h"
37 38
#include "bus.h"
#include "host.h"
P
Pierre Ossman 已提交
39
#include "sdio_bus.h"
P
Pierre Ossman 已提交
40 41 42

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

45 46 47
/* If the device is not responding */
#define MMC_CORE_TIMEOUT_MS	(10 * 60 * 1000) /* 10 minute timeout */

48 49 50 51 52 53
/*
 * Background operations can take a long time, depending on the housekeeping
 * operations the card has to perform.
 */
#define MMC_BKOPS_MAX_TIMEOUT	(4 * 60 * 1000) /* max time to wait in ms */

54
static struct workqueue_struct *workqueue;
55
static const unsigned freqs[] = { 400000, 300000, 200000, 100000 };
56

D
David Brownell 已提交
57 58 59 60 61
/*
 * 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.
 */
62
bool use_spi_crc = 1;
D
David Brownell 已提交
63 64
module_param(use_spi_crc, bool, 0);

65 66 67 68 69 70 71
/*
 * 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
72
bool mmc_assume_removable;
73
#else
74
bool mmc_assume_removable = 1;
75
#endif
76
EXPORT_SYMBOL(mmc_assume_removable);
77 78 79 80 81
module_param_named(removable, mmc_assume_removable, bool, 0644);
MODULE_PARM_DESC(
	removable,
	"MMC/SD cards are removable and may be removed during suspend");

82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
/*
 * 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);
}

P
Per Forlin 已提交
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
#ifdef CONFIG_FAIL_MMC_REQUEST

/*
 * Internal function. Inject random data errors.
 * If mmc_data is NULL no errors are injected.
 */
static void mmc_should_fail_request(struct mmc_host *host,
				    struct mmc_request *mrq)
{
	struct mmc_command *cmd = mrq->cmd;
	struct mmc_data *data = mrq->data;
	static const int data_errors[] = {
		-ETIMEDOUT,
		-EILSEQ,
		-EIO,
	};

	if (!data)
		return;

	if (cmd->error || data->error ||
	    !should_fail(&host->fail_mmc_request, data->blksz * data->blocks))
		return;

	data->error = data_errors[random32() % ARRAY_SIZE(data_errors)];
	data->bytes_xfered = (random32() % (data->bytes_xfered >> 9)) << 9;
}

#else /* CONFIG_FAIL_MMC_REQUEST */

static inline void mmc_should_fail_request(struct mmc_host *host,
					   struct mmc_request *mrq)
{
}

#endif /* CONFIG_FAIL_MMC_REQUEST */

L
Linus Torvalds 已提交
136
/**
137 138 139
 *	mmc_request_done - finish processing an MMC request
 *	@host: MMC host which completed request
 *	@mrq: MMC request which request
L
Linus Torvalds 已提交
140 141
 *
 *	MMC drivers should call this function when they have completed
142
 *	their processing of a request.
L
Linus Torvalds 已提交
143 144 145 146
 */
void mmc_request_done(struct mmc_host *host, struct mmc_request *mrq)
{
	struct mmc_command *cmd = mrq->cmd;
147 148
	int err = cmd->error;

D
David Brownell 已提交
149 150 151 152 153
	if (err && cmd->retries && mmc_host_is_spi(host)) {
		if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND)
			cmd->retries = 0;
	}

154
	if (err && cmd->retries && !mmc_card_removed(host->card)) {
155 156 157 158 159 160
		/*
		 * Request starter must handle retries - see
		 * mmc_wait_for_req_done().
		 */
		if (mrq->done)
			mrq->done(mrq);
161
	} else {
P
Per Forlin 已提交
162 163
		mmc_should_fail_request(host, mrq);

P
Pierre Ossman 已提交
164 165
		led_trigger_event(host->led, LED_OFF);

166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186
		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);
187

188
		mmc_host_clk_release(host);
L
Linus Torvalds 已提交
189 190 191 192 193
	}
}

EXPORT_SYMBOL(mmc_request_done);

194
static void
L
Linus Torvalds 已提交
195 196
mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
{
P
Pierre Ossman 已提交
197 198
#ifdef CONFIG_MMC_DEBUG
	unsigned int i, sz;
199
	struct scatterlist *sg;
P
Pierre Ossman 已提交
200 201
#endif

202 203 204 205 206 207
	if (mrq->sbc) {
		pr_debug("<%s: starting CMD%u arg %08x flags %08x>\n",
			 mmc_hostname(host), mrq->sbc->opcode,
			 mrq->sbc->arg, mrq->sbc->flags);
	}

208 209 210
	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 已提交
211

212 213 214 215 216
	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,
217
			mrq->data->timeout_ns / 1000000,
218 219 220 221 222 223 224 225 226
			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 已提交
227
	WARN_ON(!host->claimed);
L
Linus Torvalds 已提交
228 229 230 231

	mrq->cmd->error = 0;
	mrq->cmd->mrq = mrq;
	if (mrq->data) {
232
		BUG_ON(mrq->data->blksz > host->max_blk_size);
233 234 235
		BUG_ON(mrq->data->blocks > host->max_blk_count);
		BUG_ON(mrq->data->blocks * mrq->data->blksz >
			host->max_req_size);
236

P
Pierre Ossman 已提交
237 238
#ifdef CONFIG_MMC_DEBUG
		sz = 0;
239 240
		for_each_sg(mrq->data->sg, sg, mrq->data->sg_len, i)
			sz += sg->length;
P
Pierre Ossman 已提交
241 242 243
		BUG_ON(sz != mrq->data->blocks * mrq->data->blksz);
#endif

L
Linus Torvalds 已提交
244 245 246 247 248 249 250 251 252
		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;
		}
	}
253
	mmc_host_clk_hold(host);
254
	led_trigger_event(host->led, LED_FULL);
L
Linus Torvalds 已提交
255 256 257
	host->ops->request(host, mrq);
}

258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321
/**
 *	mmc_start_bkops - start BKOPS for supported cards
 *	@card: MMC card to start BKOPS
 *	@form_exception: A flag to indicate if this function was
 *			 called due to an exception raised by the card
 *
 *	Start background operations whenever requested.
 *	When the urgent BKOPS bit is set in a R1 command response
 *	then background operations should be started immediately.
*/
void mmc_start_bkops(struct mmc_card *card, bool from_exception)
{
	int err;
	int timeout;
	bool use_busy_signal;

	BUG_ON(!card);

	if (!card->ext_csd.bkops_en || mmc_card_doing_bkops(card))
		return;

	err = mmc_read_bkops_status(card);
	if (err) {
		pr_err("%s: Failed to read bkops status: %d\n",
		       mmc_hostname(card->host), err);
		return;
	}

	if (!card->ext_csd.raw_bkops_status)
		return;

	if (card->ext_csd.raw_bkops_status < EXT_CSD_BKOPS_LEVEL_2 &&
	    from_exception)
		return;

	mmc_claim_host(card->host);
	if (card->ext_csd.raw_bkops_status >= EXT_CSD_BKOPS_LEVEL_2) {
		timeout = MMC_BKOPS_MAX_TIMEOUT;
		use_busy_signal = true;
	} else {
		timeout = 0;
		use_busy_signal = false;
	}

	err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
			EXT_CSD_BKOPS_START, 1, timeout, use_busy_signal);
	if (err) {
		pr_warn("%s: Error %d starting bkops\n",
			mmc_hostname(card->host), err);
		goto out;
	}

	/*
	 * For urgent bkops status (LEVEL_2 and more)
	 * bkops executed synchronously, otherwise
	 * the operation is in progress
	 */
	if (!use_busy_signal)
		mmc_card_set_doing_bkops(card);
out:
	mmc_release_host(card->host);
}
EXPORT_SYMBOL(mmc_start_bkops);

322 323 324 325 326 327 328 329 330 331 332 333
/*
 * mmc_wait_data_done() - done callback for data request
 * @mrq: done data request
 *
 * Wakes up mmc context, passed as a callback to host controller driver
 */
static void mmc_wait_data_done(struct mmc_request *mrq)
{
	mrq->host->context_info.is_done_rcv = true;
	wake_up_interruptible(&mrq->host->context_info.wait);
}

L
Linus Torvalds 已提交
334 335
static void mmc_wait_done(struct mmc_request *mrq)
{
336 337 338
	complete(&mrq->completion);
}

339 340 341 342 343 344 345 346 347 348 349 350 351 352
/*
 *__mmc_start_data_req() - starts data request
 * @host: MMC host to start the request
 * @mrq: data request to start
 *
 * Sets the done callback to be called when request is completed by the card.
 * Starts data mmc request execution
 */
static int __mmc_start_data_req(struct mmc_host *host, struct mmc_request *mrq)
{
	mrq->done = mmc_wait_data_done;
	mrq->host = host;
	if (mmc_card_removed(host->card)) {
		mrq->cmd->error = -ENOMEDIUM;
353
		mmc_wait_data_done(mrq);
354 355 356 357 358 359 360
		return -ENOMEDIUM;
	}
	mmc_start_request(host, mrq);

	return 0;
}

361
static int __mmc_start_req(struct mmc_host *host, struct mmc_request *mrq)
362 363 364
{
	init_completion(&mrq->completion);
	mrq->done = mmc_wait_done;
365 366 367
	if (mmc_card_removed(host->card)) {
		mrq->cmd->error = -ENOMEDIUM;
		complete(&mrq->completion);
368
		return -ENOMEDIUM;
369
	}
370
	mmc_start_request(host, mrq);
371
	return 0;
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
/*
 * mmc_wait_for_data_req_done() - wait for request completed
 * @host: MMC host to prepare the command.
 * @mrq: MMC request to wait for
 *
 * Blocks MMC context till host controller will ack end of data request
 * execution or new request notification arrives from the block layer.
 * Handles command retries.
 *
 * Returns enum mmc_blk_status after checking errors.
 */
static int mmc_wait_for_data_req_done(struct mmc_host *host,
				      struct mmc_request *mrq,
				      struct mmc_async_req *next_req)
{
	struct mmc_command *cmd;
	struct mmc_context_info *context_info = &host->context_info;
	int err;
	unsigned long flags;

	while (1) {
		wait_event_interruptible(context_info->wait,
				(context_info->is_done_rcv ||
				 context_info->is_new_req));
		spin_lock_irqsave(&context_info->lock, flags);
		context_info->is_waiting_last_req = false;
		spin_unlock_irqrestore(&context_info->lock, flags);
		if (context_info->is_done_rcv) {
			context_info->is_done_rcv = false;
			context_info->is_new_req = false;
			cmd = mrq->cmd;
			if (!cmd->error || !cmd->retries ||
			    mmc_card_removed(host->card)) {
				err = host->areq->err_check(host->card,
							    host->areq);
				break; /* return err */
			} else {
				pr_info("%s: req failed (CMD%u): %d, retrying...\n",
					mmc_hostname(host),
					cmd->opcode, cmd->error);
				cmd->retries--;
				cmd->error = 0;
				host->ops->request(host, mrq);
				continue; /* wait for done/new event again */
			}
		} else if (context_info->is_new_req) {
			context_info->is_new_req = false;
			if (!next_req) {
				err = MMC_BLK_NEW_REQUEST;
				break; /* return err */
			}
		}
	}
	return err;
}

430 431 432
static void mmc_wait_for_req_done(struct mmc_host *host,
				  struct mmc_request *mrq)
{
433 434 435 436 437 438
	struct mmc_command *cmd;

	while (1) {
		wait_for_completion(&mrq->completion);

		cmd = mrq->cmd;
439 440
		if (!cmd->error || !cmd->retries ||
		    mmc_card_removed(host->card))
441 442 443 444 445 446 447 448
			break;

		pr_debug("%s: req failed (CMD%u): %d, retrying...\n",
			 mmc_hostname(host), cmd->opcode, cmd->error);
		cmd->retries--;
		cmd->error = 0;
		host->ops->request(host, mrq);
	}
449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464
}

/**
 *	mmc_pre_req - Prepare for a new request
 *	@host: MMC host to prepare command
 *	@mrq: MMC request to prepare for
 *	@is_first_req: true if there is no previous started request
 *                     that may run in parellel to this call, otherwise false
 *
 *	mmc_pre_req() is called in prior to mmc_start_req() to let
 *	host prepare for the new request. Preparation of a request may be
 *	performed while another request is running on the host.
 */
static void mmc_pre_req(struct mmc_host *host, struct mmc_request *mrq,
		 bool is_first_req)
{
465 466
	if (host->ops->pre_req) {
		mmc_host_clk_hold(host);
467
		host->ops->pre_req(host, mrq, is_first_req);
468 469
		mmc_host_clk_release(host);
	}
470 471 472 473 474 475 476 477 478 479 480 481 482 483
}

/**
 *	mmc_post_req - Post process a completed request
 *	@host: MMC host to post process command
 *	@mrq: MMC request to post process for
 *	@err: Error, if non zero, clean up any resources made in pre_req
 *
 *	Let the host post process a completed request. Post processing of
 *	a request may be performed while another reuqest is running.
 */
static void mmc_post_req(struct mmc_host *host, struct mmc_request *mrq,
			 int err)
{
484 485
	if (host->ops->post_req) {
		mmc_host_clk_hold(host);
486
		host->ops->post_req(host, mrq, err);
487 488
		mmc_host_clk_release(host);
	}
L
Linus Torvalds 已提交
489 490
}

491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510
/**
 *	mmc_start_req - start a non-blocking request
 *	@host: MMC host to start command
 *	@areq: async request to start
 *	@error: out parameter returns 0 for success, otherwise non zero
 *
 *	Start a new MMC custom command request for a host.
 *	If there is on ongoing async request wait for completion
 *	of that request and start the new one and return.
 *	Does not wait for the new request to complete.
 *
 *      Returns the completed request, NULL in case of none completed.
 *	Wait for the an ongoing request (previoulsy started) to complete and
 *	return the completed request. If there is no ongoing request, NULL
 *	is returned without waiting. NULL is not an error condition.
 */
struct mmc_async_req *mmc_start_req(struct mmc_host *host,
				    struct mmc_async_req *areq, int *error)
{
	int err = 0;
511
	int start_err = 0;
512 513 514 515 516 517 518
	struct mmc_async_req *data = host->areq;

	/* Prepare a new request */
	if (areq)
		mmc_pre_req(host, areq->mrq, !host->areq);

	if (host->areq) {
J
Jaehoon Chung 已提交
519 520 521 522 523 524 525 526 527 528
		err = mmc_wait_for_data_req_done(host, host->areq->mrq,	areq);
		if (err == MMC_BLK_NEW_REQUEST) {
			if (error)
				*error = err;
			/*
			 * The previous request was not completed,
			 * nothing to return
			 */
			return NULL;
		}
529 530 531 532 533 534 535 536
		/*
		 * Check BKOPS urgency for each R1 response
		 */
		if (host->card && mmc_card_mmc(host->card) &&
		    ((mmc_resp_type(host->areq->mrq->cmd) == MMC_RSP_R1) ||
		     (mmc_resp_type(host->areq->mrq->cmd) == MMC_RSP_R1B)) &&
		    (host->areq->mrq->cmd->resp[0] & R1_EXCEPTION_EVENT))
			mmc_start_bkops(host->card, true);
537 538
	}

539
	if (!err && areq)
540
		start_err = __mmc_start_data_req(host, areq->mrq);
541 542 543 544

	if (host->areq)
		mmc_post_req(host, host->areq->mrq, 0);

545 546
	 /* Cancel a prepared request if it was not started. */
	if ((err || start_err) && areq)
J
Jaehoon Chung 已提交
547
		mmc_post_req(host, areq->mrq, -EINVAL);
548 549 550 551 552 553

	if (err)
		host->areq = NULL;
	else
		host->areq = areq;

554 555 556 557 558 559
	if (error)
		*error = err;
	return data;
}
EXPORT_SYMBOL(mmc_start_req);

P
Pierre Ossman 已提交
560 561 562 563 564 565 566 567 568 569
/**
 *	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 已提交
570
{
571 572
	__mmc_start_req(host, mrq);
	mmc_wait_for_req_done(host, mrq);
L
Linus Torvalds 已提交
573 574 575
}
EXPORT_SYMBOL(mmc_wait_for_req);

576 577 578 579 580
/**
 *	mmc_interrupt_hpi - Issue for High priority Interrupt
 *	@card: the MMC card associated with the HPI transfer
 *
 *	Issued High Priority Interrupt, and check for card status
581
 *	until out-of prg-state.
582 583 584 585 586
 */
int mmc_interrupt_hpi(struct mmc_card *card)
{
	int err;
	u32 status;
587
	unsigned long prg_wait;
588 589 590 591 592 593 594 595 596 597 598 599 600 601 602

	BUG_ON(!card);

	if (!card->ext_csd.hpi_en) {
		pr_info("%s: HPI enable bit unset\n", mmc_hostname(card->host));
		return 1;
	}

	mmc_claim_host(card->host);
	err = mmc_send_status(card, &status);
	if (err) {
		pr_err("%s: Get card status fail\n", mmc_hostname(card->host));
		goto out;
	}

603 604 605 606
	switch (R1_CURRENT_STATE(status)) {
	case R1_STATE_IDLE:
	case R1_STATE_READY:
	case R1_STATE_STBY:
607
	case R1_STATE_TRAN:
608
		/*
609
		 * In idle and transfer states, HPI is not needed and the caller
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
		 * can issue the next intended command immediately
		 */
		goto out;
	case R1_STATE_PRG:
		break;
	default:
		/* In all other states, it's illegal to issue HPI */
		pr_debug("%s: HPI cannot be sent. Card state=%d\n",
			mmc_hostname(card->host), R1_CURRENT_STATE(status));
		err = -EINVAL;
		goto out;
	}

	err = mmc_send_hpi_cmd(card, &status);
	if (err)
		goto out;

	prg_wait = jiffies + msecs_to_jiffies(card->ext_csd.out_of_int_time);
	do {
		err = mmc_send_status(card, &status);

		if (!err && R1_CURRENT_STATE(status) == R1_STATE_TRAN)
			break;
		if (time_after(jiffies, prg_wait))
			err = -ETIMEDOUT;
	} while (!err);
636 637 638 639 640 641 642

out:
	mmc_release_host(card->host);
	return err;
}
EXPORT_SYMBOL(mmc_interrupt_hpi);

L
Linus Torvalds 已提交
643 644 645 646 647 648 649 650 651 652 653 654
/**
 *	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)
{
655
	struct mmc_request mrq = {NULL};
L
Linus Torvalds 已提交
656

P
Pierre Ossman 已提交
657
	WARN_ON(!host->claimed);
L
Linus Torvalds 已提交
658 659 660 661 662 663 664 665 666 667 668 669 670 671

	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);

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 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729
/**
 *	mmc_stop_bkops - stop ongoing BKOPS
 *	@card: MMC card to check BKOPS
 *
 *	Send HPI command to stop ongoing background operations to
 *	allow rapid servicing of foreground operations, e.g. read/
 *	writes. Wait until the card comes out of the programming state
 *	to avoid errors in servicing read/write requests.
 */
int mmc_stop_bkops(struct mmc_card *card)
{
	int err = 0;

	BUG_ON(!card);
	err = mmc_interrupt_hpi(card);

	/*
	 * If err is EINVAL, we can't issue an HPI.
	 * It should complete the BKOPS.
	 */
	if (!err || (err == -EINVAL)) {
		mmc_card_clr_doing_bkops(card);
		err = 0;
	}

	return err;
}
EXPORT_SYMBOL(mmc_stop_bkops);

int mmc_read_bkops_status(struct mmc_card *card)
{
	int err;
	u8 *ext_csd;

	/*
	 * In future work, we should consider storing the entire ext_csd.
	 */
	ext_csd = kmalloc(512, GFP_KERNEL);
	if (!ext_csd) {
		pr_err("%s: could not allocate buffer to receive the ext_csd.\n",
		       mmc_hostname(card->host));
		return -ENOMEM;
	}

	mmc_claim_host(card->host);
	err = mmc_send_ext_csd(card, ext_csd);
	mmc_release_host(card->host);
	if (err)
		goto out;

	card->ext_csd.raw_bkops_status = ext_csd[EXT_CSD_BKOPS_STATUS];
	card->ext_csd.raw_exception_status = ext_csd[EXT_CSD_EXP_EVENTS_STATUS];
out:
	kfree(ext_csd);
	return err;
}
EXPORT_SYMBOL(mmc_read_bkops_status);

730 731 732 733
/**
 *	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 已提交
734 735 736
 *
 *	Computes the data timeout parameters according to the
 *	correct algorithm given the card type.
737
 */
738
void mmc_set_data_timeout(struct mmc_data *data, const struct mmc_card *card)
739 740 741
{
	unsigned int mult;

742 743 744 745 746 747 748 749 750
	/*
	 * 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;
	}

751 752 753 754 755 756 757 758 759
	/*
	 * 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.
	 */
760
	if (data->flags & MMC_DATA_WRITE)
761 762 763 764 765 766 767 768 769 770 771 772
		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;
773 774 775
		if (mmc_host_clk_rate(card->host))
			timeout_us += data->timeout_clks * 1000 /
				(mmc_host_clk_rate(card->host) / 1000);
776

777
		if (data->flags & MMC_DATA_WRITE)
778
			/*
779 780 781 782 783 784
			 * The MMC spec "It is strongly recommended
			 * for hosts to implement more than 500ms
			 * timeout value even if the card indicates
			 * the 250ms maximum busy length."  Even the
			 * previous value of 300ms is known to be
			 * insufficient for some cards.
785
			 */
786
			limit_us = 3000000;
787 788 789
		else
			limit_us = 100000;

790 791 792 793
		/*
		 * SDHC cards always use these fixed values.
		 */
		if (timeout_us > limit_us || mmc_card_blockaddr(card)) {
794 795 796 797
			data->timeout_ns = limit_us * 1000;
			data->timeout_clks = 0;
		}
	}
798 799 800 801 802 803 804 805 806 807 808 809

	/*
	 * Some cards require longer data read timeout than indicated in CSD.
	 * Address this by setting the read timeout to a "reasonably high"
	 * value. For the cards tested, 300ms has proven enough. If necessary,
	 * this value can be increased if other problematic cards require this.
	 */
	if (mmc_card_long_read_time(card) && data->flags & MMC_DATA_READ) {
		data->timeout_ns = 300000000;
		data->timeout_clks = 0;
	}

810 811 812 813 814 815 816 817 818 819 820 821 822 823 824
	/*
	 * 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 */
		}
	}
825 826 827
}
EXPORT_SYMBOL(mmc_set_data_timeout);

828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854
/**
 *	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);

L
Linus Torvalds 已提交
855
/**
856
 *	__mmc_claim_host - exclusively claim a host
L
Linus Torvalds 已提交
857
 *	@host: mmc host to claim
858
 *	@abort: whether or not the operation should be aborted
L
Linus Torvalds 已提交
859
 *
860 861 862 863
 *	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 已提交
864
 */
865
int __mmc_claim_host(struct mmc_host *host, atomic_t *abort)
L
Linus Torvalds 已提交
866 867 868
{
	DECLARE_WAITQUEUE(wait, current);
	unsigned long flags;
869
	int stop;
L
Linus Torvalds 已提交
870

871 872
	might_sleep();

L
Linus Torvalds 已提交
873 874 875 876
	add_wait_queue(&host->wq, &wait);
	spin_lock_irqsave(&host->lock, flags);
	while (1) {
		set_current_state(TASK_UNINTERRUPTIBLE);
877
		stop = abort ? atomic_read(abort) : 0;
878
		if (stop || !host->claimed || host->claimer == current)
L
Linus Torvalds 已提交
879 880 881 882 883 884
			break;
		spin_unlock_irqrestore(&host->lock, flags);
		schedule();
		spin_lock_irqsave(&host->lock, flags);
	}
	set_current_state(TASK_RUNNING);
885
	if (!stop) {
886
		host->claimed = 1;
887 888 889
		host->claimer = current;
		host->claim_cnt += 1;
	} else
890
		wake_up(&host->wq);
L
Linus Torvalds 已提交
891 892
	spin_unlock_irqrestore(&host->lock, flags);
	remove_wait_queue(&host->wq, &wait);
893 894
	if (host->ops->enable && !stop && host->claim_cnt == 1)
		host->ops->enable(host);
895
	return stop;
L
Linus Torvalds 已提交
896 897
}

898
EXPORT_SYMBOL(__mmc_claim_host);
L
Linus Torvalds 已提交
899

900 901 902 903 904 905 906
/**
 *	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)
907 908 909 910 911
{
	int claimed_host = 0;
	unsigned long flags;

	spin_lock_irqsave(&host->lock, flags);
912
	if (!host->claimed || host->claimer == current) {
913
		host->claimed = 1;
914 915
		host->claimer = current;
		host->claim_cnt += 1;
916 917 918
		claimed_host = 1;
	}
	spin_unlock_irqrestore(&host->lock, flags);
919 920
	if (host->ops->enable && claimed_host && host->claim_cnt == 1)
		host->ops->enable(host);
921 922
	return claimed_host;
}
923
EXPORT_SYMBOL(mmc_try_claim_host);
924

925
/**
926
 *	mmc_release_host - release a host
927 928
 *	@host: mmc host to release
 *
929 930
 *	Release a MMC host, allowing others to claim the host
 *	for their operations.
931
 */
932
void mmc_release_host(struct mmc_host *host)
933 934 935
{
	unsigned long flags;

936 937 938 939 940
	WARN_ON(!host->claimed);

	if (host->ops->disable && host->claim_cnt == 1)
		host->ops->disable(host);

941
	spin_lock_irqsave(&host->lock, flags);
942 943 944 945 946 947 948 949 950
	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);
	}
951
}
L
Linus Torvalds 已提交
952 953
EXPORT_SYMBOL(mmc_release_host);

P
Pierre Ossman 已提交
954 955 956 957
/*
 * Internal function that does the actual ios call to the host driver,
 * optionally printing some debug output.
 */
958 959 960 961
static inline void mmc_set_ios(struct mmc_host *host)
{
	struct mmc_ios *ios = &host->ios;

962 963
	pr_debug("%s: clock %uHz busmode %u powermode %u cs %u Vdd %u "
		"width %u timing %u\n",
964 965
		 mmc_hostname(host), ios->clock, ios->bus_mode,
		 ios->power_mode, ios->chip_select, ios->vdd,
966
		 ios->bus_width, ios->timing);
967

968 969
	if (ios->clock > 0)
		mmc_set_ungated(host);
970 971 972
	host->ops->set_ios(host, ios);
}

P
Pierre Ossman 已提交
973 974 975
/*
 * Control chip select pin on a host.
 */
P
Pierre Ossman 已提交
976
void mmc_set_chip_select(struct mmc_host *host, int mode)
L
Linus Torvalds 已提交
977
{
978
	mmc_host_clk_hold(host);
P
Pierre Ossman 已提交
979 980
	host->ios.chip_select = mode;
	mmc_set_ios(host);
981
	mmc_host_clk_release(host);
L
Linus Torvalds 已提交
982 983
}

P
Pierre Ossman 已提交
984 985 986 987
/*
 * Sets the host clock to the highest possible frequency that
 * is below "hz".
 */
988
static void __mmc_set_clock(struct mmc_host *host, unsigned int hz)
P
Pierre Ossman 已提交
989 990 991 992 993 994 995 996 997 998
{
	WARN_ON(hz < host->f_min);

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

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

999 1000 1001 1002 1003 1004 1005
void mmc_set_clock(struct mmc_host *host, unsigned int hz)
{
	mmc_host_clk_hold(host);
	__mmc_set_clock(host, hz);
	mmc_host_clk_release(host);
}

1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037
#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 */
1038
		__mmc_set_clock(host, host->clk_old);
1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060
	}
}

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 已提交
1061 1062 1063 1064 1065
/*
 * Change the bus mode (open drain/push-pull) of a host.
 */
void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode)
{
1066
	mmc_host_clk_hold(host);
P
Pierre Ossman 已提交
1067 1068
	host->ios.bus_mode = mode;
	mmc_set_ios(host);
1069
	mmc_host_clk_release(host);
P
Pierre Ossman 已提交
1070 1071
}

1072 1073 1074 1075 1076
/*
 * Change data bus width of a host.
 */
void mmc_set_bus_width(struct mmc_host *host, unsigned int width)
{
1077
	mmc_host_clk_hold(host);
1078 1079
	host->ios.bus_width = width;
	mmc_set_ios(host);
1080
	mmc_host_clk_release(host);
1081 1082
}

1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156
/**
 * 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 已提交
1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191
#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;
}
1192
EXPORT_SYMBOL_GPL(mmc_regulator_get_ocrmask);
D
David Brownell 已提交
1193 1194 1195

/**
 * mmc_regulator_set_ocr - set regulator to match host->ios voltage
1196
 * @mmc: the host to regulate
D
David Brownell 已提交
1197
 * @supply: regulator to use
1198
 * @vdd_bit: zero for power off, else a bit number (host->ios.vdd)
D
David Brownell 已提交
1199 1200 1201 1202 1203 1204 1205
 *
 * 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.
 */
1206 1207 1208
int mmc_regulator_set_ocr(struct mmc_host *mmc,
			struct regulator *supply,
			unsigned short vdd_bit)
D
David Brownell 已提交
1209 1210 1211 1212 1213 1214 1215 1216
{
	int			result = 0;
	int			min_uV, max_uV;

	if (vdd_bit) {
		int		tmp;
		int		voltage;

1217 1218
		/*
		 * REVISIT mmc_vddrange_to_ocrmask() may have set some
D
David Brownell 已提交
1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231
		 * 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;
		}

1232 1233 1234
		/*
		 * If we're using a fixed/static regulator, don't call
		 * regulator_set_voltage; it would fail.
D
David Brownell 已提交
1235 1236
		 */
		voltage = regulator_get_voltage(supply);
1237

1238
		if (!regulator_can_change_voltage(supply))
1239 1240
			min_uV = max_uV = voltage;

D
David Brownell 已提交
1241 1242 1243 1244 1245 1246 1247
		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;

1248
		if (result == 0 && !mmc->regulator_enabled) {
D
David Brownell 已提交
1249
			result = regulator_enable(supply);
1250 1251 1252 1253
			if (!result)
				mmc->regulator_enabled = true;
		}
	} else if (mmc->regulator_enabled) {
D
David Brownell 已提交
1254
		result = regulator_disable(supply);
1255 1256
		if (result == 0)
			mmc->regulator_enabled = false;
D
David Brownell 已提交
1257 1258
	}

1259 1260 1261
	if (result)
		dev_err(mmc_dev(mmc),
			"could not set regulator OCR (%d)\n", result);
D
David Brownell 已提交
1262 1263
	return result;
}
1264
EXPORT_SYMBOL_GPL(mmc_regulator_set_ocr);
D
David Brownell 已提交
1265

1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288
int mmc_regulator_get_supply(struct mmc_host *mmc)
{
	struct device *dev = mmc_dev(mmc);
	struct regulator *supply;
	int ret;

	supply = devm_regulator_get(dev, "vmmc");
	mmc->supply.vmmc = supply;
	mmc->supply.vqmmc = devm_regulator_get(dev, "vqmmc");

	if (IS_ERR(supply))
		return PTR_ERR(supply);

	ret = mmc_regulator_get_ocrmask(supply);
	if (ret > 0)
		mmc->ocr_avail = ret;
	else
		dev_warn(mmc_dev(mmc), "Failed getting OCR mask: %d\n", ret);

	return 0;
}
EXPORT_SYMBOL_GPL(mmc_regulator_get_supply);

1289
#endif /* CONFIG_REGULATOR */
D
David Brownell 已提交
1290

L
Linus Torvalds 已提交
1291 1292 1293 1294
/*
 * Mask off any voltages we don't support and select
 * the lowest voltage
 */
P
Pierre Ossman 已提交
1295
u32 mmc_select_voltage(struct mmc_host *host, u32 ocr)
L
Linus Torvalds 已提交
1296 1297 1298 1299 1300 1301 1302 1303 1304
{
	int bit;

	ocr &= host->ocr_avail;

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

1305
		ocr &= 3 << bit;
L
Linus Torvalds 已提交
1306

1307
		mmc_host_clk_hold(host);
L
Linus Torvalds 已提交
1308
		host->ios.vdd = bit;
1309
		mmc_set_ios(host);
1310
		mmc_host_clk_release(host);
L
Linus Torvalds 已提交
1311
	} else {
1312 1313
		pr_warning("%s: host doesn't support card's voltages\n",
				mmc_hostname(host));
L
Linus Torvalds 已提交
1314 1315 1316 1317 1318 1319
		ocr = 0;
	}

	return ocr;
}

1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339
int __mmc_set_signal_voltage(struct mmc_host *host, int signal_voltage)
{
	int err = 0;
	int old_signal_voltage = host->ios.signal_voltage;

	host->ios.signal_voltage = signal_voltage;
	if (host->ops->start_signal_voltage_switch) {
		mmc_host_clk_hold(host);
		err = host->ops->start_signal_voltage_switch(host, &host->ios);
		mmc_host_clk_release(host);
	}

	if (err)
		host->ios.signal_voltage = old_signal_voltage;

	return err;

}

int mmc_set_signal_voltage(struct mmc_host *host, int signal_voltage)
1340 1341 1342
{
	struct mmc_command cmd = {0};
	int err = 0;
1343
	u32 clock;
1344 1345 1346 1347 1348 1349 1350

	BUG_ON(!host);

	/*
	 * Send CMD11 only if the request is to switch the card to
	 * 1.8V signalling.
	 */
1351 1352
	if (signal_voltage == MMC_SIGNAL_VOLTAGE_330)
		return __mmc_set_signal_voltage(host, signal_voltage);
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 1386 1387 1388 1389 1390 1391
	/*
	 * If we cannot switch voltages, return failure so the caller
	 * can continue without UHS mode
	 */
	if (!host->ops->start_signal_voltage_switch)
		return -EPERM;
	if (!host->ops->card_busy)
		pr_warning("%s: cannot verify signal voltage switch\n",
				mmc_hostname(host));

	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;

	mmc_host_clk_hold(host);
	/*
	 * The card should drive cmd and dat[0:3] low immediately
	 * after the response of cmd11, but wait 1 ms to be sure
	 */
	mmc_delay(1);
	if (host->ops->card_busy && !host->ops->card_busy(host)) {
		err = -EAGAIN;
		goto power_cycle;
	}
	/*
	 * During a signal voltage level switch, the clock must be gated
	 * for 5 ms according to the SD spec
	 */
	clock = host->ios.clock;
	host->ios.clock = 0;
	mmc_set_ios(host);
1392

1393 1394 1395 1396 1397 1398 1399
	if (__mmc_set_signal_voltage(host, signal_voltage)) {
		/*
		 * Voltages may not have been switched, but we've already
		 * sent CMD11, so a power cycle is required anyway
		 */
		err = -EAGAIN;
		goto power_cycle;
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
	/* Keep clock gated for at least 5 ms */
	mmc_delay(5);
	host->ios.clock = clock;
	mmc_set_ios(host);

	/* Wait for at least 1 ms according to spec */
	mmc_delay(1);

	/*
	 * Failure to switch is indicated by the card holding
	 * dat[0:3] low
	 */
	if (host->ops->card_busy && host->ops->card_busy(host))
		err = -EAGAIN;

power_cycle:
	if (err) {
		pr_debug("%s: Signal voltage switch failed, "
			"power cycling card\n", mmc_hostname(host));
		mmc_power_cycle(host);
	}

	mmc_host_clk_release(host);

	return err;
1427 1428
}

P
Pierre Ossman 已提交
1429
/*
P
Pierre Ossman 已提交
1430
 * Select timing parameters for host.
P
Pierre Ossman 已提交
1431
 */
P
Pierre Ossman 已提交
1432
void mmc_set_timing(struct mmc_host *host, unsigned int timing)
P
Pierre Ossman 已提交
1433
{
1434
	mmc_host_clk_hold(host);
P
Pierre Ossman 已提交
1435 1436
	host->ios.timing = timing;
	mmc_set_ios(host);
1437
	mmc_host_clk_release(host);
P
Pierre Ossman 已提交
1438 1439
}

1440 1441 1442 1443 1444
/*
 * Select appropriate driver type for host.
 */
void mmc_set_driver_type(struct mmc_host *host, unsigned int drv_type)
{
1445
	mmc_host_clk_hold(host);
1446 1447
	host->ios.drv_type = drv_type;
	mmc_set_ios(host);
1448
	mmc_host_clk_release(host);
1449 1450
}

L
Linus Torvalds 已提交
1451
/*
1452 1453 1454 1455 1456 1457 1458 1459 1460
 * 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 已提交
1461 1462 1463
 */
static void mmc_power_up(struct mmc_host *host)
{
1464 1465
	int bit;

1466 1467 1468
	if (host->ios.power_mode == MMC_POWER_ON)
		return;

1469 1470
	mmc_host_clk_hold(host);

1471 1472 1473 1474 1475
	/* 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 已提交
1476 1477

	host->ios.vdd = bit;
1478
	if (mmc_host_is_spi(host))
D
David Brownell 已提交
1479
		host->ios.chip_select = MMC_CS_HIGH;
1480
	else
D
David Brownell 已提交
1481
		host->ios.chip_select = MMC_CS_DONTCARE;
1482
	host->ios.bus_mode = MMC_BUSMODE_PUSHPULL;
L
Linus Torvalds 已提交
1483
	host->ios.power_mode = MMC_POWER_UP;
P
Pierre Ossman 已提交
1484
	host->ios.bus_width = MMC_BUS_WIDTH_1;
1485
	host->ios.timing = MMC_TIMING_LEGACY;
1486
	mmc_set_ios(host);
L
Linus Torvalds 已提交
1487

1488
	/* Set signal voltage to 3.3V */
1489
	__mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330);
1490

P
Pierre Ossman 已提交
1491 1492 1493 1494
	/*
	 * This delay should be sufficient to allow the power supply
	 * to reach the minimum voltage.
	 */
1495
	mmc_delay(10);
L
Linus Torvalds 已提交
1496

H
Hein Tibosch 已提交
1497
	host->ios.clock = host->f_init;
1498

L
Linus Torvalds 已提交
1499
	host->ios.power_mode = MMC_POWER_ON;
1500
	mmc_set_ios(host);
L
Linus Torvalds 已提交
1501

P
Pierre Ossman 已提交
1502 1503 1504 1505
	/*
	 * This delay must be at least 74 clock sizes, or 1 ms, or the
	 * time required to reach a stable voltage.
	 */
1506
	mmc_delay(10);
1507 1508

	mmc_host_clk_release(host);
L
Linus Torvalds 已提交
1509 1510
}

1511
void mmc_power_off(struct mmc_host *host)
L
Linus Torvalds 已提交
1512
{
1513 1514 1515
	if (host->ios.power_mode == MMC_POWER_OFF)
		return;

1516 1517
	mmc_host_clk_hold(host);

L
Linus Torvalds 已提交
1518 1519
	host->ios.clock = 0;
	host->ios.vdd = 0;
1520

1521

1522 1523 1524 1525 1526 1527
	/*
	 * 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 已提交
1528 1529 1530 1531
	if (!mmc_host_is_spi(host)) {
		host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
		host->ios.chip_select = MMC_CS_DONTCARE;
	}
L
Linus Torvalds 已提交
1532
	host->ios.power_mode = MMC_POWER_OFF;
P
Pierre Ossman 已提交
1533
	host->ios.bus_width = MMC_BUS_WIDTH_1;
1534
	host->ios.timing = MMC_TIMING_LEGACY;
1535
	mmc_set_ios(host);
1536

1537 1538 1539 1540 1541 1542 1543
	/*
	 * Some configurations, such as the 802.11 SDIO card in the OLPC
	 * XO-1.5, require a short delay after poweroff before the card
	 * can be successfully turned on again.
	 */
	mmc_delay(1);

1544
	mmc_host_clk_release(host);
L
Linus Torvalds 已提交
1545 1546
}

J
Johan Rudholm 已提交
1547 1548 1549 1550 1551 1552 1553 1554
void mmc_power_cycle(struct mmc_host *host)
{
	mmc_power_off(host);
	/* Wait at least 1 ms according to SD spec */
	mmc_delay(1);
	mmc_power_up(host);
}

1555 1556 1557
/*
 * Cleanup when the last reference to the bus operator is dropped.
 */
1558
static void __mmc_release_bus(struct mmc_host *host)
1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593
{
	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 已提交
1594
/*
P
Pierre Ossman 已提交
1595 1596
 * Assign a mmc bus handler to a host. Only one bus handler may control a
 * host at any given time.
L
Linus Torvalds 已提交
1597
 */
P
Pierre Ossman 已提交
1598
void mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops)
L
Linus Torvalds 已提交
1599
{
P
Pierre Ossman 已提交
1600
	unsigned long flags;
1601

P
Pierre Ossman 已提交
1602 1603
	BUG_ON(!host);
	BUG_ON(!ops);
P
Pierre Ossman 已提交
1604

P
Pierre Ossman 已提交
1605
	WARN_ON(!host->claimed);
1606

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

P
Pierre Ossman 已提交
1609 1610
	BUG_ON(host->bus_ops);
	BUG_ON(host->bus_refs);
P
Pierre Ossman 已提交
1611

P
Pierre Ossman 已提交
1612 1613 1614
	host->bus_ops = ops;
	host->bus_refs = 1;
	host->bus_dead = 0;
P
Pierre Ossman 已提交
1615

P
Pierre Ossman 已提交
1616
	spin_unlock_irqrestore(&host->lock, flags);
P
Pierre Ossman 已提交
1617 1618
}

P
Pierre Ossman 已提交
1619
/*
1620
 * Remove the current bus handler from a host.
P
Pierre Ossman 已提交
1621 1622
 */
void mmc_detach_bus(struct mmc_host *host)
1623
{
P
Pierre Ossman 已提交
1624
	unsigned long flags;
1625

P
Pierre Ossman 已提交
1626
	BUG_ON(!host);
1627

P
Pierre Ossman 已提交
1628 1629
	WARN_ON(!host->claimed);
	WARN_ON(!host->bus_ops);
1630

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

P
Pierre Ossman 已提交
1633
	host->bus_dead = 1;
1634

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

P
Pierre Ossman 已提交
1637
	mmc_bus_put(host);
L
Linus Torvalds 已提交
1638 1639 1640 1641 1642
}

/**
 *	mmc_detect_change - process change of state on a MMC socket
 *	@host: host which changed state.
1643
 *	@delay: optional delay to wait before detection (jiffies)
L
Linus Torvalds 已提交
1644
 *
P
Pierre Ossman 已提交
1645 1646 1647 1648
 *	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 已提交
1649
 */
1650
void mmc_detect_change(struct mmc_host *host, unsigned long delay)
L
Linus Torvalds 已提交
1651
{
1652
#ifdef CONFIG_MMC_DEBUG
1653
	unsigned long flags;
A
Andrew Morton 已提交
1654
	spin_lock_irqsave(&host->lock, flags);
P
Pierre Ossman 已提交
1655
	WARN_ON(host->removed);
A
Andrew Morton 已提交
1656
	spin_unlock_irqrestore(&host->lock, flags);
1657
#endif
1658
	host->detect_change = 1;
D
David Howells 已提交
1659
	mmc_schedule_delayed_work(&host->detect, delay);
L
Linus Torvalds 已提交
1660 1661 1662 1663
}

EXPORT_SYMBOL(mmc_detect_change);

1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712
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;
		}
	}
}

1713 1714
static unsigned int mmc_mmc_erase_timeout(struct mmc_card *card,
				          unsigned int arg, unsigned int qty)
1715 1716 1717
{
	unsigned int erase_timeout;

1718 1719 1720 1721
	if (arg == MMC_DISCARD_ARG ||
	    (arg == MMC_TRIM_ARG && card->ext_csd.rev >= 6)) {
		erase_timeout = card->ext_csd.trim_timeout;
	} else if (card->ext_csd.erase_group_def & 1) {
1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744
		/* 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) /
1745
			      (mmc_host_clk_rate(card->host) / 1000);
1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773

		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;

1774
	return erase_timeout;
1775 1776
}

1777 1778 1779
static unsigned int mmc_sd_erase_timeout(struct mmc_card *card,
					 unsigned int arg,
					 unsigned int qty)
1780
{
1781 1782
	unsigned int erase_timeout;

1783 1784
	if (card->ssr.erase_timeout) {
		/* Erase timeout specified in SD Status Register (SSR) */
1785 1786
		erase_timeout = card->ssr.erase_timeout * qty +
				card->ssr.erase_offset;
1787 1788 1789 1790 1791
	} else {
		/*
		 * Erase timeout not specified in SD Status Register (SSR) so
		 * use 250ms per write block.
		 */
1792
		erase_timeout = 250 * qty;
1793 1794 1795
	}

	/* Must not be less than 1 second */
1796 1797 1798 1799
	if (erase_timeout < 1000)
		erase_timeout = 1000;

	return erase_timeout;
1800 1801
}

1802 1803 1804
static unsigned int mmc_erase_timeout(struct mmc_card *card,
				      unsigned int arg,
				      unsigned int qty)
1805 1806
{
	if (mmc_card_sd(card))
1807
		return mmc_sd_erase_timeout(card, arg, qty);
1808
	else
1809
		return mmc_mmc_erase_timeout(card, arg, qty);
1810 1811 1812 1813 1814
}

static int mmc_do_erase(struct mmc_card *card, unsigned int from,
			unsigned int to, unsigned int arg)
{
1815
	struct mmc_command cmd = {0};
1816
	unsigned int qty = 0;
1817
	unsigned long timeout;
1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 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
	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) {
1858
		pr_err("mmc_erase: group start error %d, "
1859
		       "status %#x\n", err, cmd.resp[0]);
1860
		err = -EIO;
1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872
		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) {
1873
		pr_err("mmc_erase: group end error %d, status %#x\n",
1874
		       err, cmd.resp[0]);
1875
		err = -EIO;
1876 1877 1878 1879 1880 1881 1882
		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;
1883
	cmd.cmd_timeout_ms = mmc_erase_timeout(card, arg, qty);
1884 1885
	err = mmc_wait_for_cmd(card->host, &cmd, 0);
	if (err) {
1886
		pr_err("mmc_erase: erase error %d, status %#x\n",
1887 1888 1889 1890 1891 1892 1893 1894
		       err, cmd.resp[0]);
		err = -EIO;
		goto out;
	}

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

1895
	timeout = jiffies + msecs_to_jiffies(MMC_CORE_TIMEOUT_MS);
1896 1897 1898 1899 1900 1901 1902 1903
	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)) {
1904
			pr_err("error %d requesting status %#x\n",
1905 1906 1907 1908
				err, cmd.resp[0]);
			err = -EIO;
			goto out;
		}
1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919

		/* Timeout if the device never becomes ready for data and
		 * never leaves the program state.
		 */
		if (time_after(jiffies, timeout)) {
			pr_err("%s: Card stuck in programming state! %s\n",
				mmc_hostname(card->host), __func__);
			err =  -EIO;
			goto out;
		}

1920
	} while (!(cmd.resp[0] & R1_READY_FOR_DATA) ||
1921
		 (R1_CURRENT_STATE(cmd.resp[0]) == R1_STATE_PRG));
1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009
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);

2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021
int mmc_can_discard(struct mmc_card *card)
{
	/*
	 * As there's no way to detect the discard support bit at v4.5
	 * use the s/w feature support filed.
	 */
	if (card->ext_csd.feature_support & MMC_DISCARD_FEATURE)
		return 1;
	return 0;
}
EXPORT_SYMBOL(mmc_can_discard);

2022 2023
int mmc_can_sanitize(struct mmc_card *card)
{
2024 2025
	if (!mmc_can_trim(card) && !mmc_can_erase(card))
		return 0;
2026 2027 2028 2029 2030 2031
	if (card->ext_csd.sec_feature_support & EXT_CSD_SEC_SANITIZE)
		return 1;
	return 0;
}
EXPORT_SYMBOL(mmc_can_sanitize);

2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049
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 已提交
2050

2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126
static unsigned int mmc_do_calc_max_discard(struct mmc_card *card,
					    unsigned int arg)
{
	struct mmc_host *host = card->host;
	unsigned int max_discard, x, y, qty = 0, max_qty, timeout;
	unsigned int last_timeout = 0;

	if (card->erase_shift)
		max_qty = UINT_MAX >> card->erase_shift;
	else if (mmc_card_sd(card))
		max_qty = UINT_MAX;
	else
		max_qty = UINT_MAX / card->erase_size;

	/* Find the largest qty with an OK timeout */
	do {
		y = 0;
		for (x = 1; x && x <= max_qty && max_qty - x >= qty; x <<= 1) {
			timeout = mmc_erase_timeout(card, arg, qty + x);
			if (timeout > host->max_discard_to)
				break;
			if (timeout < last_timeout)
				break;
			last_timeout = timeout;
			y = x;
		}
		qty += y;
	} while (y);

	if (!qty)
		return 0;

	if (qty == 1)
		return 1;

	/* Convert qty to sectors */
	if (card->erase_shift)
		max_discard = --qty << card->erase_shift;
	else if (mmc_card_sd(card))
		max_discard = qty;
	else
		max_discard = --qty * card->erase_size;

	return max_discard;
}

unsigned int mmc_calc_max_discard(struct mmc_card *card)
{
	struct mmc_host *host = card->host;
	unsigned int max_discard, max_trim;

	if (!host->max_discard_to)
		return UINT_MAX;

	/*
	 * Without erase_group_def set, MMC erase timeout depends on clock
	 * frequence which can change.  In that case, the best choice is
	 * just the preferred erase size.
	 */
	if (mmc_card_mmc(card) && !(card->ext_csd.erase_group_def & 1))
		return card->pref_erase;

	max_discard = mmc_do_calc_max_discard(card, MMC_ERASE_ARG);
	if (mmc_can_trim(card)) {
		max_trim = mmc_do_calc_max_discard(card, MMC_TRIM_ARG);
		if (max_trim < max_discard)
			max_discard = max_trim;
	} else if (max_discard < card->erase_size) {
		max_discard = 0;
	}
	pr_debug("%s: calculated max. discard sectors %u for timeout %u ms\n",
		 mmc_hostname(host), max_discard, host->max_discard_to);
	return max_discard;
}
EXPORT_SYMBOL(mmc_calc_max_discard);

2127 2128
int mmc_set_blocklen(struct mmc_card *card, unsigned int blocklen)
{
2129
	struct mmc_command cmd = {0};
2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140

	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);

2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154
int mmc_set_blockcount(struct mmc_card *card, unsigned int blockcount,
			bool is_rel_write)
{
	struct mmc_command cmd = {0};

	cmd.opcode = MMC_SET_BLOCK_COUNT;
	cmd.arg = blockcount & 0x0000FFFF;
	if (is_rel_write)
		cmd.arg |= 1 << 31;
	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_blockcount);

2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242
static void mmc_hw_reset_for_init(struct mmc_host *host)
{
	if (!(host->caps & MMC_CAP_HW_RESET) || !host->ops->hw_reset)
		return;
	mmc_host_clk_hold(host);
	host->ops->hw_reset(host);
	mmc_host_clk_release(host);
}

int mmc_can_reset(struct mmc_card *card)
{
	u8 rst_n_function;

	if (!mmc_card_mmc(card))
		return 0;
	rst_n_function = card->ext_csd.rst_n_function;
	if ((rst_n_function & EXT_CSD_RST_N_EN_MASK) != EXT_CSD_RST_N_ENABLED)
		return 0;
	return 1;
}
EXPORT_SYMBOL(mmc_can_reset);

static int mmc_do_hw_reset(struct mmc_host *host, int check)
{
	struct mmc_card *card = host->card;

	if (!host->bus_ops->power_restore)
		return -EOPNOTSUPP;

	if (!(host->caps & MMC_CAP_HW_RESET) || !host->ops->hw_reset)
		return -EOPNOTSUPP;

	if (!card)
		return -EINVAL;

	if (!mmc_can_reset(card))
		return -EOPNOTSUPP;

	mmc_host_clk_hold(host);
	mmc_set_clock(host, host->f_init);

	host->ops->hw_reset(host);

	/* If the reset has happened, then a status command will fail */
	if (check) {
		struct mmc_command cmd = {0};
		int err;

		cmd.opcode = MMC_SEND_STATUS;
		if (!mmc_host_is_spi(card->host))
			cmd.arg = card->rca << 16;
		cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_AC;
		err = mmc_wait_for_cmd(card->host, &cmd, 0);
		if (!err) {
			mmc_host_clk_release(host);
			return -ENOSYS;
		}
	}

	host->card->state &= ~(MMC_STATE_HIGHSPEED | MMC_STATE_HIGHSPEED_DDR);
	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;
	}
	host->ios.bus_width = MMC_BUS_WIDTH_1;
	host->ios.timing = MMC_TIMING_LEGACY;
	mmc_set_ios(host);

	mmc_host_clk_release(host);

	return host->bus_ops->power_restore(host);
}

int mmc_hw_reset(struct mmc_host *host)
{
	return mmc_do_hw_reset(host, 0);
}
EXPORT_SYMBOL(mmc_hw_reset);

int mmc_hw_reset_check(struct mmc_host *host)
{
	return mmc_do_hw_reset(host, 1);
}
EXPORT_SYMBOL(mmc_hw_reset_check);

2243 2244 2245 2246 2247 2248 2249 2250 2251
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);
2252

2253 2254 2255 2256 2257 2258
	/*
	 * Some eMMCs (with VCCQ always on) may not be reset after power up, so
	 * do a hardware reset if possible.
	 */
	mmc_hw_reset_for_init(host);

2259 2260 2261 2262 2263
	/*
	 * 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.
	 */
2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280
	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;
}

2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302
int _mmc_detect_card_removed(struct mmc_host *host)
{
	int ret;

	if ((host->caps & MMC_CAP_NONREMOVABLE) || !host->bus_ops->alive)
		return 0;

	if (!host->card || mmc_card_removed(host->card))
		return 1;

	ret = host->bus_ops->alive(host);
	if (ret) {
		mmc_card_set_removed(host->card);
		pr_debug("%s: card remove detected\n", mmc_hostname(host));
	}

	return ret;
}

int mmc_detect_card_removed(struct mmc_host *host)
{
	struct mmc_card *card = host->card;
2303
	int ret;
2304 2305

	WARN_ON(!host->claimed);
2306 2307 2308 2309 2310

	if (!card)
		return 1;

	ret = mmc_card_removed(card);
2311 2312 2313 2314
	/*
	 * The card will be considered unchanged unless we have been asked to
	 * detect a change or host requires polling to provide card detection.
	 */
2315 2316 2317
	if (!host->detect_change && !(host->caps & MMC_CAP_NEEDS_POLL) &&
	    !(host->caps2 & MMC_CAP2_DETECT_ON_ERR))
		return ret;
2318 2319

	host->detect_change = 0;
2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330
	if (!ret) {
		ret = _mmc_detect_card_removed(host);
		if (ret && (host->caps2 & MMC_CAP2_DETECT_ON_ERR)) {
			/*
			 * Schedule a detect work as soon as possible to let a
			 * rescan handle the card removal.
			 */
			cancel_delayed_work(&host->detect);
			mmc_detect_change(host, 0);
		}
	}
2331

2332
	return ret;
2333 2334 2335
}
EXPORT_SYMBOL(mmc_detect_card_removed);

2336
void mmc_rescan(struct work_struct *work)
L
Linus Torvalds 已提交
2337
{
D
David Howells 已提交
2338 2339
	struct mmc_host *host =
		container_of(work, struct mmc_host, detect.work);
H
Hein Tibosch 已提交
2340
	int i;
2341

2342
	if (host->rescan_disable)
2343
		return;
L
Linus Torvalds 已提交
2344

2345 2346 2347 2348 2349
	/* If there is a non-removable card registered, only scan once */
	if ((host->caps & MMC_CAP_NONREMOVABLE) && host->rescan_entered)
		return;
	host->rescan_entered = 1;

P
Pierre Ossman 已提交
2350
	mmc_bus_get(host);
P
Pierre Ossman 已提交
2351

2352 2353 2354 2355 2356
	/*
	 * if there is a _removable_ card registered, check whether it is
	 * still present
	 */
	if (host->bus_ops && host->bus_ops->detect && !host->bus_dead
2357
	    && !(host->caps & MMC_CAP_NONREMOVABLE))
2358 2359
		host->bus_ops->detect(host);

2360 2361
	host->detect_change = 0;

2362 2363 2364 2365
	/*
	 * Let mmc_bus_put() free the bus/bus_ops if we've found that
	 * the card is no longer present.
	 */
2366 2367 2368 2369 2370
	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 已提交
2371
		mmc_bus_put(host);
2372 2373
		goto out;
	}
L
Linus Torvalds 已提交
2374

2375 2376 2377 2378 2379
	/*
	 * Only we can add a new handler, so it's safe to
	 * release the lock here.
	 */
	mmc_bus_put(host);
L
Linus Torvalds 已提交
2380

2381 2382 2383 2384
	if (host->ops->get_cd && host->ops->get_cd(host) == 0) {
		mmc_claim_host(host);
		mmc_power_off(host);
		mmc_release_host(host);
2385
		goto out;
2386
	}
L
Linus Torvalds 已提交
2387

2388
	mmc_claim_host(host);
H
Hein Tibosch 已提交
2389
	for (i = 0; i < ARRAY_SIZE(freqs); i++) {
2390 2391
		if (!mmc_rescan_try_freq(host, max(freqs[i], host->f_min)))
			break;
2392
		if (freqs[i] <= host->f_min)
2393
			break;
H
Hein Tibosch 已提交
2394
	}
2395 2396 2397
	mmc_release_host(host);

 out:
2398 2399
	if (host->caps & MMC_CAP_NEEDS_POLL)
		mmc_schedule_delayed_work(&host->detect, HZ);
L
Linus Torvalds 已提交
2400 2401
}

2402
void mmc_start_host(struct mmc_host *host)
L
Linus Torvalds 已提交
2403
{
2404
	host->f_init = max(freqs[0], host->f_min);
2405
	host->rescan_disable = 0;
2406
	mmc_power_up(host);
2407
	mmc_detect_change(host, 0);
L
Linus Torvalds 已提交
2408 2409
}

2410
void mmc_stop_host(struct mmc_host *host)
L
Linus Torvalds 已提交
2411
{
2412
#ifdef CONFIG_MMC_DEBUG
2413 2414
	unsigned long flags;
	spin_lock_irqsave(&host->lock, flags);
2415
	host->removed = 1;
2416
	spin_unlock_irqrestore(&host->lock, flags);
2417 2418
#endif

2419
	host->rescan_disable = 1;
2420
	cancel_delayed_work_sync(&host->detect);
2421 2422
	mmc_flush_scheduled_work();

2423 2424 2425
	/* clear pm flags now and let card drivers set them as needed */
	host->pm_flags = 0;

P
Pierre Ossman 已提交
2426 2427
	mmc_bus_get(host);
	if (host->bus_ops && !host->bus_dead) {
2428
		/* Calling bus_ops->remove() with a claimed host can deadlock */
P
Pierre Ossman 已提交
2429 2430 2431 2432 2433
		if (host->bus_ops->remove)
			host->bus_ops->remove(host);

		mmc_claim_host(host);
		mmc_detach_bus(host);
2434
		mmc_power_off(host);
P
Pierre Ossman 已提交
2435
		mmc_release_host(host);
D
Denis Karpov 已提交
2436 2437
		mmc_bus_put(host);
		return;
L
Linus Torvalds 已提交
2438
	}
P
Pierre Ossman 已提交
2439 2440 2441
	mmc_bus_put(host);

	BUG_ON(host->card);
L
Linus Torvalds 已提交
2442 2443 2444 2445

	mmc_power_off(host);
}

2446
int mmc_power_save_host(struct mmc_host *host)
2447
{
2448 2449
	int ret = 0;

2450 2451 2452 2453
#ifdef CONFIG_MMC_DEBUG
	pr_info("%s: %s: powering down\n", mmc_hostname(host), __func__);
#endif

2454 2455 2456 2457
	mmc_bus_get(host);

	if (!host->bus_ops || host->bus_dead || !host->bus_ops->power_restore) {
		mmc_bus_put(host);
2458
		return -EINVAL;
2459 2460 2461
	}

	if (host->bus_ops->power_save)
2462
		ret = host->bus_ops->power_save(host);
2463 2464 2465 2466

	mmc_bus_put(host);

	mmc_power_off(host);
2467 2468

	return ret;
2469 2470 2471
}
EXPORT_SYMBOL(mmc_power_save_host);

2472
int mmc_power_restore_host(struct mmc_host *host)
2473
{
2474 2475
	int ret;

2476 2477 2478 2479
#ifdef CONFIG_MMC_DEBUG
	pr_info("%s: %s: powering up\n", mmc_hostname(host), __func__);
#endif

2480 2481 2482 2483
	mmc_bus_get(host);

	if (!host->bus_ops || host->bus_dead || !host->bus_ops->power_restore) {
		mmc_bus_put(host);
2484
		return -EINVAL;
2485 2486 2487
	}

	mmc_power_up(host);
2488
	ret = host->bus_ops->power_restore(host);
2489 2490

	mmc_bus_put(host);
2491 2492

	return ret;
2493 2494 2495
}
EXPORT_SYMBOL(mmc_power_restore_host);

2496 2497 2498 2499
int mmc_card_awake(struct mmc_host *host)
{
	int err = -ENOSYS;

2500 2501 2502
	if (host->caps2 & MMC_CAP2_NO_SLEEP_CMD)
		return 0;

2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517
	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;

2518 2519 2520
	if (host->caps2 & MMC_CAP2_NO_SLEEP_CMD)
		return 0;

2521 2522
	mmc_bus_get(host);

2523
	if (host->bus_ops && !host->bus_dead && host->bus_ops->sleep)
2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541
		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);

2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570
/*
 * Flush the cache to the non-volatile storage.
 */
int mmc_flush_cache(struct mmc_card *card)
{
	struct mmc_host *host = card->host;
	int err = 0;

	if (!(host->caps2 & MMC_CAP2_CACHE_CTRL))
		return err;

	if (mmc_card_mmc(card) &&
			(card->ext_csd.cache_size > 0) &&
			(card->ext_csd.cache_ctrl & 1)) {
		err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
				EXT_CSD_FLUSH_CACHE, 1, 0);
		if (err)
			pr_err("%s: cache flush error %d\n",
					mmc_hostname(card->host), err);
	}

	return err;
}
EXPORT_SYMBOL(mmc_flush_cache);

/*
 * Turn the cache ON/OFF.
 * Turning the cache OFF shall trigger flushing of the data
 * to the non-volatile storage.
2571
 * This function should be called with host claimed
2572 2573 2574 2575
 */
int mmc_cache_ctrl(struct mmc_host *host, u8 enable)
{
	struct mmc_card *card = host->card;
2576
	unsigned int timeout;
2577 2578 2579 2580 2581 2582 2583 2584 2585 2586
	int err = 0;

	if (!(host->caps2 & MMC_CAP2_CACHE_CTRL) ||
			mmc_card_is_removable(host))
		return err;

	if (card && mmc_card_mmc(card) &&
			(card->ext_csd.cache_size > 0)) {
		enable = !!enable;

2587 2588
		if (card->ext_csd.cache_ctrl ^ enable) {
			timeout = enable ? card->ext_csd.generic_cmd6_time : 0;
2589
			err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
2590 2591 2592 2593 2594 2595 2596 2597 2598
					EXT_CSD_CACHE_CTRL, enable, timeout);
			if (err)
				pr_err("%s: cache %s error %d\n",
						mmc_hostname(card->host),
						enable ? "on" : "off",
						err);
			else
				card->ext_csd.cache_ctrl = enable;
		}
2599 2600 2601 2602 2603 2604
	}

	return err;
}
EXPORT_SYMBOL(mmc_cache_ctrl);

L
Linus Torvalds 已提交
2605 2606 2607 2608 2609 2610
#ifdef CONFIG_PM

/**
 *	mmc_suspend_host - suspend a host
 *	@host: mmc host
 */
2611
int mmc_suspend_host(struct mmc_host *host)
L
Linus Torvalds 已提交
2612
{
2613 2614
	int err = 0;

2615
	cancel_delayed_work(&host->detect);
P
Pierre Ossman 已提交
2616
	mmc_flush_scheduled_work();
2617

P
Pierre Ossman 已提交
2618 2619
	mmc_bus_get(host);
	if (host->bus_ops && !host->bus_dead) {
2620 2621 2622 2623 2624 2625
		if (host->bus_ops->suspend) {
			if (mmc_card_doing_bkops(host->card)) {
				err = mmc_stop_bkops(host->card);
				if (err)
					goto out;
			}
2626
			err = host->bus_ops->suspend(host);
2627
		}
2628

2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643
		if (err == -ENOSYS || !host->bus_ops->resume) {
			/*
			 * We simply "remove" the card in this case.
			 * It will be redetected on resume.  (Calling
			 * bus_ops->remove() with a claimed host can
			 * deadlock.)
			 */
			if (host->bus_ops->remove)
				host->bus_ops->remove(host);
			mmc_claim_host(host);
			mmc_detach_bus(host);
			mmc_power_off(host);
			mmc_release_host(host);
			host->pm_flags = 0;
			err = 0;
2644
		}
P
Pierre Ossman 已提交
2645
	}
P
Pierre Ossman 已提交
2646 2647
	mmc_bus_put(host);

2648
	if (!err && !mmc_card_keep_power(host))
2649
		mmc_power_off(host);
L
Linus Torvalds 已提交
2650

2651
out:
2652
	return err;
L
Linus Torvalds 已提交
2653 2654 2655 2656 2657 2658 2659 2660 2661 2662
}

EXPORT_SYMBOL(mmc_suspend_host);

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

2665 2666
	mmc_bus_get(host);
	if (host->bus_ops && !host->bus_dead) {
2667
		if (!mmc_card_keep_power(host)) {
2668 2669
			mmc_power_up(host);
			mmc_select_voltage(host, host->ocr);
2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681
			/*
			 * 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);
			}
2682
		}
2683
		BUG_ON(!host->bus_ops->resume);
2684 2685
		err = host->bus_ops->resume(host);
		if (err) {
2686
			pr_warning("%s: error %d during resume "
2687 2688 2689 2690
					    "(card was removed?)\n",
					    mmc_hostname(host), err);
			err = 0;
		}
2691
	}
2692
	host->pm_flags &= ~MMC_PM_KEEP_POWER;
2693 2694
	mmc_bus_put(host);

2695
	return err;
L
Linus Torvalds 已提交
2696 2697 2698
}
EXPORT_SYMBOL(mmc_resume_host);

2699 2700 2701 2702 2703 2704 2705 2706 2707 2708
/* 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;
2709
	int err = 0;
2710 2711 2712 2713

	switch (mode) {
	case PM_HIBERNATION_PREPARE:
	case PM_SUSPEND_PREPARE:
2714 2715 2716 2717 2718 2719 2720 2721 2722 2723
		if (host->card && mmc_card_mmc(host->card) &&
		    mmc_card_doing_bkops(host->card)) {
			err = mmc_stop_bkops(host->card);
			if (err) {
				pr_err("%s: didn't stop bkops\n",
					mmc_hostname(host));
				return err;
			}
			mmc_card_clr_doing_bkops(host->card);
		}
2724 2725 2726 2727 2728 2729 2730 2731 2732

		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;

2733
		/* Calling bus_ops->remove() with a claimed host can deadlock */
2734 2735 2736
		if (host->bus_ops->remove)
			host->bus_ops->remove(host);

2737
		mmc_claim_host(host);
2738
		mmc_detach_bus(host);
2739
		mmc_power_off(host);
2740 2741 2742 2743 2744 2745
		mmc_release_host(host);
		host->pm_flags = 0;
		break;

	case PM_POST_SUSPEND:
	case PM_POST_HIBERNATION:
2746
	case PM_POST_RESTORE:
2747 2748 2749 2750 2751 2752 2753 2754 2755 2756

		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 已提交
2757 2758
#endif

2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775
/**
 * mmc_init_context_info() - init synchronization context
 * @host: mmc host
 *
 * Init struct context_info needed to implement asynchronous
 * request mechanism, used by mmc core, host driver and mmc requests
 * supplier.
 */
void mmc_init_context_info(struct mmc_host *host)
{
	spin_lock_init(&host->context_info.lock);
	host->context_info.is_new_req = false;
	host->context_info.is_done_rcv = false;
	host->context_info.is_waiting_last_req = false;
	init_waitqueue_head(&host->context_info.wait);
}

2776 2777 2778 2779
static int __init mmc_init(void)
{
	int ret;

T
Tejun Heo 已提交
2780
	workqueue = alloc_ordered_workqueue("kmmcd", 0);
2781 2782 2783 2784
	if (!workqueue)
		return -ENOMEM;

	ret = mmc_register_bus();
P
Pierre Ossman 已提交
2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804
	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);

2805 2806 2807 2808 2809
	return ret;
}

static void __exit mmc_exit(void)
{
P
Pierre Ossman 已提交
2810
	sdio_unregister_bus();
2811 2812 2813 2814 2815
	mmc_unregister_host_class();
	mmc_unregister_bus();
	destroy_workqueue(workqueue);
}

2816
subsys_initcall(mmc_init);
2817 2818
module_exit(mmc_exit);

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