core.c 69.2 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
/*
2
 *  linux/drivers/mmc/core/core.c
Linus Torvalds's avatar
Linus Torvalds committed
3 4
 *
 *  Copyright (C) 2003-2004 Russell King, All Rights Reserved.
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.
Linus Torvalds's avatar
Linus Torvalds committed
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>
Pierre Ossman's avatar
Pierre Ossman committed
21
#include <linux/leds.h>
Pierre Ossman's avatar
Pierre Ossman committed
22
#include <linux/scatterlist.h>
23
#include <linux/log2.h>
David Brownell's avatar
David Brownell committed
24
#include <linux/regulator/consumer.h>
25
#include <linux/pm_runtime.h>
26
#include <linux/pm_wakeup.h>
27
#include <linux/suspend.h>
28 29
#include <linux/fault-inject.h>
#include <linux/random.h>
30
#include <linux/slab.h>
31
#include <linux/of.h>
Linus Torvalds's avatar
Linus Torvalds committed
32 33 34

#include <linux/mmc/card.h>
#include <linux/mmc/host.h>
Pierre Ossman's avatar
Pierre Ossman committed
35 36
#include <linux/mmc/mmc.h>
#include <linux/mmc/sd.h>
37
#include <linux/mmc/slot-gpio.h>
Linus Torvalds's avatar
Linus Torvalds committed
38

39
#include "core.h"
40 41
#include "bus.h"
#include "host.h"
Pierre Ossman's avatar
Pierre Ossman committed
42
#include "sdio_bus.h"
43
#include "pwrseq.h"
Pierre Ossman's avatar
Pierre Ossman committed
44 45 46

#include "mmc_ops.h"
#include "sd_ops.h"
Pierre Ossman's avatar
Pierre Ossman committed
47
#include "sdio_ops.h"
Linus Torvalds's avatar
Linus Torvalds committed
48

49 50 51
/* If the device is not responding */
#define MMC_CORE_TIMEOUT_MS	(10 * 60 * 1000) /* 10 minute timeout */

52 53 54 55 56 57
/*
 * 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 */

58
static struct workqueue_struct *workqueue;
59
static const unsigned freqs[] = { 400000, 300000, 200000, 100000 };
60

David Brownell's avatar
David Brownell committed
61 62 63 64 65
/*
 * 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.
 */
66
bool use_spi_crc = 1;
David Brownell's avatar
David Brownell committed
67 68
module_param(use_spi_crc, bool, 0);

69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85
/*
 * 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);
}

86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109
#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;

110 111
	data->error = data_errors[prandom_u32() % ARRAY_SIZE(data_errors)];
	data->bytes_xfered = (prandom_u32() % (data->bytes_xfered >> 9)) << 9;
112 113 114 115 116 117 118 119 120 121 122
}

#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 */

Linus Torvalds's avatar
Linus Torvalds committed
123
/**
124 125 126
 *	mmc_request_done - finish processing an MMC request
 *	@host: MMC host which completed request
 *	@mrq: MMC request which request
Linus Torvalds's avatar
Linus Torvalds committed
127 128
 *
 *	MMC drivers should call this function when they have completed
129
 *	their processing of a request.
Linus Torvalds's avatar
Linus Torvalds committed
130 131 132 133
 */
void mmc_request_done(struct mmc_host *host, struct mmc_request *mrq)
{
	struct mmc_command *cmd = mrq->cmd;
134 135
	int err = cmd->error;

136 137 138 139 140 141
	/* Flag re-tuning needed on CRC errors */
	if (err == -EILSEQ || (mrq->sbc && mrq->sbc->error == -EILSEQ) ||
	    (mrq->data && mrq->data->error == -EILSEQ) ||
	    (mrq->stop && mrq->stop->error == -EILSEQ))
		mmc_retune_needed(host);

David Brownell's avatar
David Brownell committed
142 143 144 145 146
	if (err && cmd->retries && mmc_host_is_spi(host)) {
		if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND)
			cmd->retries = 0;
	}

147
	if (err && cmd->retries && !mmc_card_removed(host->card)) {
148 149 150 151 152 153
		/*
		 * Request starter must handle retries - see
		 * mmc_wait_for_req_done().
		 */
		if (mrq->done)
			mrq->done(mrq);
154
	} else {
155 156
		mmc_should_fail_request(host, mrq);

Pierre Ossman's avatar
Pierre Ossman committed
157 158
		led_trigger_event(host->led, LED_OFF);

159 160 161 162 163 164 165 166
		if (mrq->sbc) {
			pr_debug("%s: req done <CMD%u>: %d: %08x %08x %08x %08x\n",
				mmc_hostname(host), mrq->sbc->opcode,
				mrq->sbc->error,
				mrq->sbc->resp[0], mrq->sbc->resp[1],
				mrq->sbc->resp[2], mrq->sbc->resp[3]);
		}

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

189
		mmc_host_clk_release(host);
Linus Torvalds's avatar
Linus Torvalds committed
190 191 192 193 194
	}
}

EXPORT_SYMBOL(mmc_request_done);

195 196 197 198 199 200 201 202 203 204 205 206 207 208 209
static void __mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
{
	int err;

	/* Assumes host controller has been runtime resumed by mmc_claim_host */
	err = mmc_retune(host);
	if (err) {
		mrq->cmd->error = err;
		mmc_request_done(host, mrq);
		return;
	}

	host->ops->request(host, mrq);
}

210
static int mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
Linus Torvalds's avatar
Linus Torvalds committed
211
{
Pierre Ossman's avatar
Pierre Ossman committed
212 213
#ifdef CONFIG_MMC_DEBUG
	unsigned int i, sz;
214
	struct scatterlist *sg;
Pierre Ossman's avatar
Pierre Ossman committed
215
#endif
216 217
	mmc_retune_hold(host);

218 219
	if (mmc_card_removed(host->card))
		return -ENOMEDIUM;
Pierre Ossman's avatar
Pierre Ossman committed
220

221 222 223 224 225 226
	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);
	}

227 228 229
	pr_debug("%s: starting CMD%u arg %08x flags %08x\n",
		 mmc_hostname(host), mrq->cmd->opcode,
		 mrq->cmd->arg, mrq->cmd->flags);
Linus Torvalds's avatar
Linus Torvalds committed
230

231 232 233 234 235
	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,
236
			mrq->data->timeout_ns / 1000000,
237 238 239 240 241 242 243 244 245
			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);
	}

Pierre Ossman's avatar
Pierre Ossman committed
246
	WARN_ON(!host->claimed);
Linus Torvalds's avatar
Linus Torvalds committed
247 248 249

	mrq->cmd->error = 0;
	mrq->cmd->mrq = mrq;
250 251 252 253
	if (mrq->sbc) {
		mrq->sbc->error = 0;
		mrq->sbc->mrq = mrq;
	}
Linus Torvalds's avatar
Linus Torvalds committed
254
	if (mrq->data) {
255
		BUG_ON(mrq->data->blksz > host->max_blk_size);
256 257 258
		BUG_ON(mrq->data->blocks > host->max_blk_count);
		BUG_ON(mrq->data->blocks * mrq->data->blksz >
			host->max_req_size);
259

Pierre Ossman's avatar
Pierre Ossman committed
260 261
#ifdef CONFIG_MMC_DEBUG
		sz = 0;
262 263
		for_each_sg(mrq->data->sg, sg, mrq->data->sg_len, i)
			sz += sg->length;
Pierre Ossman's avatar
Pierre Ossman committed
264 265 266
		BUG_ON(sz != mrq->data->blocks * mrq->data->blksz);
#endif

Linus Torvalds's avatar
Linus Torvalds committed
267 268 269 270 271 272 273 274 275
		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;
		}
	}
276
	mmc_host_clk_hold(host);
277
	led_trigger_event(host->led, LED_FULL);
278
	__mmc_start_request(host, mrq);
279 280

	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
281 282
}

283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300
/**
 *	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);

301
	if (!card->ext_csd.man_bkops_en || mmc_card_doing_bkops(card))
302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326
		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;
	}

327 328
	mmc_retune_hold(card->host);

329
	err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
330 331
			EXT_CSD_BKOPS_START, 1, timeout,
			use_busy_signal, true, false);
332 333 334
	if (err) {
		pr_warn("%s: Error %d starting bkops\n",
			mmc_hostname(card->host), err);
335
		mmc_retune_release(card->host);
336 337 338 339 340 341 342 343 344 345
		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);
346 347
	else
		mmc_retune_release(card->host);
348 349 350 351 352
out:
	mmc_release_host(card->host);
}
EXPORT_SYMBOL(mmc_start_bkops);

353 354 355 356 357 358 359 360
/*
 * 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)
{
361 362 363 364
	struct mmc_context_info *context_info = &mrq->host->context_info;

	context_info->is_done_rcv = true;
	wake_up_interruptible(&context_info->wait);
365 366
}

Linus Torvalds's avatar
Linus Torvalds committed
367 368
static void mmc_wait_done(struct mmc_request *mrq)
{
369 370 371
	complete(&mrq->completion);
}

372 373 374 375 376 377 378 379 380 381
/*
 *__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)
{
382 383
	int err;

384 385
	mrq->done = mmc_wait_data_done;
	mrq->host = host;
386 387 388 389

	err = mmc_start_request(host, mrq);
	if (err) {
		mrq->cmd->error = err;
390
		mmc_wait_data_done(mrq);
391 392
	}

393
	return err;
394 395
}

396
static int __mmc_start_req(struct mmc_host *host, struct mmc_request *mrq)
397
{
398 399
	int err;

400 401
	init_completion(&mrq->completion);
	mrq->done = mmc_wait_done;
402 403 404 405

	err = mmc_start_request(host, mrq);
	if (err) {
		mrq->cmd->error = err;
406 407
		complete(&mrq->completion);
	}
408 409

	return err;
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
/*
 * 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;
443

444 445 446 447 448 449
			if (!cmd->error || !cmd->retries ||
			    mmc_card_removed(host->card)) {
				err = host->areq->err_check(host->card,
							    host->areq);
				break; /* return err */
			} else {
450
				mmc_retune_recheck(host);
451 452 453 454 455
				pr_info("%s: req failed (CMD%u): %d, retrying...\n",
					mmc_hostname(host),
					cmd->opcode, cmd->error);
				cmd->retries--;
				cmd->error = 0;
456
				__mmc_start_request(host, mrq);
457 458 459 460
				continue; /* wait for done/new event again */
			}
		} else if (context_info->is_new_req) {
			context_info->is_new_req = false;
461 462
			if (!next_req)
				return MMC_BLK_NEW_REQUEST;
463 464
		}
	}
465
	mmc_retune_release(host);
466 467 468
	return err;
}

469 470 471
static void mmc_wait_for_req_done(struct mmc_host *host,
				  struct mmc_request *mrq)
{
472 473 474 475 476 477
	struct mmc_command *cmd;

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

		cmd = mrq->cmd;
478 479 480 481 482 483 484 485 486

		/*
		 * If host has timed out waiting for the sanitize
		 * to complete, card might be still in programming state
		 * so let's try to bring the card out of programming
		 * state.
		 */
		if (cmd->sanitize_busy && cmd->error == -ETIMEDOUT) {
			if (!mmc_interrupt_hpi(host->card)) {
487 488
				pr_warn("%s: %s: Interrupted sanitize\n",
					mmc_hostname(host), __func__);
489 490 491 492 493 494 495
				cmd->error = 0;
				break;
			} else {
				pr_err("%s: %s: Failed to interrupt sanitize\n",
				       mmc_hostname(host), __func__);
			}
		}
496 497
		if (!cmd->error || !cmd->retries ||
		    mmc_card_removed(host->card))
498 499
			break;

500 501
		mmc_retune_recheck(host);

502 503 504 505
		pr_debug("%s: req failed (CMD%u): %d, retrying...\n",
			 mmc_hostname(host), cmd->opcode, cmd->error);
		cmd->retries--;
		cmd->error = 0;
506
		__mmc_start_request(host, mrq);
507
	}
508 509

	mmc_retune_release(host);
510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525
}

/**
 *	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)
{
526 527
	if (host->ops->pre_req) {
		mmc_host_clk_hold(host);
528
		host->ops->pre_req(host, mrq, is_first_req);
529 530
		mmc_host_clk_release(host);
	}
531 532 533 534 535 536 537 538 539 540 541 542 543 544
}

/**
 *	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)
{
545 546
	if (host->ops->post_req) {
		mmc_host_clk_hold(host);
547
		host->ops->post_req(host, mrq, err);
548 549
		mmc_host_clk_release(host);
	}
Linus Torvalds's avatar
Linus Torvalds committed
550 551
}

552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571
/**
 *	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;
572
	int start_err = 0;
573 574 575 576 577 578 579
	struct mmc_async_req *data = host->areq;

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

	if (host->areq) {
Jaehoon Chung's avatar
Jaehoon Chung committed
580 581 582 583 584 585 586 587 588 589
		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;
		}
590 591 592 593 594 595
		/*
		 * 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)) &&
596 597 598 599 600 601
		    (host->areq->mrq->cmd->resp[0] & R1_EXCEPTION_EVENT)) {

			/* Cancel the prepared request */
			if (areq)
				mmc_post_req(host, areq->mrq, -EINVAL);

602
			mmc_start_bkops(host->card, true);
603 604 605 606 607

			/* prepare the request again */
			if (areq)
				mmc_pre_req(host, areq->mrq, !host->areq);
		}
608 609
	}

610
	if (!err && areq)
611
		start_err = __mmc_start_data_req(host, areq->mrq);
612 613 614 615

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

616 617
	 /* Cancel a prepared request if it was not started. */
	if ((err || start_err) && areq)
Jaehoon Chung's avatar
Jaehoon Chung committed
618
		mmc_post_req(host, areq->mrq, -EINVAL);
619 620 621 622 623 624

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

625 626 627 628 629 630
	if (error)
		*error = err;
	return data;
}
EXPORT_SYMBOL(mmc_start_req);

Pierre Ossman's avatar
Pierre Ossman committed
631 632 633 634 635 636 637 638 639 640
/**
 *	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)
Linus Torvalds's avatar
Linus Torvalds committed
641
{
642 643
	__mmc_start_req(host, mrq);
	mmc_wait_for_req_done(host, mrq);
Linus Torvalds's avatar
Linus Torvalds committed
644 645 646
}
EXPORT_SYMBOL(mmc_wait_for_req);

647 648 649 650 651
/**
 *	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
652
 *	until out-of prg-state.
653 654 655 656 657
 */
int mmc_interrupt_hpi(struct mmc_card *card)
{
	int err;
	u32 status;
658
	unsigned long prg_wait;
659 660 661 662 663 664 665 666 667 668 669 670 671 672 673

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

674 675 676 677
	switch (R1_CURRENT_STATE(status)) {
	case R1_STATE_IDLE:
	case R1_STATE_READY:
	case R1_STATE_STBY:
678
	case R1_STATE_TRAN:
679
		/*
680
		 * In idle and transfer states, HPI is not needed and the caller
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
		 * 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);
707 708 709 710 711 712 713

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

Linus Torvalds's avatar
Linus Torvalds committed
714 715 716 717 718 719 720 721 722 723 724 725
/**
 *	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)
{
726
	struct mmc_request mrq = {NULL};
Linus Torvalds's avatar
Linus Torvalds committed
727

728
	WARN_ON(!host->claimed);
Linus Torvalds's avatar
Linus Torvalds committed
729 730 731 732 733 734 735 736 737 738 739 740 741 742

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

743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764
/**
 *	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);
765
		mmc_retune_release(card->host);
766 767 768 769 770 771 772 773 774 775 776 777 778
		err = 0;
	}

	return err;
}
EXPORT_SYMBOL(mmc_stop_bkops);

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

	mmc_claim_host(card->host);
779
	err = mmc_get_ext_csd(card, &ext_csd);
780 781
	mmc_release_host(card->host);
	if (err)
782
		return err;
783 784 785 786

	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];
	kfree(ext_csd);
787
	return 0;
788 789 790
}
EXPORT_SYMBOL(mmc_read_bkops_status);

791 792 793 794
/**
 *	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
Pierre Ossman's avatar
Pierre Ossman committed
795 796 797
 *
 *	Computes the data timeout parameters according to the
 *	correct algorithm given the card type.
798
 */
799
void mmc_set_data_timeout(struct mmc_data *data, const struct mmc_card *card)
800 801 802
{
	unsigned int mult;

803 804 805 806 807 808 809 810 811
	/*
	 * 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;
	}

812 813 814 815 816 817 818 819 820
	/*
	 * 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.
	 */
821
	if (data->flags & MMC_DATA_WRITE)
822 823 824 825 826 827 828 829 830 831 832 833
		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;
834 835 836
		if (mmc_host_clk_rate(card->host))
			timeout_us += data->timeout_clks * 1000 /
				(mmc_host_clk_rate(card->host) / 1000);
837

838
		if (data->flags & MMC_DATA_WRITE)
839
			/*
840 841 842 843 844 845
			 * 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.
846
			 */
847
			limit_us = 3000000;
848 849 850
		else
			limit_us = 100000;

851 852 853 854
		/*
		 * SDHC cards always use these fixed values.
		 */
		if (timeout_us > limit_us || mmc_card_blockaddr(card)) {
855 856 857
			data->timeout_ns = limit_us * 1000;
			data->timeout_clks = 0;
		}
858 859 860 861

		/* assign limit value if invalid */
		if (timeout_us == 0)
			data->timeout_ns = limit_us * 1000;
862
	}
863 864 865 866 867 868 869 870 871 872 873 874

	/*
	 * 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;
	}

875 876 877 878 879 880 881 882 883 884 885 886 887 888 889
	/*
	 * 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 */
		}
	}
890 891 892
}
EXPORT_SYMBOL(mmc_set_data_timeout);

893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919
/**
 *	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);

Linus Torvalds's avatar
Linus Torvalds committed
920
/**
921
 *	__mmc_claim_host - exclusively claim a host
Linus Torvalds's avatar
Linus Torvalds committed
922
 *	@host: mmc host to claim
923
 *	@abort: whether or not the operation should be aborted
Linus Torvalds's avatar
Linus Torvalds committed
924
 *
925 926 927 928
 *	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.
Linus Torvalds's avatar
Linus Torvalds committed
929
 */
930
int __mmc_claim_host(struct mmc_host *host, atomic_t *abort)
Linus Torvalds's avatar
Linus Torvalds committed
931 932 933
{
	DECLARE_WAITQUEUE(wait, current);
	unsigned long flags;
934
	int stop;
935
	bool pm = false;
Linus Torvalds's avatar
Linus Torvalds committed
936

937 938
	might_sleep();

Linus Torvalds's avatar
Linus Torvalds committed
939 940 941 942
	add_wait_queue(&host->wq, &wait);
	spin_lock_irqsave(&host->lock, flags);
	while (1) {
		set_current_state(TASK_UNINTERRUPTIBLE);
943
		stop = abort ? atomic_read(abort) : 0;
944
		if (stop || !host->claimed || host->claimer == current)
Linus Torvalds's avatar
Linus Torvalds committed
945 946 947 948 949 950
			break;
		spin_unlock_irqrestore(&host->lock, flags);
		schedule();
		spin_lock_irqsave(&host->lock, flags);
	}
	set_current_state(TASK_RUNNING);
951
	if (!stop) {
952
		host->claimed = 1;
953 954
		host->claimer = current;
		host->claim_cnt += 1;
955 956
		if (host->claim_cnt == 1)
			pm = true;
957
	} else
958
		wake_up(&host->wq);
Linus Torvalds's avatar
Linus Torvalds committed
959 960
	spin_unlock_irqrestore(&host->lock, flags);
	remove_wait_queue(&host->wq, &wait);
961 962 963 964

	if (pm)
		pm_runtime_get_sync(mmc_dev(host));

965
	return stop;
Linus Torvalds's avatar
Linus Torvalds committed
966
}
967
EXPORT_SYMBOL(__mmc_claim_host);
968

969
/**
970
 *	mmc_release_host - release a host
971 972
 *	@host: mmc host to release
 *
973 974
 *	Release a MMC host, allowing others to claim the host
 *	for their operations.
975
 */
976
void mmc_release_host(struct mmc_host *host)
977 978 979
{
	unsigned long flags;

980 981
	WARN_ON(!host->claimed);

982
	spin_lock_irqsave(&host->lock, flags);
983 984 985 986 987 988 989 990
	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);
991 992
		pm_runtime_mark_last_busy(mmc_dev(host));
		pm_runtime_put_autosuspend(mmc_dev(host));
993
	}
994
}
Linus Torvalds's avatar
Linus Torvalds committed
995 996
EXPORT_SYMBOL(mmc_release_host);

997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019
/*
 * This is a helper function, which fetches a runtime pm reference for the
 * card device and also claims the host.
 */
void mmc_get_card(struct mmc_card *card)
{
	pm_runtime_get_sync(&card->dev);
	mmc_claim_host(card->host);
}
EXPORT_SYMBOL(mmc_get_card);

/*
 * This is a helper function, which releases the host and drops the runtime
 * pm reference for the card device.
 */
void mmc_put_card(struct mmc_card *card)
{
	mmc_release_host(card->host);
	pm_runtime_mark_last_busy(&card->dev);
	pm_runtime_put_autosuspend(&card->dev);
}
EXPORT_SYMBOL(mmc_put_card);

Pierre Ossman's avatar
Pierre Ossman committed
1020 1021 1022 1023
/*
 * Internal function that does the actual ios call to the host driver,
 * optionally printing some debug output.
 */
1024 1025 1026 1027
static inline void mmc_set_ios(struct mmc_host *host)
{
	struct mmc_ios *ios = &host->ios;

1028 1029
	pr_debug("%s: clock %uHz busmode %u powermode %u cs %u Vdd %u "
		"width %u timing %u\n",
1030 1031
		 mmc_hostname(host), ios->clock, ios->bus_mode,
		 ios->power_mode, ios->chip_select, ios->vdd,
1032
		 ios->bus_width, ios->timing);
1033

1034 1035
	if (ios->clock > 0)
		mmc_set_ungated(host);
1036 1037 1038
	host->ops->set_ios(host, ios);
}

Pierre Ossman's avatar
Pierre Ossman committed
1039 1040 1041
/*
 * Control chip select pin on a host.
 */
Pierre Ossman's avatar
Pierre Ossman committed
1042
void mmc_set_chip_select(struct mmc_host *host, int mode)
Linus Torvalds's avatar
Linus Torvalds committed
1043
{
1044
	mmc_host_clk_hold(host);
Pierre Ossman's avatar
Pierre Ossman committed
1045 1046
	host->ios.chip_select = mode;
	mmc_set_ios(host);
1047
	mmc_host_clk_release(host);
Linus Torvalds's avatar
Linus Torvalds committed
1048 1049
}

Pierre Ossman's avatar
Pierre Ossman committed
1050 1051 1052 1053
/*
 * Sets the host clock to the highest possible frequency that
 * is below "hz".
 */
1054
static void __mmc_set_clock(struct mmc_host *host, unsigned int hz)
Pierre Ossman's avatar
Pierre Ossman committed
1055
{
1056
	WARN_ON(hz && hz < host->f_min);
Pierre Ossman's avatar
Pierre Ossman committed
1057 1058 1059 1060 1061 1062 1063 1064

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

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

1065 1066 1067 1068 1069 1070 1071
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);
}

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 1098 1099 1100 1101 1102 1103
#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 */
1104
		__mmc_set_clock(host, host->clk_old);
1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126
	}
}

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

1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146
int mmc_execute_tuning(struct mmc_card *card)
{
	struct mmc_host *host = card->host;
	u32 opcode;
	int err;

	if (!host->ops->execute_tuning)
		return 0;

	if (mmc_card_mmc(card))
		opcode = MMC_SEND_TUNING_BLOCK_HS200;
	else
		opcode = MMC_SEND_TUNING_BLOCK;

	mmc_host_clk_hold(host);
	err = host->ops->execute_tuning(host, opcode);
	mmc_host_clk_release(host);

	if (err)
		pr_err("%s: tuning execution failed\n", mmc_hostname(host));
1147 1148
	else
		mmc_retune_enable(host);
1149 1150 1151 1152

	return err;
}

Pierre Ossman's avatar
Pierre Ossman committed
1153 1154 1155 1156 1157
/*
 * Change the bus mode (open drain/push-pull) of a host.
 */
void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode)
{
1158
	mmc_host_clk_hold(host);
Pierre Ossman's avatar
Pierre Ossman committed
1159 1160
	host->ios.bus_mode = mode;
	mmc_set_ios(host);
1161
	mmc_host_clk_release(host);
Pierre Ossman's avatar
Pierre Ossman committed
1162 1163
}

1164 1165 1166 1167 1168
/*
 * Change data bus width of a host.
 */
void mmc_set_bus_width(struct mmc_host *host, unsigned int width)
{
1169
	mmc_host_clk_hold(host);
1170 1171
	host->ios.bus_width = width;
	mmc_set_ios(host);
1172
	mmc_host_clk_release(host);
1173 1174
}

1175 1176 1177 1178 1179
/*
 * Set initial state after a power cycle or a hw_reset.
 */
void mmc_set_initial_state(struct mmc_host *host)
{
1180 1181
	mmc_retune_disable(host);

1182 1183 1184 1185 1186 1187 1188
	if (mmc_host_is_spi(host))
		host->ios.chip_select = MMC_CS_HIGH;
	else
		host->ios.chip_select = MMC_CS_DONTCARE;
	host->ios.bus_mode = MMC_BUSMODE_PUSHPULL;
	host->ios.bus_width = MMC_BUS_WIDTH_1;
	host->ios.timing = MMC_TIMING_LEGACY;
1189
	host->ios.drv_type = 0;
1190 1191 1192 1193

	mmc_set_ios(host);
}

1194 1195 1196