Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit e7747475b61fdc2a4a412475a9d64d8c309916e3

Authored by Ulf Hansson 2012-03-01 20:18:05 +0800

Committed by Chris Ball 2012-03-05 01:25:15 +0800

Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches

mmc: core: Fixup suspend/resume issues for UHS-I cards

Even if cards supports 1.8V I/O voltage those should anyway be
initialized at 3.3V I/O according to (e)MMC, SD and SDIO specs.
Some eMMC and embedded SDIO devices are able to be initialized
at 1.8V as well, but it is better to be safe.

Do note that initialization in this context means that the card
has been completely powered off, otherwise the card will remain
at the last I/O voltage level that were negotitiated.

Due to the above being taken care of the suspend/resume issues
for UHS-I SD-cards has been fixed.

Signed-off-by: Ulf Hansson <ulf.hansson@stericsson.com>
Acked-by: Philip Rakity <prakity@marvell.com>
Acked-by: Linus Walleij <linus.walleij@linaro.org>
Tested-by: Subhash Jadavani <subhashj@codeaurora.org>
Signed-off-by: Chris Ball <cjb@laptop.org>

Showing 4 changed files with 17 additions and 5 deletions Inline Diff

drivers/mmc/core/core.c
drivers/mmc/core/mmc.c
drivers/mmc/core/sd.c
drivers/mmc/core/sdio.c

drivers/mmc/core/core.c

Diff comments View file @ e774747

 /*
  *  linux/drivers/mmc/core/core.c
  *
  *  Copyright (C) 2003-2004 Russell King, All Rights Reserved.
  *  SD support Copyright (C) 2004 Ian Molton, All Rights Reserved.
  *  Copyright (C) 2005-2008 Pierre Ossman, All Rights Reserved.
  *  MMCv4 support Copyright (C) 2006 Philip Langdale, All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
 #include <linux/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>
 #include <linux/leds.h>
 #include <linux/scatterlist.h>
 #include <linux/log2.h>
 #include <linux/regulator/consumer.h>
 #include <linux/pm_runtime.h>
 #include <linux/suspend.h>
 #include <linux/fault-inject.h>
 #include <linux/random.h>
 #include <linux/mmc/card.h>
 #include <linux/mmc/host.h>
 #include <linux/mmc/mmc.h>
 #include <linux/mmc/sd.h>
 #include "core.h"
 #include "bus.h"
 #include "host.h"
 #include "sdio_bus.h"
 #include "mmc_ops.h"
 #include "sd_ops.h"
 #include "sdio_ops.h"
 static struct workqueue_struct *workqueue;
 /*
  * 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.
  */
 bool use_spi_crc = 1;
 module_param(use_spi_crc, bool, 0);
 /*
  * 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
 bool mmc_assume_removable;
 #else
 bool mmc_assume_removable = 1;
 #endif
 EXPORT_SYMBOL(mmc_assume_removable);
 module_param_named(removable, mmc_assume_removable, bool, 0644);
 MODULE_PARM_DESC(
 	removable,
 	"MMC/SD cards are removable and may be removed during suspend");
 /*
  * 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);
 }
 #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 */
 /**
  *	mmc_request_done - finish processing an MMC request
  *	@host: MMC host which completed request
  *	@mrq: MMC request which request
  *
  *	MMC drivers should call this function when they have completed
  *	their processing of a request.
  */
 void mmc_request_done(struct mmc_host *host, struct mmc_request *mrq)
 {
 	struct mmc_command *cmd = mrq->cmd;
 	int err = cmd->error;
 	if (err && cmd->retries && mmc_host_is_spi(host)) {
 		if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND)
 			cmd->retries = 0;
 	}
 	if (err && cmd->retries && !mmc_card_removed(host->card)) {
 		/*
 		 * Request starter must handle retries - see
 		 * mmc_wait_for_req_done().
 		 */
 		if (mrq->done)
 			mrq->done(mrq);
 	} else {
 		mmc_should_fail_request(host, mrq);
 		led_trigger_event(host->led, LED_OFF);
 		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);
 		mmc_host_clk_release(host);
 	}
 }
 EXPORT_SYMBOL(mmc_request_done);
 static void
 mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
 {
 #ifdef CONFIG_MMC_DEBUG
 	unsigned int i, sz;
 	struct scatterlist *sg;
 #endif
 	pr_debug("%s: starting CMD%u arg %08x flags %08x\n",
 		 mmc_hostname(host), mrq->cmd->opcode,
 		 mrq->cmd->arg, mrq->cmd->flags);
 	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,
 			mrq->data->timeout_ns / 1000000,
 			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);
 	}
 	WARN_ON(!host->claimed);
 	mrq->cmd->error = 0;
 	mrq->cmd->mrq = mrq;
 	if (mrq->data) {
 		BUG_ON(mrq->data->blksz > host->max_blk_size);
 		BUG_ON(mrq->data->blocks > host->max_blk_count);
 		BUG_ON(mrq->data->blocks * mrq->data->blksz >
 			host->max_req_size);
 #ifdef CONFIG_MMC_DEBUG
 		sz = 0;
 		for_each_sg(mrq->data->sg, sg, mrq->data->sg_len, i)
 			sz += sg->length;
 		BUG_ON(sz != mrq->data->blocks * mrq->data->blksz);
 #endif
 		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;
 		}
 	}
 	mmc_host_clk_hold(host);
 	led_trigger_event(host->led, LED_FULL);
 	host->ops->request(host, mrq);
 }
 static void mmc_wait_done(struct mmc_request *mrq)
 {
 	complete(&mrq->completion);
 }
 static void __mmc_start_req(struct mmc_host *host, struct mmc_request *mrq)
 {
 	init_completion(&mrq->completion);
 	mrq->done = mmc_wait_done;
 	if (mmc_card_removed(host->card)) {
 		mrq->cmd->error = -ENOMEDIUM;
 		complete(&mrq->completion);
 		return;
 	}
 	mmc_start_request(host, mrq);
 }
 static void mmc_wait_for_req_done(struct mmc_host *host,
 				  struct mmc_request *mrq)
 {
 	struct mmc_command *cmd;
 	while (1) {
 		wait_for_completion(&mrq->completion);
 		cmd = mrq->cmd;
 		if (!cmd->error || !cmd->retries ||
 		    mmc_card_removed(host->card))
 			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);
 	}
 }
 /**
  *	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)
 {
 	if (host->ops->pre_req) {
 		mmc_host_clk_hold(host);
 		host->ops->pre_req(host, mrq, is_first_req);
 		mmc_host_clk_release(host);
 	}
 }
 /**
  *	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)
 {
 	if (host->ops->post_req) {
 		mmc_host_clk_hold(host);
 		host->ops->post_req(host, mrq, err);
 		mmc_host_clk_release(host);
 	}
 }
 /**
  *	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;
 	struct mmc_async_req *data = host->areq;
 	/* Prepare a new request */
 	if (areq)
 		mmc_pre_req(host, areq->mrq, !host->areq);
 	if (host->areq) {
 		mmc_wait_for_req_done(host, host->areq->mrq);
 		err = host->areq->err_check(host->card, host->areq);
 		if (err) {
 			/* post process the completed failed request */
 			mmc_post_req(host, host->areq->mrq, 0);
 			if (areq)
 				/*
 				 * Cancel the new prepared request, because
 				 * it can't run until the failed
 				 * request has been properly handled.
 				 */
 				mmc_post_req(host, areq->mrq, -EINVAL);
 			host->areq = NULL;
 			goto out;
 		}
 	}
 	if (areq)
 		__mmc_start_req(host, areq->mrq);
 	if (host->areq)
 		mmc_post_req(host, host->areq->mrq, 0);
 	host->areq = areq;
  out:
 	if (error)
 		*error = err;
 	return data;
 }
 EXPORT_SYMBOL(mmc_start_req);
 /**
  *	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)
 {
 	__mmc_start_req(host, mrq);
 	mmc_wait_for_req_done(host, mrq);
 }
 EXPORT_SYMBOL(mmc_wait_for_req);
 /**
  *	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
  *	util out-of prg-state.
  */
 int mmc_interrupt_hpi(struct mmc_card *card)
 {
 	int err;
 	u32 status;
 	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;
 	}
 	/*
 	 * If the card status is in PRG-state, we can send the HPI command.
 	 */
 	if (R1_CURRENT_STATE(status) == R1_STATE_PRG) {
 		do {
 			/*
 			 * We don't know when the HPI command will finish
 			 * processing, so we need to resend HPI until out
 			 * of prg-state, and keep checking the card status
 			 * with SEND_STATUS.  If a timeout error occurs when
 			 * sending the HPI command, we are already out of
 			 * prg-state.
 			 */
 			err = mmc_send_hpi_cmd(card, &status);
 			if (err)
 				pr_debug("%s: abort HPI (%d error)\n",
 					 mmc_hostname(card->host), err);
 			err = mmc_send_status(card, &status);
 			if (err)
 				break;
 		} while (R1_CURRENT_STATE(status) == R1_STATE_PRG);
 	} else
 		pr_debug("%s: Left prg-state\n", mmc_hostname(card->host));
 out:
 	mmc_release_host(card->host);
 	return err;
 }
 EXPORT_SYMBOL(mmc_interrupt_hpi);
 /**
  *	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)
 {
 	struct mmc_request mrq = {NULL};
 	WARN_ON(!host->claimed);
 	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);
 /**
  *	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
  *
  *	Computes the data timeout parameters according to the
  *	correct algorithm given the card type.
  */
 void mmc_set_data_timeout(struct mmc_data *data, const struct mmc_card *card)
 {
 	unsigned int mult;
 	/*
 	 * 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;
 	}
 	/*
 	 * 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.
 	 */
 	if (data->flags & MMC_DATA_WRITE)
 		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;
 		if (mmc_host_clk_rate(card->host))
 			timeout_us += data->timeout_clks * 1000 /
 				(mmc_host_clk_rate(card->host) / 1000);
 		if (data->flags & MMC_DATA_WRITE)
 			/*
 			 * The limit is really 250 ms, but that is
 			 * insufficient for some crappy cards.
 			 */
 			limit_us = 300000;
 		else
 			limit_us = 100000;
 		/*
 		 * SDHC cards always use these fixed values.
 		 */
 		if (timeout_us > limit_us || mmc_card_blockaddr(card)) {
 			data->timeout_ns = limit_us * 1000;
 			data->timeout_clks = 0;
 		}
 	}
 	/*
 	 * 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;
 	}
 	/*
 	 * 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 */
 		}
 	}
 }
 EXPORT_SYMBOL(mmc_set_data_timeout);
 /**
  *	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);
 /**
  *	mmc_host_enable - enable a host.
  *	@host: mmc host to enable
  *
  *	Hosts that support power saving can use the 'enable' and 'disable'
  *	methods to exit and enter power saving states. For more information
  *	see comments for struct mmc_host_ops.
  */
 int mmc_host_enable(struct mmc_host *host)
 {
 	if (!(host->caps & MMC_CAP_DISABLE))
 		return 0;
 	if (host->en_dis_recurs)
 		return 0;
 	if (host->nesting_cnt++)
 		return 0;
 	cancel_delayed_work_sync(&host->disable);
 	if (host->enabled)
 		return 0;
 	if (host->ops->enable) {
 		int err;
 		host->en_dis_recurs = 1;
 		mmc_host_clk_hold(host);
 		err = host->ops->enable(host);
 		mmc_host_clk_release(host);
 		host->en_dis_recurs = 0;
 		if (err) {
 			pr_debug("%s: enable error %d\n",
 				 mmc_hostname(host), err);
 			return err;
 		}
 	}
 	host->enabled = 1;
 	return 0;
 }
 EXPORT_SYMBOL(mmc_host_enable);
 static int mmc_host_do_disable(struct mmc_host *host, int lazy)
 {
 	if (host->ops->disable) {
 		int err;
 		host->en_dis_recurs = 1;
 		mmc_host_clk_hold(host);
 		err = host->ops->disable(host, lazy);
 		mmc_host_clk_release(host);
 		host->en_dis_recurs = 0;
 		if (err < 0) {
 			pr_debug("%s: disable error %d\n",
 				 mmc_hostname(host), err);
 			return err;
 		}
 		if (err > 0) {
 			unsigned long delay = msecs_to_jiffies(err);
 			mmc_schedule_delayed_work(&host->disable, delay);
 		}
 	}
 	host->enabled = 0;
 	return 0;
 }
 /**
  *	mmc_host_disable - disable a host.
  *	@host: mmc host to disable
  *
  *	Hosts that support power saving can use the 'enable' and 'disable'
  *	methods to exit and enter power saving states. For more information
  *	see comments for struct mmc_host_ops.
  */
 int mmc_host_disable(struct mmc_host *host)
 {
 	int err;
 	if (!(host->caps & MMC_CAP_DISABLE))
 		return 0;
 	if (host->en_dis_recurs)
 		return 0;
 	if (--host->nesting_cnt)
 		return 0;
 	if (!host->enabled)
 		return 0;
 	err = mmc_host_do_disable(host, 0);
 	return err;
 }
 EXPORT_SYMBOL(mmc_host_disable);
 /**
  *	__mmc_claim_host - exclusively claim a host
  *	@host: mmc host to claim
  *	@abort: whether or not the operation should be aborted
  *
  *	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.
  */
 int __mmc_claim_host(struct mmc_host *host, atomic_t *abort)
 {
 	DECLARE_WAITQUEUE(wait, current);
 	unsigned long flags;
 	int stop;
 	might_sleep();
 	add_wait_queue(&host->wq, &wait);
 	spin_lock_irqsave(&host->lock, flags);
 	while (1) {
 		set_current_state(TASK_UNINTERRUPTIBLE);
 		stop = abort ? atomic_read(abort) : 0;
 		if (stop || !host->claimed || host->claimer == current)
 			break;
 		spin_unlock_irqrestore(&host->lock, flags);
 		schedule();
 		spin_lock_irqsave(&host->lock, flags);
 	}
 	set_current_state(TASK_RUNNING);
 	if (!stop) {
 		host->claimed = 1;
 		host->claimer = current;
 		host->claim_cnt += 1;
 	} else
 		wake_up(&host->wq);
 	spin_unlock_irqrestore(&host->lock, flags);
 	remove_wait_queue(&host->wq, &wait);
 	if (!stop)
 		mmc_host_enable(host);
 	return stop;
 }
 EXPORT_SYMBOL(__mmc_claim_host);
 /**
  *	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)
 {
 	int claimed_host = 0;
 	unsigned long flags;
 	spin_lock_irqsave(&host->lock, flags);
 	if (!host->claimed || host->claimer == current) {
 		host->claimed = 1;
 		host->claimer = current;
 		host->claim_cnt += 1;
 		claimed_host = 1;
 	}
 	spin_unlock_irqrestore(&host->lock, flags);
 	return claimed_host;
 }
 EXPORT_SYMBOL(mmc_try_claim_host);
 /**
  *	mmc_do_release_host - release a claimed host
  *	@host: mmc host to release
  *
  *	If you successfully claimed a host, this function will
  *	release it again.
  */
 void mmc_do_release_host(struct mmc_host *host)
 {
 	unsigned long flags;
 	spin_lock_irqsave(&host->lock, flags);
 	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);
 	}
 }
 EXPORT_SYMBOL(mmc_do_release_host);
 void mmc_host_deeper_disable(struct work_struct *work)
 {
 	struct mmc_host *host =
 		container_of(work, struct mmc_host, disable.work);
 	/* If the host is claimed then we do not want to disable it anymore */
 	if (!mmc_try_claim_host(host))
 		return;
 	mmc_host_do_disable(host, 1);
 	mmc_do_release_host(host);
 }
 /**
  *	mmc_host_lazy_disable - lazily disable a host.
  *	@host: mmc host to disable
  *
  *	Hosts that support power saving can use the 'enable' and 'disable'
  *	methods to exit and enter power saving states. For more information
  *	see comments for struct mmc_host_ops.
  */
 int mmc_host_lazy_disable(struct mmc_host *host)
 {
 	if (!(host->caps & MMC_CAP_DISABLE))
 		return 0;
 	if (host->en_dis_recurs)
 		return 0;
 	if (--host->nesting_cnt)
 		return 0;
 	if (!host->enabled)
 		return 0;
 	if (host->disable_delay) {
 		mmc_schedule_delayed_work(&host->disable,
 				msecs_to_jiffies(host->disable_delay));
 		return 0;
 	} else
 		return mmc_host_do_disable(host, 1);
 }
 EXPORT_SYMBOL(mmc_host_lazy_disable);
 /**
  *	mmc_release_host - release a host
  *	@host: mmc host to release
  *
  *	Release a MMC host, allowing others to claim the host
  *	for their operations.
  */
 void mmc_release_host(struct mmc_host *host)
 {
 	WARN_ON(!host->claimed);
 	mmc_host_lazy_disable(host);
 	mmc_do_release_host(host);
 }
 EXPORT_SYMBOL(mmc_release_host);
 /*
  * Internal function that does the actual ios call to the host driver,
  * optionally printing some debug output.
  */
 static inline void mmc_set_ios(struct mmc_host *host)
 {
 	struct mmc_ios *ios = &host->ios;
 	pr_debug("%s: clock %uHz busmode %u powermode %u cs %u Vdd %u "
 		"width %u timing %u\n",
 		 mmc_hostname(host), ios->clock, ios->bus_mode,
 		 ios->power_mode, ios->chip_select, ios->vdd,
 		 ios->bus_width, ios->timing);
 	if (ios->clock > 0)
 		mmc_set_ungated(host);
 	host->ops->set_ios(host, ios);
 }
 /*
  * Control chip select pin on a host.
  */
 void mmc_set_chip_select(struct mmc_host *host, int mode)
 {
 	mmc_host_clk_hold(host);
 	host->ios.chip_select = mode;
 	mmc_set_ios(host);
 	mmc_host_clk_release(host);
 }
 /*
  * Sets the host clock to the highest possible frequency that
  * is below "hz".
  */
 static void __mmc_set_clock(struct mmc_host *host, unsigned int hz)
 {
 	WARN_ON(hz < host->f_min);
 	if (hz > host->f_max)
 		hz = host->f_max;
 	host->ios.clock = hz;
 	mmc_set_ios(host);
 }
 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);
 }
 #ifdef CONFIG_MMC_CLKGATE
 /*
  * This gates the clock by setting it to 0 Hz.
  */
 void mmc_gate_clock(struct mmc_host *host)
 {
 	unsigned long flags;
 	spin_lock_irqsave(&host->clk_lock, flags);
 	host->clk_old = host->ios.clock;
 	host->ios.clock = 0;
 	host->clk_gated = true;
 	spin_unlock_irqrestore(&host->clk_lock, flags);
 	mmc_set_ios(host);
 }
 /*
  * This restores the clock from gating by using the cached
  * clock value.
  */
 void mmc_ungate_clock(struct mmc_host *host)
 {
 	/*
 	 * We should previously have gated the clock, so the clock shall
 	 * be 0 here! The clock may however be 0 during initialization,
 	 * when some request operations are performed before setting
 	 * the frequency. When ungate is requested in that situation
 	 * we just ignore the call.
 	 */
 	if (host->clk_old) {
 		BUG_ON(host->ios.clock);
 		/* This call will also set host->clk_gated to false */
 		__mmc_set_clock(host, host->clk_old);
 	}
 }
 void mmc_set_ungated(struct mmc_host *host)
 {
 	unsigned long flags;
 	/*
 	 * We've been given a new frequency while the clock is gated,
 	 * so make sure we regard this as ungating it.
 	 */
 	spin_lock_irqsave(&host->clk_lock, flags);
 	host->clk_gated = false;
 	spin_unlock_irqrestore(&host->clk_lock, flags);
 }
 #else
 void mmc_set_ungated(struct mmc_host *host)
 {
 }
 #endif
 /*
  * Change the bus mode (open drain/push-pull) of a host.
  */
 void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode)
 {
 	mmc_host_clk_hold(host);
 	host->ios.bus_mode = mode;
 	mmc_set_ios(host);
 	mmc_host_clk_release(host);
 }
 /*
  * Change data bus width of a host.
  */
 void mmc_set_bus_width(struct mmc_host *host, unsigned int width)
 {
 	mmc_host_clk_hold(host);
 	host->ios.bus_width = width;
 	mmc_set_ios(host);
 	mmc_host_clk_release(host);
 }
 /**
  * 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);
 #ifdef CONFIG_REGULATOR
 /**
  * mmc_regulator_get_ocrmask - return mask of supported voltages
  * @supply: regulator to use
  *
  * This returns either a negative errno, or a mask of voltages that
  * can be provided to MMC/SD/SDIO devices using the specified voltage
  * regulator.  This would normally be called before registering the
  * MMC host adapter.
  */
 int mmc_regulator_get_ocrmask(struct regulator *supply)
 {
 	int			result = 0;
 	int			count;
 	int			i;
 	count = regulator_count_voltages(supply);
 	if (count < 0)
 		return count;
 	for (i = 0; i < count; i++) {
 		int		vdd_uV;
 		int		vdd_mV;
 		vdd_uV = regulator_list_voltage(supply, i);
 		if (vdd_uV <= 0)
 			continue;
 		vdd_mV = vdd_uV / 1000;
 		result |= mmc_vddrange_to_ocrmask(vdd_mV, vdd_mV);
 	}
 	return result;
 }
 EXPORT_SYMBOL(mmc_regulator_get_ocrmask);
 /**
  * mmc_regulator_set_ocr - set regulator to match host->ios voltage
  * @mmc: the host to regulate
  * @supply: regulator to use
  * @vdd_bit: zero for power off, else a bit number (host->ios.vdd)
  *
  * 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.
  */
 int mmc_regulator_set_ocr(struct mmc_host *mmc,
 			struct regulator *supply,
 			unsigned short vdd_bit)
 {
 	int			result = 0;
 	int			min_uV, max_uV;
 	if (vdd_bit) {
 		int		tmp;
 		int		voltage;
 		/* REVISIT mmc_vddrange_to_ocrmask() may have set some
 		 * bits this regulator doesn't quite support ... don't
 		 * be too picky, most cards and regulators are OK with
 		 * a 0.1V range goof (it's a small error percentage).
 		 */
 		tmp = vdd_bit - ilog2(MMC_VDD_165_195);
 		if (tmp == 0) {
 			min_uV = 1650 * 1000;
 			max_uV = 1950 * 1000;
 		} else {
 			min_uV = 1900 * 1000 + tmp * 100 * 1000;
 			max_uV = min_uV + 100 * 1000;
 		}
 		/* avoid needless changes to this voltage; the regulator
 		 * might not allow this operation
 		 */
 		voltage = regulator_get_voltage(supply);
 		if (mmc->caps2 & MMC_CAP2_BROKEN_VOLTAGE)
 			min_uV = max_uV = voltage;
 		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;
 		if (result == 0 && !mmc->regulator_enabled) {
 			result = regulator_enable(supply);
 			if (!result)
 				mmc->regulator_enabled = true;
 		}
 	} else if (mmc->regulator_enabled) {
 		result = regulator_disable(supply);
 		if (result == 0)
 			mmc->regulator_enabled = false;
 	}
 	if (result)
 		dev_err(mmc_dev(mmc),
 			"could not set regulator OCR (%d)\n", result);
 	return result;
 }
 EXPORT_SYMBOL(mmc_regulator_set_ocr);
 #endif /* CONFIG_REGULATOR */
 /*
  * Mask off any voltages we don't support and select
  * the lowest voltage
  */
 u32 mmc_select_voltage(struct mmc_host *host, u32 ocr)
 {
 	int bit;
 	ocr &= host->ocr_avail;
 	bit = ffs(ocr);
 	if (bit) {
 		bit -= 1;
 		ocr &= 3 << bit;
 		mmc_host_clk_hold(host);
 		host->ios.vdd = bit;
 		mmc_set_ios(host);
 		mmc_host_clk_release(host);
 	} else {
 		pr_warning("%s: host doesn't support card's voltages\n",
 				mmc_hostname(host));
 		ocr = 0;
 	}
 	return ocr;
 }
 int mmc_set_signal_voltage(struct mmc_host *host, int signal_voltage, bool cmd11)
 {
 	struct mmc_command cmd = {0};
 	int err = 0;
 	BUG_ON(!host);
 	/*
 	 * Send CMD11 only if the request is to switch the card to
 	 * 1.8V signalling.
 	 */
 	if ((signal_voltage != MMC_SIGNAL_VOLTAGE_330) && cmd11) {
 		cmd.opcode = SD_SWITCH_VOLTAGE;
 		cmd.arg = 0;
 		cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
 		err = mmc_wait_for_cmd(host, &cmd, 0);
 		if (err)
 			return err;
 		if (!mmc_host_is_spi(host) && (cmd.resp[0] & R1_ERROR))
 			return -EIO;
 	}
 	host->ios.signal_voltage = signal_voltage;
 	if (host->ops->start_signal_voltage_switch) {
 		mmc_host_clk_hold(host);
 		err = host->ops->start_signal_voltage_switch(host, &host->ios);
 		mmc_host_clk_release(host);
 	}
 	return err;
 }
 /*
  * Select timing parameters for host.
  */
 void mmc_set_timing(struct mmc_host *host, unsigned int timing)
 {
 	mmc_host_clk_hold(host);
 	host->ios.timing = timing;
 	mmc_set_ios(host);
 	mmc_host_clk_release(host);
 }
 /*
  * Select appropriate driver type for host.
  */
 void mmc_set_driver_type(struct mmc_host *host, unsigned int drv_type)
 {
 	mmc_host_clk_hold(host);
 	host->ios.drv_type = drv_type;
 	mmc_set_ios(host);
 	mmc_host_clk_release(host);
 }
 static void mmc_poweroff_notify(struct mmc_host *host)
 {
 	struct mmc_card *card;
 	unsigned int timeout;
 	unsigned int notify_type = EXT_CSD_NO_POWER_NOTIFICATION;
 	int err = 0;
 	card = host->card;
 	mmc_claim_host(host);
 	/*
 	 * Send power notify command only if card
 	 * is mmc and notify state is powered ON
 	 */
 	if (card && mmc_card_mmc(card) &&
 	    (card->poweroff_notify_state == MMC_POWERED_ON)) {
 		if (host->power_notify_type == MMC_HOST_PW_NOTIFY_SHORT) {
 			notify_type = EXT_CSD_POWER_OFF_SHORT;
 			timeout = card->ext_csd.generic_cmd6_time;
 			card->poweroff_notify_state = MMC_POWEROFF_SHORT;
 		} else {
 			notify_type = EXT_CSD_POWER_OFF_LONG;
 			timeout = card->ext_csd.power_off_longtime;
 			card->poweroff_notify_state = MMC_POWEROFF_LONG;
 		}
 		err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
 				 EXT_CSD_POWER_OFF_NOTIFICATION,
 				 notify_type, timeout);
 		if (err && err != -EBADMSG)
 			pr_err("Device failed to respond within %d poweroff "
 			       "time. Forcefully powering down the device\n",
 			       timeout);
 		/* Set the card state to no notification after the poweroff */
 		card->poweroff_notify_state = MMC_NO_POWER_NOTIFICATION;
 	}
 	mmc_release_host(host);
 }
 /*
  * 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.
  */
 static void mmc_power_up(struct mmc_host *host)
 {
 	int bit;
 	mmc_host_clk_hold(host);
 	/* If ocr is set, we use it */
 	if (host->ocr)
 		bit = ffs(host->ocr) - 1;
 	else
 		bit = fls(host->ocr_avail) - 1;
 	host->ios.vdd = bit;
 	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.power_mode = MMC_POWER_UP;
 	host->ios.bus_width = MMC_BUS_WIDTH_1;
 	host->ios.timing = MMC_TIMING_LEGACY;
 	mmc_set_ios(host);
 	/*
 	 * This delay should be sufficient to allow the power supply
 	 * to reach the minimum voltage.
 	 */
 	mmc_delay(10);
 	host->ios.clock = host->f_init;
 	host->ios.power_mode = MMC_POWER_ON;
 	mmc_set_ios(host);
 	/*
 	 * This delay must be at least 74 clock sizes, or 1 ms, or the
 	 * time required to reach a stable voltage.
 	 */
 	mmc_delay(10);
 	mmc_host_clk_release(host);
 }
 void mmc_power_off(struct mmc_host *host)
 {
 	int err = 0;
 	mmc_host_clk_hold(host);
 	host->ios.clock = 0;
 	host->ios.vdd = 0;
 	/*
 	 * For eMMC 4.5 device send AWAKE command before
 	 * POWER_OFF_NOTIFY command, because in sleep state
 	 * eMMC 4.5 devices respond to only RESET and AWAKE cmd
 	 */
 	if (host->card && mmc_card_is_sleep(host->card) &&
 	    host->bus_ops->resume) {
 		err = host->bus_ops->resume(host);
 		if (!err)
 			mmc_poweroff_notify(host);
 		else
 			pr_warning("%s: error %d during resume "
 				   "(continue with poweroff sequence)\n",
 				   mmc_hostname(host), err);
 	}
 	/*
 	 * 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);
 	if (!mmc_host_is_spi(host)) {
 		host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
 		host->ios.chip_select = MMC_CS_DONTCARE;
 	}
 	host->ios.power_mode = MMC_POWER_OFF;
 	host->ios.bus_width = MMC_BUS_WIDTH_1;
 	host->ios.timing = MMC_TIMING_LEGACY;
 	mmc_set_ios(host);
 	/*
 	 * 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);
 	mmc_host_clk_release(host);
 }
 /*
  * Cleanup when the last reference to the bus operator is dropped.
  */
 static void __mmc_release_bus(struct mmc_host *host)
 {
 	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);
 }
 /*
  * Assign a mmc bus handler to a host. Only one bus handler may control a
  * host at any given time.
  */
 void mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops)
 {
 	unsigned long flags;
 	BUG_ON(!host);
 	BUG_ON(!ops);
 	WARN_ON(!host->claimed);
 	spin_lock_irqsave(&host->lock, flags);
 	BUG_ON(host->bus_ops);
 	BUG_ON(host->bus_refs);
 	host->bus_ops = ops;
 	host->bus_refs = 1;
 	host->bus_dead = 0;
 	spin_unlock_irqrestore(&host->lock, flags);
 }
 /*
  * Remove the current bus handler from a host.
  */
 void mmc_detach_bus(struct mmc_host *host)
 {
 	unsigned long flags;
 	BUG_ON(!host);
 	WARN_ON(!host->claimed);
 	WARN_ON(!host->bus_ops);
 	spin_lock_irqsave(&host->lock, flags);
 	host->bus_dead = 1;
 	spin_unlock_irqrestore(&host->lock, flags);
 	mmc_bus_put(host);
 }
 /**
  *	mmc_detect_change - process change of state on a MMC socket
  *	@host: host which changed state.
  *	@delay: optional delay to wait before detection (jiffies)
  *
  *	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.
  */
 void mmc_detect_change(struct mmc_host *host, unsigned long delay)
 {
 #ifdef CONFIG_MMC_DEBUG
 	unsigned long flags;
 	spin_lock_irqsave(&host->lock, flags);
 	WARN_ON(host->removed);
 	spin_unlock_irqrestore(&host->lock, flags);
 #endif
 	host->detect_change = 1;
 	mmc_schedule_delayed_work(&host->detect, delay);
 }
 EXPORT_SYMBOL(mmc_detect_change);
 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;
 		}
 	}
 }
 static unsigned int mmc_mmc_erase_timeout(struct mmc_card *card,
 				          unsigned int arg, unsigned int qty)
 {
 	unsigned int erase_timeout;
 	if (card->ext_csd.erase_group_def & 1) {
 		/* High Capacity Erase Group Size uses HC timeouts */
 		if (arg == MMC_TRIM_ARG)
 			erase_timeout = card->ext_csd.trim_timeout;
 		else
 			erase_timeout = card->ext_csd.hc_erase_timeout;
 	} else {
 		/* CSD Erase Group Size uses write timeout */
 		unsigned int mult = (10 << card->csd.r2w_factor);
 		unsigned int timeout_clks = card->csd.tacc_clks * mult;
 		unsigned int timeout_us;
 		/* Avoid overflow: e.g. tacc_ns=80000000 mult=1280 */
 		if (card->csd.tacc_ns < 1000000)
 			timeout_us = (card->csd.tacc_ns * mult) / 1000;
 		else
 			timeout_us = (card->csd.tacc_ns / 1000) * mult;
 		/*
 		 * ios.clock is only a target.  The real clock rate might be
 		 * less but not that much less, so fudge it by multiplying by 2.
 		 */
 		timeout_clks <<= 1;
 		timeout_us += (timeout_clks * 1000) /
 			      (mmc_host_clk_rate(card->host) / 1000);
 		erase_timeout = timeout_us / 1000;
 		/*
 		 * Theoretically, the calculation could underflow so round up
 		 * to 1ms in that case.
 		 */
 		if (!erase_timeout)
 			erase_timeout = 1;
 	}
 	/* Multiplier for secure operations */
 	if (arg & MMC_SECURE_ARGS) {
 		if (arg == MMC_SECURE_ERASE_ARG)
 			erase_timeout *= card->ext_csd.sec_erase_mult;
 		else
 			erase_timeout *= card->ext_csd.sec_trim_mult;
 	}
 	erase_timeout *= qty;
 	/*
 	 * Ensure at least a 1 second timeout for SPI as per
 	 * 'mmc_set_data_timeout()'
 	 */
 	if (mmc_host_is_spi(card->host) && erase_timeout < 1000)
 		erase_timeout = 1000;
 	return erase_timeout;
 }
 static unsigned int mmc_sd_erase_timeout(struct mmc_card *card,
 					 unsigned int arg,
 					 unsigned int qty)
 {
 	unsigned int erase_timeout;
 	if (card->ssr.erase_timeout) {
 		/* Erase timeout specified in SD Status Register (SSR) */
 		erase_timeout = card->ssr.erase_timeout * qty +
 				card->ssr.erase_offset;
 	} else {
 		/*
 		 * Erase timeout not specified in SD Status Register (SSR) so
 		 * use 250ms per write block.
 		 */
 		erase_timeout = 250 * qty;
 	}
 	/* Must not be less than 1 second */
 	if (erase_timeout < 1000)
 		erase_timeout = 1000;
 	return erase_timeout;
 }
 static unsigned int mmc_erase_timeout(struct mmc_card *card,
 				      unsigned int arg,
 				      unsigned int qty)
 {
 	if (mmc_card_sd(card))
 		return mmc_sd_erase_timeout(card, arg, qty);
 	else
 		return mmc_mmc_erase_timeout(card, arg, qty);
 }
 static int mmc_do_erase(struct mmc_card *card, unsigned int from,
 			unsigned int to, unsigned int arg)
 {
 	struct mmc_command cmd = {0};
 	unsigned int qty = 0;
 	int err;
 	/*
 	 * qty is used to calculate the erase timeout which depends on how many
 	 * erase groups (or allocation units in SD terminology) are affected.
 	 * We count erasing part of an erase group as one erase group.
 	 * For SD, the allocation units are always a power of 2.  For MMC, the
 	 * erase group size is almost certainly also power of 2, but it does not
 	 * seem to insist on that in the JEDEC standard, so we fall back to
 	 * division in that case.  SD may not specify an allocation unit size,
 	 * in which case the timeout is based on the number of write blocks.
 	 *
 	 * Note that the timeout for secure trim 2 will only be correct if the
 	 * number of erase groups specified is the same as the total of all
 	 * preceding secure trim 1 commands.  Since the power may have been
 	 * lost since the secure trim 1 commands occurred, it is generally
 	 * impossible to calculate the secure trim 2 timeout correctly.
 	 */
 	if (card->erase_shift)
 		qty += ((to >> card->erase_shift) -
 			(from >> card->erase_shift)) + 1;
 	else if (mmc_card_sd(card))
 		qty += to - from + 1;
 	else
 		qty += ((to / card->erase_size) -
 			(from / card->erase_size)) + 1;
 	if (!mmc_card_blockaddr(card)) {
 		from <<= 9;
 		to <<= 9;
 	}
 	if (mmc_card_sd(card))
 		cmd.opcode = SD_ERASE_WR_BLK_START;
 	else
 		cmd.opcode = MMC_ERASE_GROUP_START;
 	cmd.arg = from;
 	cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
 	err = mmc_wait_for_cmd(card->host, &cmd, 0);
 	if (err) {
 		pr_err("mmc_erase: group start error %d, "
 		       "status %#x\n", err, cmd.resp[0]);
 		err = -EIO;
 		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) {
 		pr_err("mmc_erase: group end error %d, status %#x\n",
 		       err, cmd.resp[0]);
 		err = -EIO;
 		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;
 	cmd.cmd_timeout_ms = mmc_erase_timeout(card, arg, qty);
 	err = mmc_wait_for_cmd(card->host, &cmd, 0);
 	if (err) {
 		pr_err("mmc_erase: erase error %d, status %#x\n",
 		       err, cmd.resp[0]);
 		err = -EIO;
 		goto out;
 	}
 	if (mmc_host_is_spi(card->host))
 		goto out;
 	do {
 		memset(&cmd, 0, sizeof(struct mmc_command));
 		cmd.opcode = MMC_SEND_STATUS;
 		cmd.arg = card->rca << 16;
 		cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
 		/* Do not retry else we can't see errors */
 		err = mmc_wait_for_cmd(card->host, &cmd, 0);
 		if (err || (cmd.resp[0] & 0xFDF92000)) {
 			pr_err("error %d requesting status %#x\n",
 				err, cmd.resp[0]);
 			err = -EIO;
 			goto out;
 		}
 	} while (!(cmd.resp[0] & R1_READY_FOR_DATA) ||
 		 R1_CURRENT_STATE(cmd.resp[0]) == R1_STATE_PRG);
 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;
 	if (mmc_can_discard(card))
 		return 1;
 	return 0;
 }
 EXPORT_SYMBOL(mmc_can_trim);
 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);
 int mmc_can_sanitize(struct mmc_card *card)
 {
 	if (card->ext_csd.sec_feature_support & EXT_CSD_SEC_SANITIZE)
 		return 1;
 	return 0;
 }
 EXPORT_SYMBOL(mmc_can_sanitize);
 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);
 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);
 int mmc_set_blocklen(struct mmc_card *card, unsigned int blocklen)
 {
 	struct mmc_command cmd = {0};
 	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);
 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);
 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);
 	/*
 	 * 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);
+	/* Initialization should be done at 3.3 V I/O voltage. */
+	mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330, 0);
 	/*
 	 * 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.
 	 */
 	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;
 }
 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;
 	WARN_ON(!host->claimed);
 	/*
 	 * The card will be considered unchanged unless we have been asked to
 	 * detect a change or host requires polling to provide card detection.
 	 */
 	if (card && !host->detect_change && !(host->caps & MMC_CAP_NEEDS_POLL))
 		return mmc_card_removed(card);
 	host->detect_change = 0;
 	return _mmc_detect_card_removed(host);
 }
 EXPORT_SYMBOL(mmc_detect_card_removed);
 void mmc_rescan(struct work_struct *work)
 {
 	static const unsigned freqs[] = { 400000, 300000, 200000, 100000 };
 	struct mmc_host *host =
 		container_of(work, struct mmc_host, detect.work);
 	int i;
 	if (host->rescan_disable)
 		return;
 	mmc_bus_get(host);
 	/*
 	 * if there is a _removable_ card registered, check whether it is
 	 * still present
 	 */
 	if (host->bus_ops && host->bus_ops->detect && !host->bus_dead
 	    && !(host->caps & MMC_CAP_NONREMOVABLE))
 		host->bus_ops->detect(host);
 	host->detect_change = 0;
 	/*
 	 * Let mmc_bus_put() free the bus/bus_ops if we've found that
 	 * the card is no longer present.
 	 */
 	mmc_bus_put(host);
 	mmc_bus_get(host);
 	/* if there still is a card present, stop here */
 	if (host->bus_ops != NULL) {
 		mmc_bus_put(host);
 		goto out;
 	}
 	/*
 	 * Only we can add a new handler, so it's safe to
 	 * release the lock here.
 	 */
 	mmc_bus_put(host);
 	if (host->ops->get_cd && host->ops->get_cd(host) == 0)
 		goto out;
 	mmc_claim_host(host);
 	for (i = 0; i < ARRAY_SIZE(freqs); i++) {
 		if (!mmc_rescan_try_freq(host, max(freqs[i], host->f_min)))
 			break;
 		if (freqs[i] <= host->f_min)
 			break;
 	}
 	mmc_release_host(host);
  out:
 	if (host->caps & MMC_CAP_NEEDS_POLL)
 		mmc_schedule_delayed_work(&host->detect, HZ);
 }
 void mmc_start_host(struct mmc_host *host)
 {
 	mmc_power_off(host);
 	mmc_detect_change(host, 0);
 }
 void mmc_stop_host(struct mmc_host *host)
 {
 #ifdef CONFIG_MMC_DEBUG
 	unsigned long flags;
 	spin_lock_irqsave(&host->lock, flags);
 	host->removed = 1;
 	spin_unlock_irqrestore(&host->lock, flags);
 #endif
 	if (host->caps & MMC_CAP_DISABLE)
 		cancel_delayed_work(&host->disable);
 	cancel_delayed_work_sync(&host->detect);
 	mmc_flush_scheduled_work();
 	/* clear pm flags now and let card drivers set them as needed */
 	host->pm_flags = 0;
 	mmc_bus_get(host);
 	if (host->bus_ops && !host->bus_dead) {
 		/* 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);
 		mmc_bus_put(host);
 		return;
 	}
 	mmc_bus_put(host);
 	BUG_ON(host->card);
 	mmc_power_off(host);
 }
 int mmc_power_save_host(struct mmc_host *host)
 {
 	int ret = 0;
 #ifdef CONFIG_MMC_DEBUG
 	pr_info("%s: %s: powering down\n", mmc_hostname(host), __func__);
 #endif
 	mmc_bus_get(host);
 	if (!host->bus_ops || host->bus_dead || !host->bus_ops->power_restore) {
 		mmc_bus_put(host);
 		return -EINVAL;
 	}
 	if (host->bus_ops->power_save)
 		ret = host->bus_ops->power_save(host);
 	mmc_bus_put(host);
 	mmc_power_off(host);
 	return ret;
 }
 EXPORT_SYMBOL(mmc_power_save_host);
 int mmc_power_restore_host(struct mmc_host *host)
 {
 	int ret;
 #ifdef CONFIG_MMC_DEBUG
 	pr_info("%s: %s: powering up\n", mmc_hostname(host), __func__);
 #endif
 	mmc_bus_get(host);
 	if (!host->bus_ops || host->bus_dead || !host->bus_ops->power_restore) {
 		mmc_bus_put(host);
 		return -EINVAL;
 	}
 	mmc_power_up(host);
 	ret = host->bus_ops->power_restore(host);
 	mmc_bus_put(host);
 	return ret;
 }
 EXPORT_SYMBOL(mmc_power_restore_host);
 int mmc_card_awake(struct mmc_host *host)
 {
 	int err = -ENOSYS;
 	if (host->caps2 & MMC_CAP2_NO_SLEEP_CMD)
 		return 0;
 	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;
 	if (host->caps2 & MMC_CAP2_NO_SLEEP_CMD)
 		return 0;
 	mmc_bus_get(host);
 	if (host->bus_ops && !host->bus_dead && host->bus_ops->sleep)
 		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);
 /*
  * 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.
  */
 int mmc_cache_ctrl(struct mmc_host *host, u8 enable)
 {
 	struct mmc_card *card = host->card;
 	unsigned int timeout;
 	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;
 		if (card->ext_csd.cache_ctrl ^ enable) {
 			timeout = enable ? card->ext_csd.generic_cmd6_time : 0;
 			err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
 					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;
 		}
 	}
 	return err;
 }
 EXPORT_SYMBOL(mmc_cache_ctrl);
 #ifdef CONFIG_PM
 /**
  *	mmc_suspend_host - suspend a host
  *	@host: mmc host
  */
 int mmc_suspend_host(struct mmc_host *host)
 {
 	int err = 0;
 	if (host->caps & MMC_CAP_DISABLE)
 		cancel_delayed_work(&host->disable);
 	cancel_delayed_work(&host->detect);
 	mmc_flush_scheduled_work();
 	if (mmc_try_claim_host(host)) {
 		err = mmc_cache_ctrl(host, 0);
 		mmc_do_release_host(host);
 	} else {
 		err = -EBUSY;
 	}
 	if (err)
 		goto out;
 	mmc_bus_get(host);
 	if (host->bus_ops && !host->bus_dead) {
 		/*
 		 * A long response time is not acceptable for device drivers
 		 * when doing suspend. Prevent mmc_claim_host in the suspend
 		 * sequence, to potentially wait "forever" by trying to
 		 * pre-claim the host.
 		 */
 		if (mmc_try_claim_host(host)) {
 			if (host->bus_ops->suspend) {
 				err = host->bus_ops->suspend(host);
 			}
 			mmc_do_release_host(host);
 			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;
 			}
 		} else {
 			err = -EBUSY;
 		}
 	}
 	mmc_bus_put(host);
 	if (!err && !mmc_card_keep_power(host))
 		mmc_power_off(host);
 out:
 	return err;
 }
 EXPORT_SYMBOL(mmc_suspend_host);
 /**
  *	mmc_resume_host - resume a previously suspended host
  *	@host: mmc host
  */
 int mmc_resume_host(struct mmc_host *host)
 {
 	int err = 0;
 	mmc_bus_get(host);
 	if (host->bus_ops && !host->bus_dead) {
 		if (!mmc_card_keep_power(host)) {
 			mmc_power_up(host);
 			mmc_select_voltage(host, host->ocr);
 			/*
 			 * 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);
 			}
 		}
 		BUG_ON(!host->bus_ops->resume);
 		err = host->bus_ops->resume(host);
 		if (err) {
 			pr_warning("%s: error %d during resume "
 					    "(card was removed?)\n",
 					    mmc_hostname(host), err);
 			err = 0;
 		}
 	}
 	host->pm_flags &= ~MMC_PM_KEEP_POWER;
 	mmc_bus_put(host);
 	return err;
 }
 EXPORT_SYMBOL(mmc_resume_host);
 /* Do the card removal on suspend if card is assumed removeable
  * Do that in pm notifier while userspace isn't yet frozen, so we will be able
    to sync the card.
 */
 int mmc_pm_notify(struct notifier_block *notify_block,
 					unsigned long mode, void *unused)
 {
 	struct mmc_host *host = container_of(
 		notify_block, struct mmc_host, pm_notify);
 	unsigned long flags;
 	switch (mode) {
 	case PM_HIBERNATION_PREPARE:
 	case PM_SUSPEND_PREPARE:
 		spin_lock_irqsave(&host->lock, flags);
 		host->rescan_disable = 1;
 		host->power_notify_type = MMC_HOST_PW_NOTIFY_SHORT;
 		spin_unlock_irqrestore(&host->lock, flags);
 		cancel_delayed_work_sync(&host->detect);
 		if (!host->bus_ops || host->bus_ops->suspend)
 			break;
 		/* 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;
 		break;
 	case PM_POST_SUSPEND:
 	case PM_POST_HIBERNATION:
 	case PM_POST_RESTORE:
 		spin_lock_irqsave(&host->lock, flags);
 		host->rescan_disable = 0;
 		host->power_notify_type = MMC_HOST_PW_NOTIFY_LONG;
 		spin_unlock_irqrestore(&host->lock, flags);
 		mmc_detect_change(host, 0);
 	}
 	return 0;
 }
 #endif
 static int __init mmc_init(void)
 {
 	int ret;
 	workqueue = alloc_ordered_workqueue("kmmcd", 0);
 	if (!workqueue)
 		return -ENOMEM;
 	ret = mmc_register_bus();
 	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);
 	return ret;
 }
 static void __exit mmc_exit(void)
 {
 	sdio_unregister_bus();
 	mmc_unregister_host_class();
 	mmc_unregister_bus();
 	destroy_workqueue(workqueue);
 }
 subsys_initcall(mmc_init);
 module_exit(mmc_exit);
 MODULE_LICENSE("GPL");

drivers/mmc/core/mmc.c

Diff comments View file @ e774747

 /*
  *  linux/drivers/mmc/core/mmc.c
  *
  *  Copyright (C) 2003-2004 Russell King, All Rights Reserved.
  *  Copyright (C) 2005-2007 Pierre Ossman, All Rights Reserved.
  *  MMCv4 support Copyright (C) 2006 Philip Langdale, All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
 #include <linux/err.h>
 #include <linux/slab.h>
 #include <linux/stat.h>
 #include <linux/mmc/host.h>
 #include <linux/mmc/card.h>
 #include <linux/mmc/mmc.h>
 #include "core.h"
 #include "bus.h"
 #include "mmc_ops.h"
 #include "sd_ops.h"
 static const unsigned int tran_exp[] = {
 	10000,		100000,		1000000,	10000000,
 	0,		0,		0,		0
 };
 static const unsigned char tran_mant[] = {
 	0,	10,	12,	13,	15,	20,	25,	30,
 	35,	40,	45,	50,	55,	60,	70,	80,
 };
 static const unsigned int tacc_exp[] = {
 	1,	10,	100,	1000,	10000,	100000,	1000000, 10000000,
 };
 static const unsigned int tacc_mant[] = {
 	0,	10,	12,	13,	15,	20,	25,	30,
 	35,	40,	45,	50,	55,	60,	70,	80,
 };
 #define UNSTUFF_BITS(resp,start,size)					\
 	({								\
 		const int __size = size;				\
 		const u32 __mask = (__size < 32 ? 1 << __size : 0) - 1;	\
 		const int __off = 3 - ((start) / 32);			\
 		const int __shft = (start) & 31;			\
 		u32 __res;						\
 									\
 		__res = resp[__off] >> __shft;				\
 		if (__size + __shft > 32)				\
 			__res |= resp[__off-1] << ((32 - __shft) % 32);	\
 		__res & __mask;						\
 	})
 /*
  * Given the decoded CSD structure, decode the raw CID to our CID structure.
  */
 static int mmc_decode_cid(struct mmc_card *card)
 {
 	u32 *resp = card->raw_cid;
 	/*
 	 * The selection of the format here is based upon published
 	 * specs from sandisk and from what people have reported.
 	 */
 	switch (card->csd.mmca_vsn) {
 	case 0: /* MMC v1.0 - v1.2 */
 	case 1: /* MMC v1.4 */
 		card->cid.manfid	= UNSTUFF_BITS(resp, 104, 24);
 		card->cid.prod_name[0]	= UNSTUFF_BITS(resp, 96, 8);
 		card->cid.prod_name[1]	= UNSTUFF_BITS(resp, 88, 8);
 		card->cid.prod_name[2]	= UNSTUFF_BITS(resp, 80, 8);
 		card->cid.prod_name[3]	= UNSTUFF_BITS(resp, 72, 8);
 		card->cid.prod_name[4]	= UNSTUFF_BITS(resp, 64, 8);
 		card->cid.prod_name[5]	= UNSTUFF_BITS(resp, 56, 8);
 		card->cid.prod_name[6]	= UNSTUFF_BITS(resp, 48, 8);
 		card->cid.hwrev		= UNSTUFF_BITS(resp, 44, 4);
 		card->cid.fwrev		= UNSTUFF_BITS(resp, 40, 4);
 		card->cid.serial	= UNSTUFF_BITS(resp, 16, 24);
 		card->cid.month		= UNSTUFF_BITS(resp, 12, 4);
 		card->cid.year		= UNSTUFF_BITS(resp, 8, 4) + 1997;
 		break;
 	case 2: /* MMC v2.0 - v2.2 */
 	case 3: /* MMC v3.1 - v3.3 */
 	case 4: /* MMC v4 */
 		card->cid.manfid	= UNSTUFF_BITS(resp, 120, 8);
 		card->cid.oemid		= UNSTUFF_BITS(resp, 104, 16);
 		card->cid.prod_name[0]	= UNSTUFF_BITS(resp, 96, 8);
 		card->cid.prod_name[1]	= UNSTUFF_BITS(resp, 88, 8);
 		card->cid.prod_name[2]	= UNSTUFF_BITS(resp, 80, 8);
 		card->cid.prod_name[3]	= UNSTUFF_BITS(resp, 72, 8);
 		card->cid.prod_name[4]	= UNSTUFF_BITS(resp, 64, 8);
 		card->cid.prod_name[5]	= UNSTUFF_BITS(resp, 56, 8);
 		card->cid.serial	= UNSTUFF_BITS(resp, 16, 32);
 		card->cid.month		= UNSTUFF_BITS(resp, 12, 4);
 		card->cid.year		= UNSTUFF_BITS(resp, 8, 4) + 1997;
 		break;
 	default:
 		pr_err("%s: card has unknown MMCA version %d\n",
 			mmc_hostname(card->host), card->csd.mmca_vsn);
 		return -EINVAL;
 	}
 	return 0;
 }
 static void mmc_set_erase_size(struct mmc_card *card)
 {
 	if (card->ext_csd.erase_group_def & 1)
 		card->erase_size = card->ext_csd.hc_erase_size;
 	else
 		card->erase_size = card->csd.erase_size;
 	mmc_init_erase(card);
 }
 /*
  * Given a 128-bit response, decode to our card CSD structure.
  */
 static int mmc_decode_csd(struct mmc_card *card)
 {
 	struct mmc_csd *csd = &card->csd;
 	unsigned int e, m, a, b;
 	u32 *resp = card->raw_csd;
 	/*
 	 * We only understand CSD structure v1.1 and v1.2.
 	 * v1.2 has extra information in bits 15, 11 and 10.
 	 * We also support eMMC v4.4 & v4.41.
 	 */
 	csd->structure = UNSTUFF_BITS(resp, 126, 2);
 	if (csd->structure == 0) {
 		pr_err("%s: unrecognised CSD structure version %d\n",
 			mmc_hostname(card->host), csd->structure);
 		return -EINVAL;
 	}
 	csd->mmca_vsn	 = UNSTUFF_BITS(resp, 122, 4);
 	m = UNSTUFF_BITS(resp, 115, 4);
 	e = UNSTUFF_BITS(resp, 112, 3);
 	csd->tacc_ns	 = (tacc_exp[e] * tacc_mant[m] + 9) / 10;
 	csd->tacc_clks	 = UNSTUFF_BITS(resp, 104, 8) * 100;
 	m = UNSTUFF_BITS(resp, 99, 4);
 	e = UNSTUFF_BITS(resp, 96, 3);
 	csd->max_dtr	  = tran_exp[e] * tran_mant[m];
 	csd->cmdclass	  = UNSTUFF_BITS(resp, 84, 12);
 	e = UNSTUFF_BITS(resp, 47, 3);
 	m = UNSTUFF_BITS(resp, 62, 12);
 	csd->capacity	  = (1 + m) << (e + 2);
 	csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4);
 	csd->read_partial = UNSTUFF_BITS(resp, 79, 1);
 	csd->write_misalign = UNSTUFF_BITS(resp, 78, 1);
 	csd->read_misalign = UNSTUFF_BITS(resp, 77, 1);
 	csd->r2w_factor = UNSTUFF_BITS(resp, 26, 3);
 	csd->write_blkbits = UNSTUFF_BITS(resp, 22, 4);
 	csd->write_partial = UNSTUFF_BITS(resp, 21, 1);
 	if (csd->write_blkbits >= 9) {
 		a = UNSTUFF_BITS(resp, 42, 5);
 		b = UNSTUFF_BITS(resp, 37, 5);
 		csd->erase_size = (a + 1) * (b + 1);
 		csd->erase_size <<= csd->write_blkbits - 9;
 	}
 	return 0;
 }
 /*
  * Read extended CSD.
  */
 static int mmc_get_ext_csd(struct mmc_card *card, u8 **new_ext_csd)
 {
 	int err;
 	u8 *ext_csd;
 	BUG_ON(!card);
 	BUG_ON(!new_ext_csd);
 	*new_ext_csd = NULL;
 	if (card->csd.mmca_vsn < CSD_SPEC_VER_4)
 		return 0;
 	/*
 	 * As the ext_csd is so large and mostly unused, we don't store the
 	 * raw block in mmc_card.
 	 */
 	ext_csd = kmalloc(512, GFP_KERNEL);
 	if (!ext_csd) {
 		pr_err("%s: could not allocate a buffer to "
 			"receive the ext_csd.\n", mmc_hostname(card->host));
 		return -ENOMEM;
 	}
 	err = mmc_send_ext_csd(card, ext_csd);
 	if (err) {
 		kfree(ext_csd);
 		*new_ext_csd = NULL;
 		/* If the host or the card can't do the switch,
 		 * fail more gracefully. */
 		if ((err != -EINVAL)
 		 && (err != -ENOSYS)
 		 && (err != -EFAULT))
 			return err;
 		/*
 		 * High capacity cards should have this "magic" size
 		 * stored in their CSD.
 		 */
 		if (card->csd.capacity == (4096 * 512)) {
 			pr_err("%s: unable to read EXT_CSD "
 				"on a possible high capacity card. "
 				"Card will be ignored.\n",
 				mmc_hostname(card->host));
 		} else {
 			pr_warning("%s: unable to read "
 				"EXT_CSD, performance might "
 				"suffer.\n",
 				mmc_hostname(card->host));
 			err = 0;
 		}
 	} else
 		*new_ext_csd = ext_csd;
 	return err;
 }
 /*
  * Decode extended CSD.
  */
 static int mmc_read_ext_csd(struct mmc_card *card, u8 *ext_csd)
 {
 	int err = 0, idx;
 	unsigned int part_size;
 	u8 hc_erase_grp_sz = 0, hc_wp_grp_sz = 0;
 	BUG_ON(!card);
 	if (!ext_csd)
 		return 0;
 	/* Version is coded in the CSD_STRUCTURE byte in the EXT_CSD register */
 	card->ext_csd.raw_ext_csd_structure = ext_csd[EXT_CSD_STRUCTURE];
 	if (card->csd.structure == 3) {
 		if (card->ext_csd.raw_ext_csd_structure > 2) {
 			pr_err("%s: unrecognised EXT_CSD structure "
 				"version %d\n", mmc_hostname(card->host),
 					card->ext_csd.raw_ext_csd_structure);
 			err = -EINVAL;
 			goto out;
 		}
 	}
 	card->ext_csd.rev = ext_csd[EXT_CSD_REV];
 	if (card->ext_csd.rev > 6) {
 		pr_err("%s: unrecognised EXT_CSD revision %d\n",
 			mmc_hostname(card->host), card->ext_csd.rev);
 		err = -EINVAL;
 		goto out;
 	}
 	card->ext_csd.raw_sectors[0] = ext_csd[EXT_CSD_SEC_CNT + 0];
 	card->ext_csd.raw_sectors[1] = ext_csd[EXT_CSD_SEC_CNT + 1];
 	card->ext_csd.raw_sectors[2] = ext_csd[EXT_CSD_SEC_CNT + 2];
 	card->ext_csd.raw_sectors[3] = ext_csd[EXT_CSD_SEC_CNT + 3];
 	if (card->ext_csd.rev >= 2) {
 		card->ext_csd.sectors =
 			ext_csd[EXT_CSD_SEC_CNT + 0] << 0 |
 			ext_csd[EXT_CSD_SEC_CNT + 1] << 8 |
 			ext_csd[EXT_CSD_SEC_CNT + 2] << 16 |
 			ext_csd[EXT_CSD_SEC_CNT + 3] << 24;
 		/* Cards with density > 2GiB are sector addressed */
 		if (card->ext_csd.sectors > (2u * 1024 * 1024 * 1024) / 512)
 			mmc_card_set_blockaddr(card);
 	}
 	card->ext_csd.raw_card_type = ext_csd[EXT_CSD_CARD_TYPE];
 	switch (ext_csd[EXT_CSD_CARD_TYPE] & EXT_CSD_CARD_TYPE_MASK) {
 	case EXT_CSD_CARD_TYPE_SDR_ALL:
 	case EXT_CSD_CARD_TYPE_SDR_ALL_DDR_1_8V:
 	case EXT_CSD_CARD_TYPE_SDR_ALL_DDR_1_2V:
 	case EXT_CSD_CARD_TYPE_SDR_ALL_DDR_52:
 		card->ext_csd.hs_max_dtr = 200000000;
 		card->ext_csd.card_type = EXT_CSD_CARD_TYPE_SDR_200;
 		break;
 	case EXT_CSD_CARD_TYPE_SDR_1_2V_ALL:
 	case EXT_CSD_CARD_TYPE_SDR_1_2V_DDR_1_8V:
 	case EXT_CSD_CARD_TYPE_SDR_1_2V_DDR_1_2V:
 	case EXT_CSD_CARD_TYPE_SDR_1_2V_DDR_52:
 		card->ext_csd.hs_max_dtr = 200000000;
 		card->ext_csd.card_type = EXT_CSD_CARD_TYPE_SDR_1_2V;
 		break;
 	case EXT_CSD_CARD_TYPE_SDR_1_8V_ALL:
 	case EXT_CSD_CARD_TYPE_SDR_1_8V_DDR_1_8V:
 	case EXT_CSD_CARD_TYPE_SDR_1_8V_DDR_1_2V:
 	case EXT_CSD_CARD_TYPE_SDR_1_8V_DDR_52:
 		card->ext_csd.hs_max_dtr = 200000000;
 		card->ext_csd.card_type = EXT_CSD_CARD_TYPE_SDR_1_8V;
 		break;
 	case EXT_CSD_CARD_TYPE_DDR_52 | EXT_CSD_CARD_TYPE_52 |
 	     EXT_CSD_CARD_TYPE_26:
 		card->ext_csd.hs_max_dtr = 52000000;
 		card->ext_csd.card_type = EXT_CSD_CARD_TYPE_DDR_52;
 		break;
 	case EXT_CSD_CARD_TYPE_DDR_1_2V | EXT_CSD_CARD_TYPE_52 |
 	     EXT_CSD_CARD_TYPE_26:
 		card->ext_csd.hs_max_dtr = 52000000;
 		card->ext_csd.card_type = EXT_CSD_CARD_TYPE_DDR_1_2V;
 		break;
 	case EXT_CSD_CARD_TYPE_DDR_1_8V | EXT_CSD_CARD_TYPE_52 |
 	     EXT_CSD_CARD_TYPE_26:
 		card->ext_csd.hs_max_dtr = 52000000;
 		card->ext_csd.card_type = EXT_CSD_CARD_TYPE_DDR_1_8V;
 		break;
 	case EXT_CSD_CARD_TYPE_52 | EXT_CSD_CARD_TYPE_26:
 		card->ext_csd.hs_max_dtr = 52000000;
 		break;
 	case EXT_CSD_CARD_TYPE_26:
 		card->ext_csd.hs_max_dtr = 26000000;
 		break;
 	default:
 		/* MMC v4 spec says this cannot happen */
 		pr_warning("%s: card is mmc v4 but doesn't "
 			"support any high-speed modes.\n",
 			mmc_hostname(card->host));
 	}
 	card->ext_csd.raw_s_a_timeout = ext_csd[EXT_CSD_S_A_TIMEOUT];
 	card->ext_csd.raw_erase_timeout_mult =
 		ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT];
 	card->ext_csd.raw_hc_erase_grp_size =
 		ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
 	if (card->ext_csd.rev >= 3) {
 		u8 sa_shift = ext_csd[EXT_CSD_S_A_TIMEOUT];
 		card->ext_csd.part_config = ext_csd[EXT_CSD_PART_CONFIG];
 		/* EXT_CSD value is in units of 10ms, but we store in ms */
 		card->ext_csd.part_time = 10 * ext_csd[EXT_CSD_PART_SWITCH_TIME];
 		/* Sleep / awake timeout in 100ns units */
 		if (sa_shift > 0 && sa_shift <= 0x17)
 			card->ext_csd.sa_timeout =
 					1 << ext_csd[EXT_CSD_S_A_TIMEOUT];
 		card->ext_csd.erase_group_def =
 			ext_csd[EXT_CSD_ERASE_GROUP_DEF];
 		card->ext_csd.hc_erase_timeout = 300 *
 			ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT];
 		card->ext_csd.hc_erase_size =
 			ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] << 10;
 		card->ext_csd.rel_sectors = ext_csd[EXT_CSD_REL_WR_SEC_C];
 		/*
 		 * There are two boot regions of equal size, defined in
 		 * multiples of 128K.
 		 */
 		if (ext_csd[EXT_CSD_BOOT_MULT] && mmc_boot_partition_access(card->host)) {
 			for (idx = 0; idx < MMC_NUM_BOOT_PARTITION; idx++) {
 				part_size = ext_csd[EXT_CSD_BOOT_MULT] << 17;
 				mmc_part_add(card, part_size,
 					EXT_CSD_PART_CONFIG_ACC_BOOT0 + idx,
 					"boot%d", idx, true,
 					MMC_BLK_DATA_AREA_BOOT);
 			}
 		}
 	}
 	card->ext_csd.raw_hc_erase_gap_size =
 		ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
 	card->ext_csd.raw_sec_trim_mult =
 		ext_csd[EXT_CSD_SEC_TRIM_MULT];
 	card->ext_csd.raw_sec_erase_mult =
 		ext_csd[EXT_CSD_SEC_ERASE_MULT];
 	card->ext_csd.raw_sec_feature_support =
 		ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT];
 	card->ext_csd.raw_trim_mult =
 		ext_csd[EXT_CSD_TRIM_MULT];
 	if (card->ext_csd.rev >= 4) {
 		/*
 		 * Enhanced area feature support -- check whether the eMMC
 		 * card has the Enhanced area enabled.  If so, export enhanced
 		 * area offset and size to user by adding sysfs interface.
 		 */
 		card->ext_csd.raw_partition_support = ext_csd[EXT_CSD_PARTITION_SUPPORT];
 		if ((ext_csd[EXT_CSD_PARTITION_SUPPORT] & 0x2) &&
 		    (ext_csd[EXT_CSD_PARTITION_ATTRIBUTE] & 0x1)) {
 			hc_erase_grp_sz =
 				ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
 			hc_wp_grp_sz =
 				ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
 			card->ext_csd.enhanced_area_en = 1;
 			/*
 			 * calculate the enhanced data area offset, in bytes
 			 */
 			card->ext_csd.enhanced_area_offset =
 				(ext_csd[139] << 24) + (ext_csd[138] << 16) +
 				(ext_csd[137] << 8) + ext_csd[136];
 			if (mmc_card_blockaddr(card))
 				card->ext_csd.enhanced_area_offset <<= 9;
 			/*
 			 * calculate the enhanced data area size, in kilobytes
 			 */
 			card->ext_csd.enhanced_area_size =
 				(ext_csd[142] << 16) + (ext_csd[141] << 8) +
 				ext_csd[140];
 			card->ext_csd.enhanced_area_size *=
 				(size_t)(hc_erase_grp_sz * hc_wp_grp_sz);
 			card->ext_csd.enhanced_area_size <<= 9;
 		} else {
 			/*
 			 * If the enhanced area is not enabled, disable these
 			 * device attributes.
 			 */
 			card->ext_csd.enhanced_area_offset = -EINVAL;
 			card->ext_csd.enhanced_area_size = -EINVAL;
 		}
 		/*
 		 * General purpose partition feature support --
 		 * If ext_csd has the size of general purpose partitions,
 		 * set size, part_cfg, partition name in mmc_part.
 		 */
 		if (ext_csd[EXT_CSD_PARTITION_SUPPORT] &
 			EXT_CSD_PART_SUPPORT_PART_EN) {
 			if (card->ext_csd.enhanced_area_en != 1) {
 				hc_erase_grp_sz =
 					ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
 				hc_wp_grp_sz =
 					ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
 				card->ext_csd.enhanced_area_en = 1;
 			}
 			for (idx = 0; idx < MMC_NUM_GP_PARTITION; idx++) {
 				if (!ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3] &&
 				!ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 1] &&
 				!ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 2])
 					continue;
 				part_size =
 				(ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 2]
 					<< 16) +
 				(ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 1]
 					<< 8) +
 				ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3];
 				part_size *= (size_t)(hc_erase_grp_sz *
 					hc_wp_grp_sz);
 				mmc_part_add(card, part_size << 19,
 					EXT_CSD_PART_CONFIG_ACC_GP0 + idx,
 					"gp%d", idx, false,
 					MMC_BLK_DATA_AREA_GP);
 			}
 		}
 		card->ext_csd.sec_trim_mult =
 			ext_csd[EXT_CSD_SEC_TRIM_MULT];
 		card->ext_csd.sec_erase_mult =
 			ext_csd[EXT_CSD_SEC_ERASE_MULT];
 		card->ext_csd.sec_feature_support =
 			ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT];
 		card->ext_csd.trim_timeout = 300 *
 			ext_csd[EXT_CSD_TRIM_MULT];
 		/*
 		 * Note that the call to mmc_part_add above defaults to read
 		 * only. If this default assumption is changed, the call must
 		 * take into account the value of boot_locked below.
 		 */
 		card->ext_csd.boot_ro_lock = ext_csd[EXT_CSD_BOOT_WP];
 		card->ext_csd.boot_ro_lockable = true;
 	}
 	if (card->ext_csd.rev >= 5) {
 		/* check whether the eMMC card supports HPI */
 		if (ext_csd[EXT_CSD_HPI_FEATURES] & 0x1) {
 			card->ext_csd.hpi = 1;
 			if (ext_csd[EXT_CSD_HPI_FEATURES] & 0x2)
 				card->ext_csd.hpi_cmd =	MMC_STOP_TRANSMISSION;
 			else
 				card->ext_csd.hpi_cmd = MMC_SEND_STATUS;
 			/*
 			 * Indicate the maximum timeout to close
 			 * a command interrupted by HPI
 			 */
 			card->ext_csd.out_of_int_time =
 				ext_csd[EXT_CSD_OUT_OF_INTERRUPT_TIME] * 10;
 		}
 		card->ext_csd.rel_param = ext_csd[EXT_CSD_WR_REL_PARAM];
 		card->ext_csd.rst_n_function = ext_csd[EXT_CSD_RST_N_FUNCTION];
 	}
 	card->ext_csd.raw_erased_mem_count = ext_csd[EXT_CSD_ERASED_MEM_CONT];
 	if (ext_csd[EXT_CSD_ERASED_MEM_CONT])
 		card->erased_byte = 0xFF;
 	else
 		card->erased_byte = 0x0;
 	/* eMMC v4.5 or later */
 	if (card->ext_csd.rev >= 6) {
 		card->ext_csd.feature_support |= MMC_DISCARD_FEATURE;
 		card->ext_csd.generic_cmd6_time = 10 *
 			ext_csd[EXT_CSD_GENERIC_CMD6_TIME];
 		card->ext_csd.power_off_longtime = 10 *
 			ext_csd[EXT_CSD_POWER_OFF_LONG_TIME];
 		card->ext_csd.cache_size =
 			ext_csd[EXT_CSD_CACHE_SIZE + 0] << 0 |
 			ext_csd[EXT_CSD_CACHE_SIZE + 1] << 8 |
 			ext_csd[EXT_CSD_CACHE_SIZE + 2] << 16 |
 			ext_csd[EXT_CSD_CACHE_SIZE + 3] << 24;
 	}
 out:
 	return err;
 }
 static inline void mmc_free_ext_csd(u8 *ext_csd)
 {
 	kfree(ext_csd);
 }
 static int mmc_compare_ext_csds(struct mmc_card *card, unsigned bus_width)
 {
 	u8 *bw_ext_csd;
 	int err;
 	if (bus_width == MMC_BUS_WIDTH_1)
 		return 0;
 	err = mmc_get_ext_csd(card, &bw_ext_csd);
 	if (err || bw_ext_csd == NULL) {
 		if (bus_width != MMC_BUS_WIDTH_1)
 			err = -EINVAL;
 		goto out;
 	}
 	if (bus_width == MMC_BUS_WIDTH_1)
 		goto out;
 	/* only compare read only fields */
 	err = !((card->ext_csd.raw_partition_support ==
 			bw_ext_csd[EXT_CSD_PARTITION_SUPPORT]) &&
 		(card->ext_csd.raw_erased_mem_count ==
 			bw_ext_csd[EXT_CSD_ERASED_MEM_CONT]) &&
 		(card->ext_csd.rev ==
 			bw_ext_csd[EXT_CSD_REV]) &&
 		(card->ext_csd.raw_ext_csd_structure ==
 			bw_ext_csd[EXT_CSD_STRUCTURE]) &&
 		(card->ext_csd.raw_card_type ==
 			bw_ext_csd[EXT_CSD_CARD_TYPE]) &&
 		(card->ext_csd.raw_s_a_timeout ==
 			bw_ext_csd[EXT_CSD_S_A_TIMEOUT]) &&
 		(card->ext_csd.raw_hc_erase_gap_size ==
 			bw_ext_csd[EXT_CSD_HC_WP_GRP_SIZE]) &&
 		(card->ext_csd.raw_erase_timeout_mult ==
 			bw_ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT]) &&
 		(card->ext_csd.raw_hc_erase_grp_size ==
 			bw_ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]) &&
 		(card->ext_csd.raw_sec_trim_mult ==
 			bw_ext_csd[EXT_CSD_SEC_TRIM_MULT]) &&
 		(card->ext_csd.raw_sec_erase_mult ==
 			bw_ext_csd[EXT_CSD_SEC_ERASE_MULT]) &&
 		(card->ext_csd.raw_sec_feature_support ==
 			bw_ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT]) &&
 		(card->ext_csd.raw_trim_mult ==
 			bw_ext_csd[EXT_CSD_TRIM_MULT]) &&
 		(card->ext_csd.raw_sectors[0] ==
 			bw_ext_csd[EXT_CSD_SEC_CNT + 0]) &&
 		(card->ext_csd.raw_sectors[1] ==
 			bw_ext_csd[EXT_CSD_SEC_CNT + 1]) &&
 		(card->ext_csd.raw_sectors[2] ==
 			bw_ext_csd[EXT_CSD_SEC_CNT + 2]) &&
 		(card->ext_csd.raw_sectors[3] ==
 			bw_ext_csd[EXT_CSD_SEC_CNT + 3]));
 	if (err)
 		err = -EINVAL;
 out:
 	mmc_free_ext_csd(bw_ext_csd);
 	return err;
 }
 MMC_DEV_ATTR(cid, "%08x%08x%08x%08x\n", card->raw_cid[0], card->raw_cid[1],
 	card->raw_cid[2], card->raw_cid[3]);
 MMC_DEV_ATTR(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1],
 	card->raw_csd[2], card->raw_csd[3]);
 MMC_DEV_ATTR(date, "%02d/%04d\n", card->cid.month, card->cid.year);
 MMC_DEV_ATTR(erase_size, "%u\n", card->erase_size << 9);
 MMC_DEV_ATTR(preferred_erase_size, "%u\n", card->pref_erase << 9);
 MMC_DEV_ATTR(fwrev, "0x%x\n", card->cid.fwrev);
 MMC_DEV_ATTR(hwrev, "0x%x\n", card->cid.hwrev);
 MMC_DEV_ATTR(manfid, "0x%06x\n", card->cid.manfid);
 MMC_DEV_ATTR(name, "%s\n", card->cid.prod_name);
 MMC_DEV_ATTR(oemid, "0x%04x\n", card->cid.oemid);
 MMC_DEV_ATTR(serial, "0x%08x\n", card->cid.serial);
 MMC_DEV_ATTR(enhanced_area_offset, "%llu\n",
 		card->ext_csd.enhanced_area_offset);
 MMC_DEV_ATTR(enhanced_area_size, "%u\n", card->ext_csd.enhanced_area_size);
 static struct attribute *mmc_std_attrs[] = {
 	&dev_attr_cid.attr,
 	&dev_attr_csd.attr,
 	&dev_attr_date.attr,
 	&dev_attr_erase_size.attr,
 	&dev_attr_preferred_erase_size.attr,
 	&dev_attr_fwrev.attr,
 	&dev_attr_hwrev.attr,
 	&dev_attr_manfid.attr,
 	&dev_attr_name.attr,
 	&dev_attr_oemid.attr,
 	&dev_attr_serial.attr,
 	&dev_attr_enhanced_area_offset.attr,
 	&dev_attr_enhanced_area_size.attr,
 	NULL,
 };
 static struct attribute_group mmc_std_attr_group = {
 	.attrs = mmc_std_attrs,
 };
 static const struct attribute_group *mmc_attr_groups[] = {
 	&mmc_std_attr_group,
 	NULL,
 };
 static struct device_type mmc_type = {
 	.groups = mmc_attr_groups,
 };
 /*
  * Select the PowerClass for the current bus width
  * If power class is defined for 4/8 bit bus in the
  * extended CSD register, select it by executing the
  * mmc_switch command.
  */
 static int mmc_select_powerclass(struct mmc_card *card,
 		unsigned int bus_width, u8 *ext_csd)
 {
 	int err = 0;
 	unsigned int pwrclass_val;
 	unsigned int index = 0;
 	struct mmc_host *host;
 	BUG_ON(!card);
 	host = card->host;
 	BUG_ON(!host);
 	if (ext_csd == NULL)
 		return 0;
 	/* Power class selection is supported for versions >= 4.0 */
 	if (card->csd.mmca_vsn < CSD_SPEC_VER_4)
 		return 0;
 	/* Power class values are defined only for 4/8 bit bus */
 	if (bus_width == EXT_CSD_BUS_WIDTH_1)
 		return 0;
 	switch (1 << host->ios.vdd) {
 	case MMC_VDD_165_195:
 		if (host->ios.clock <= 26000000)
 			index = EXT_CSD_PWR_CL_26_195;
 		else if	(host->ios.clock <= 52000000)
 			index = (bus_width <= EXT_CSD_BUS_WIDTH_8) ?
 				EXT_CSD_PWR_CL_52_195 :
 				EXT_CSD_PWR_CL_DDR_52_195;
 		else if (host->ios.clock <= 200000000)
 			index = EXT_CSD_PWR_CL_200_195;
 		break;
 	case MMC_VDD_32_33:
 	case MMC_VDD_33_34:
 	case MMC_VDD_34_35:
 	case MMC_VDD_35_36:
 		if (host->ios.clock <= 26000000)
 			index = EXT_CSD_PWR_CL_26_360;
 		else if	(host->ios.clock <= 52000000)
 			index = (bus_width <= EXT_CSD_BUS_WIDTH_8) ?
 				EXT_CSD_PWR_CL_52_360 :
 				EXT_CSD_PWR_CL_DDR_52_360;
 		else if (host->ios.clock <= 200000000)
 			index = EXT_CSD_PWR_CL_200_360;
 		break;
 	default:
 		pr_warning("%s: Voltage range not supported "
 			   "for power class.\n", mmc_hostname(host));
 		return -EINVAL;
 	}
 	pwrclass_val = ext_csd[index];
 	if (bus_width & (EXT_CSD_BUS_WIDTH_8 | EXT_CSD_DDR_BUS_WIDTH_8))
 		pwrclass_val = (pwrclass_val & EXT_CSD_PWR_CL_8BIT_MASK) >>
 				EXT_CSD_PWR_CL_8BIT_SHIFT;
 	else
 		pwrclass_val = (pwrclass_val & EXT_CSD_PWR_CL_4BIT_MASK) >>
 				EXT_CSD_PWR_CL_4BIT_SHIFT;
 	/* If the power class is different from the default value */
 	if (pwrclass_val > 0) {
 		err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
 				 EXT_CSD_POWER_CLASS,
 				 pwrclass_val,
 				 card->ext_csd.generic_cmd6_time);
 	}
 	return err;
 }
 /*
  * Selects the desired buswidth and switch to the HS200 mode
  * if bus width set without error
  */
 static int mmc_select_hs200(struct mmc_card *card)
 {
 	int idx, err = 0;
 	struct mmc_host *host;
 	static unsigned ext_csd_bits[] = {
 		EXT_CSD_BUS_WIDTH_4,
 		EXT_CSD_BUS_WIDTH_8,
 	};
 	static unsigned bus_widths[] = {
 		MMC_BUS_WIDTH_4,
 		MMC_BUS_WIDTH_8,
 	};
 	BUG_ON(!card);
 	host = card->host;
 	if (card->ext_csd.card_type & EXT_CSD_CARD_TYPE_SDR_1_2V &&
 	    host->caps2 & MMC_CAP2_HS200_1_2V_SDR)
 		if (mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120, 0))
 			err = mmc_set_signal_voltage(host,
 						     MMC_SIGNAL_VOLTAGE_180, 0);
 	/* If fails try again during next card power cycle */
 	if (err)
 		goto err;
 	idx = (host->caps & MMC_CAP_8_BIT_DATA) ? 1 : 0;
 	/*
 	 * Unlike SD, MMC cards dont have a configuration register to notify
 	 * supported bus width. So bus test command should be run to identify
 	 * the supported bus width or compare the ext csd values of current
 	 * bus width and ext csd values of 1 bit mode read earlier.
 	 */
 	for (; idx >= 0; idx--) {
 		/*
 		 * Host is capable of 8bit transfer, then switch
 		 * the device to work in 8bit transfer mode. If the
 		 * mmc switch command returns error then switch to
 		 * 4bit transfer mode. On success set the corresponding
 		 * bus width on the host.
 		 */
 		err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
 				 EXT_CSD_BUS_WIDTH,
 				 ext_csd_bits[idx],
 				 card->ext_csd.generic_cmd6_time);
 		if (err)
 			continue;
 		mmc_set_bus_width(card->host, bus_widths[idx]);
 		if (!(host->caps & MMC_CAP_BUS_WIDTH_TEST))
 			err = mmc_compare_ext_csds(card, bus_widths[idx]);
 		else
 			err = mmc_bus_test(card, bus_widths[idx]);
 		if (!err)
 			break;
 	}
 	/* switch to HS200 mode if bus width set successfully */
 	if (!err)
 		err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
 				 EXT_CSD_HS_TIMING, 2, 0);
 err:
 	return err;
 }
 /*
  * Handle the detection and initialisation of a card.
  *
  * In the case of a resume, "oldcard" will contain the card
  * we're trying to reinitialise.
  */
 static int mmc_init_card(struct mmc_host *host, u32 ocr,
 	struct mmc_card *oldcard)
 {
 	struct mmc_card *card;
 	int err, ddr = 0;
 	u32 cid[4];
 	unsigned int max_dtr;
 	u32 rocr;
 	u8 *ext_csd = NULL;
 	BUG_ON(!host);
 	WARN_ON(!host->claimed);
 	/* Set correct bus mode for MMC before attempting init */
 	if (!mmc_host_is_spi(host))
 		mmc_set_bus_mode(host, MMC_BUSMODE_OPENDRAIN);
+	/* Initialization should be done at 3.3 V I/O voltage. */
+	mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330, 0);
 	/*
 	 * Since we're changing the OCR value, we seem to
 	 * need to tell some cards to go back to the idle
 	 * state.  We wait 1ms to give cards time to
 	 * respond.
 	 * mmc_go_idle is needed for eMMC that are asleep
 	 */
 	mmc_go_idle(host);
 	/* The extra bit indicates that we support high capacity */
 	err = mmc_send_op_cond(host, ocr | (1 << 30), &rocr);
 	if (err)
 		goto err;
 	/*
 	 * For SPI, enable CRC as appropriate.
 	 */
 	if (mmc_host_is_spi(host)) {
 		err = mmc_spi_set_crc(host, use_spi_crc);
 		if (err)
 			goto err;
 	}
 	/*
 	 * Fetch CID from card.
 	 */
 	if (mmc_host_is_spi(host))
 		err = mmc_send_cid(host, cid);
 	else
 		err = mmc_all_send_cid(host, cid);
 	if (err)
 		goto err;
 	if (oldcard) {
 		if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0) {
 			err = -ENOENT;
 			goto err;
 		}
 		card = oldcard;
 	} else {
 		/*
 		 * Allocate card structure.
 		 */
 		card = mmc_alloc_card(host, &mmc_type);
 		if (IS_ERR(card)) {
 			err = PTR_ERR(card);
 			goto err;
 		}
 		card->type = MMC_TYPE_MMC;
 		card->rca = 1;
 		memcpy(card->raw_cid, cid, sizeof(card->raw_cid));
 	}
 	/*
 	 * For native busses:  set card RCA and quit open drain mode.
 	 */
 	if (!mmc_host_is_spi(host)) {
 		err = mmc_set_relative_addr(card);
 		if (err)
 			goto free_card;
 		mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL);
 	}
 	if (!oldcard) {
 		/*
 		 * Fetch CSD from card.
 		 */
 		err = mmc_send_csd(card, card->raw_csd);
 		if (err)
 			goto free_card;
 		err = mmc_decode_csd(card);
 		if (err)
 			goto free_card;
 		err = mmc_decode_cid(card);
 		if (err)
 			goto free_card;
 	}
 	/*
 	 * Select card, as all following commands rely on that.
 	 */
 	if (!mmc_host_is_spi(host)) {
 		err = mmc_select_card(card);
 		if (err)
 			goto free_card;
 	}
 	if (!oldcard) {
 		/*
 		 * Fetch and process extended CSD.
 		 */
 		err = mmc_get_ext_csd(card, &ext_csd);
 		if (err)
 			goto free_card;
 		err = mmc_read_ext_csd(card, ext_csd);
 		if (err)
 			goto free_card;
 		/* If doing byte addressing, check if required to do sector
 		 * addressing.  Handle the case of <2GB cards needing sector
 		 * addressing.  See section 8.1 JEDEC Standard JED84-A441;
 		 * ocr register has bit 30 set for sector addressing.
 		 */
 		if (!(mmc_card_blockaddr(card)) && (rocr & (1<<30)))
 			mmc_card_set_blockaddr(card);
 		/* Erase size depends on CSD and Extended CSD */
 		mmc_set_erase_size(card);
 	}
 	/*
 	 * If enhanced_area_en is TRUE, host needs to enable ERASE_GRP_DEF
 	 * bit.  This bit will be lost every time after a reset or power off.
 	 */
 	if (card->ext_csd.enhanced_area_en) {
 		err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
 				 EXT_CSD_ERASE_GROUP_DEF, 1,
 				 card->ext_csd.generic_cmd6_time);
 		if (err && err != -EBADMSG)
 			goto free_card;
 		if (err) {
 			err = 0;
 			/*
 			 * Just disable enhanced area off & sz
 			 * will try to enable ERASE_GROUP_DEF
 			 * during next time reinit
 			 */
 			card->ext_csd.enhanced_area_offset = -EINVAL;
 			card->ext_csd.enhanced_area_size = -EINVAL;
 		} else {
 			card->ext_csd.erase_group_def = 1;
 			/*
 			 * enable ERASE_GRP_DEF successfully.
 			 * This will affect the erase size, so
 			 * here need to reset erase size
 			 */
 			mmc_set_erase_size(card);
 		}
 	}
 	/*
 	 * Ensure eMMC user default partition is enabled
 	 */
 	if (card->ext_csd.part_config & EXT_CSD_PART_CONFIG_ACC_MASK) {
 		card->ext_csd.part_config &= ~EXT_CSD_PART_CONFIG_ACC_MASK;
 		err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONFIG,
 				 card->ext_csd.part_config,
 				 card->ext_csd.part_time);
 		if (err && err != -EBADMSG)
 			goto free_card;
 	}
 	/*
 	 * If the host supports the power_off_notify capability then
 	 * set the notification byte in the ext_csd register of device
 	 */
 	if ((host->caps2 & MMC_CAP2_POWEROFF_NOTIFY) &&
 	    (card->ext_csd.rev >= 6)) {
 		err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
 				 EXT_CSD_POWER_OFF_NOTIFICATION,
 				 EXT_CSD_POWER_ON,
 				 card->ext_csd.generic_cmd6_time);
 		if (err && err != -EBADMSG)
 			goto free_card;
 		/*
 		 * The err can be -EBADMSG or 0,
 		 * so check for success and update the flag
 		 */
 		if (!err)
 			card->poweroff_notify_state = MMC_POWERED_ON;
 	}
 	/*
 	 * Activate high speed (if supported)
 	 */
 	if (card->ext_csd.hs_max_dtr != 0) {
 		err = 0;
 		if (card->ext_csd.hs_max_dtr > 52000000 &&
 		    host->caps2 & MMC_CAP2_HS200)
 			err = mmc_select_hs200(card);
 		else if	(host->caps & MMC_CAP_MMC_HIGHSPEED)
 			err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
 					 EXT_CSD_HS_TIMING, 1,
 					 card->ext_csd.generic_cmd6_time);
 		if (err && err != -EBADMSG)
 			goto free_card;
 		if (err) {
 			pr_warning("%s: switch to highspeed failed\n",
 			       mmc_hostname(card->host));
 			err = 0;
 		} else {
 			if (card->ext_csd.hs_max_dtr > 52000000 &&
 			    host->caps2 & MMC_CAP2_HS200) {
 				mmc_card_set_hs200(card);
 				mmc_set_timing(card->host,
 					       MMC_TIMING_MMC_HS200);
 			} else {
 				mmc_card_set_highspeed(card);
 				mmc_set_timing(card->host, MMC_TIMING_MMC_HS);
 			}
 		}
 	}
 	/*
 	 * Enable HPI feature (if supported)
 	 */
 	if (card->ext_csd.hpi) {
 		err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
 			EXT_CSD_HPI_MGMT, 1, 0);
 		if (err && err != -EBADMSG)
 			goto free_card;
 		if (err) {
 			pr_warning("%s: Enabling HPI failed\n",
 				   mmc_hostname(card->host));
 			err = 0;
 		} else
 			card->ext_csd.hpi_en = 1;
 	}
 	/*
 	 * Compute bus speed.
 	 */
 	max_dtr = (unsigned int)-1;
 	if (mmc_card_highspeed(card) || mmc_card_hs200(card)) {
 		if (max_dtr > card->ext_csd.hs_max_dtr)
 			max_dtr = card->ext_csd.hs_max_dtr;
 	} else if (max_dtr > card->csd.max_dtr) {
 		max_dtr = card->csd.max_dtr;
 	}
 	mmc_set_clock(host, max_dtr);
 	/*
 	 * Indicate DDR mode (if supported).
 	 */
 	if (mmc_card_highspeed(card)) {
 		if ((card->ext_csd.card_type & EXT_CSD_CARD_TYPE_DDR_1_8V)
 			&& ((host->caps & (MMC_CAP_1_8V_DDR |
 			     MMC_CAP_UHS_DDR50))
 				== (MMC_CAP_1_8V_DDR | MMC_CAP_UHS_DDR50)))
 				ddr = MMC_1_8V_DDR_MODE;
 		else if ((card->ext_csd.card_type & EXT_CSD_CARD_TYPE_DDR_1_2V)
 			&& ((host->caps & (MMC_CAP_1_2V_DDR |
 			     MMC_CAP_UHS_DDR50))
 				== (MMC_CAP_1_2V_DDR | MMC_CAP_UHS_DDR50)))
 				ddr = MMC_1_2V_DDR_MODE;
 	}
 	/*
 	 * Indicate HS200 SDR mode (if supported).
 	 */
 	if (mmc_card_hs200(card)) {
 		u32 ext_csd_bits;
 		u32 bus_width = card->host->ios.bus_width;
 		/*
 		 * For devices supporting HS200 mode, the bus width has
 		 * to be set before executing the tuning function. If
 		 * set before tuning, then device will respond with CRC
 		 * errors for responses on CMD line. So for HS200 the
 		 * sequence will be
 		 * 1. set bus width 4bit / 8 bit (1 bit not supported)
 		 * 2. switch to HS200 mode
 		 * 3. set the clock to > 52Mhz <=200MHz and
 		 * 4. execute tuning for HS200
 		 */
 		if ((host->caps2 & MMC_CAP2_HS200) &&
 		    card->host->ops->execute_tuning)
 			err = card->host->ops->execute_tuning(card->host,
 				MMC_SEND_TUNING_BLOCK_HS200);
 		if (err) {
 			pr_warning("%s: tuning execution failed\n",
 				   mmc_hostname(card->host));
 			goto err;
 		}
 		ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ?
 				EXT_CSD_BUS_WIDTH_8 : EXT_CSD_BUS_WIDTH_4;
 		err = mmc_select_powerclass(card, ext_csd_bits, ext_csd);
 		if (err) {
 			pr_err("%s: power class selection to bus width %d failed\n",
 				mmc_hostname(card->host), 1 << bus_width);
 			goto err;
 		}
 	}
 	/*
 	 * Activate wide bus and DDR (if supported).
 	 */
 	if (!mmc_card_hs200(card) &&
 	    (card->csd.mmca_vsn >= CSD_SPEC_VER_4) &&
 	    (host->caps & (MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA))) {
 		static unsigned ext_csd_bits[][2] = {
 			{ EXT_CSD_BUS_WIDTH_8, EXT_CSD_DDR_BUS_WIDTH_8 },
 			{ EXT_CSD_BUS_WIDTH_4, EXT_CSD_DDR_BUS_WIDTH_4 },
 			{ EXT_CSD_BUS_WIDTH_1, EXT_CSD_BUS_WIDTH_1 },
 		};
 		static unsigned bus_widths[] = {
 			MMC_BUS_WIDTH_8,
 			MMC_BUS_WIDTH_4,
 			MMC_BUS_WIDTH_1
 		};
 		unsigned idx, bus_width = 0;
 		if (host->caps & MMC_CAP_8_BIT_DATA)
 			idx = 0;
 		else
 			idx = 1;
 		for (; idx < ARRAY_SIZE(bus_widths); idx++) {
 			bus_width = bus_widths[idx];
 			if (bus_width == MMC_BUS_WIDTH_1)
 				ddr = 0; /* no DDR for 1-bit width */
 			err = mmc_select_powerclass(card, ext_csd_bits[idx][0],
 						    ext_csd);
 			if (err)
 				pr_err("%s: power class selection to "
 				       "bus width %d failed\n",
 				       mmc_hostname(card->host),
 				       1 << bus_width);
 			err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
 					 EXT_CSD_BUS_WIDTH,
 					 ext_csd_bits[idx][0],
 					 card->ext_csd.generic_cmd6_time);
 			if (!err) {
 				mmc_set_bus_width(card->host, bus_width);
 				/*
 				 * If controller can't handle bus width test,
 				 * compare ext_csd previously read in 1 bit mode
 				 * against ext_csd at new bus width
 				 */
 				if (!(host->caps & MMC_CAP_BUS_WIDTH_TEST))
 					err = mmc_compare_ext_csds(card,
 						bus_width);
 				else
 					err = mmc_bus_test(card, bus_width);
 				if (!err)
 					break;
 			}
 		}
 		if (!err && ddr) {
 			err = mmc_select_powerclass(card, ext_csd_bits[idx][1],
 						    ext_csd);
 			if (err)
 				pr_err("%s: power class selection to "
 				       "bus width %d ddr %d failed\n",
 				       mmc_hostname(card->host),
 				       1 << bus_width, ddr);
 			err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
 					 EXT_CSD_BUS_WIDTH,
 					 ext_csd_bits[idx][1],
 					 card->ext_csd.generic_cmd6_time);
 		}
 		if (err) {
 			pr_warning("%s: switch to bus width %d ddr %d "
 				"failed\n", mmc_hostname(card->host),
 				1 << bus_width, ddr);
 			goto free_card;
 		} else if (ddr) {
 			/*
 			 * eMMC cards can support 3.3V to 1.2V i/o (vccq)
 			 * signaling.
 			 *
 			 * EXT_CSD_CARD_TYPE_DDR_1_8V means 3.3V or 1.8V vccq.
 			 *
 			 * 1.8V vccq at 3.3V core voltage (vcc) is not required
 			 * in the JEDEC spec for DDR.
 			 *
 			 * Do not force change in vccq since we are obviously
 			 * working and no change to vccq is needed.
 			 *
 			 * WARNING: eMMC rules are NOT the same as SD DDR
 			 */
 			if (ddr == MMC_1_2V_DDR_MODE) {
 				err = mmc_set_signal_voltage(host,
 					MMC_SIGNAL_VOLTAGE_120, 0);
 				if (err)
 					goto err;
 			}
 			mmc_card_set_ddr_mode(card);
 			mmc_set_timing(card->host, MMC_TIMING_UHS_DDR50);
 			mmc_set_bus_width(card->host, bus_width);
 		}
 	}
 	/*
 	 * If cache size is higher than 0, this indicates
 	 * the existence of cache and it can be turned on.
 	 */
 	if ((host->caps2 & MMC_CAP2_CACHE_CTRL) &&
 			card->ext_csd.cache_size > 0) {
 		err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
 				EXT_CSD_CACHE_CTRL, 1,
 				card->ext_csd.generic_cmd6_time);
 		if (err && err != -EBADMSG)
 			goto free_card;
 		/*
 		 * Only if no error, cache is turned on successfully.
 		 */
 		if (err) {
 			pr_warning("%s: Cache is supported, "
 					"but failed to turn on (%d)\n",
 					mmc_hostname(card->host), err);
 			card->ext_csd.cache_ctrl = 0;
 			err = 0;
 		} else {
 			card->ext_csd.cache_ctrl = 1;
 		}
 	}
 	if (!oldcard)
 		host->card = card;
 	mmc_free_ext_csd(ext_csd);
 	return 0;
 free_card:
 	if (!oldcard)
 		mmc_remove_card(card);
 err:
 	mmc_free_ext_csd(ext_csd);
 	return err;
 }
 /*
  * Host is being removed. Free up the current card.
  */
 static void mmc_remove(struct mmc_host *host)
 {
 	BUG_ON(!host);
 	BUG_ON(!host->card);
 	mmc_remove_card(host->card);
 	host->card = NULL;
 }
 /*
  * Card detection - card is alive.
  */
 static int mmc_alive(struct mmc_host *host)
 {
 	return mmc_send_status(host->card, NULL);
 }
 /*
  * Card detection callback from host.
  */
 static void mmc_detect(struct mmc_host *host)
 {
 	int err;
 	BUG_ON(!host);
 	BUG_ON(!host->card);
 	mmc_claim_host(host);
 	/*
 	 * Just check if our card has been removed.
 	 */
 	err = _mmc_detect_card_removed(host);
 	mmc_release_host(host);
 	if (err) {
 		mmc_remove(host);
 		mmc_claim_host(host);
 		mmc_detach_bus(host);
 		mmc_power_off(host);
 		mmc_release_host(host);
 	}
 }
 /*
  * Suspend callback from host.
  */
 static int mmc_suspend(struct mmc_host *host)
 {
 	int err = 0;
 	BUG_ON(!host);
 	BUG_ON(!host->card);
 	mmc_claim_host(host);
 	if (mmc_card_can_sleep(host)) {
 		err = mmc_card_sleep(host);
 		if (!err)
 			mmc_card_set_sleep(host->card);
 	} else if (!mmc_host_is_spi(host))
 		mmc_deselect_cards(host);
 	host->card->state &= ~(MMC_STATE_HIGHSPEED | MMC_STATE_HIGHSPEED_200);
 	mmc_release_host(host);
 	return err;
 }
 /*
  * Resume callback from host.
  *
  * This function tries to determine if the same card is still present
  * and, if so, restore all state to it.
  */
 static int mmc_resume(struct mmc_host *host)
 {
 	int err;
 	BUG_ON(!host);
 	BUG_ON(!host->card);
 	mmc_claim_host(host);
 	if (mmc_card_is_sleep(host->card)) {
 		err = mmc_card_awake(host);
 		mmc_card_clr_sleep(host->card);
 	} else
 		err = mmc_init_card(host, host->ocr, host->card);
 	mmc_release_host(host);
 	return err;
 }
 static int mmc_power_restore(struct mmc_host *host)
 {
 	int ret;
 	host->card->state &= ~(MMC_STATE_HIGHSPEED | MMC_STATE_HIGHSPEED_200);
 	mmc_card_clr_sleep(host->card);
 	mmc_claim_host(host);
 	ret = mmc_init_card(host, host->ocr, host->card);
 	mmc_release_host(host);
 	return ret;
 }
 static int mmc_sleep(struct mmc_host *host)
 {
 	struct mmc_card *card = host->card;
 	int err = -ENOSYS;
 	if (card && card->ext_csd.rev >= 3) {
 		err = mmc_card_sleepawake(host, 1);
 		if (err < 0)
 			pr_debug("%s: Error %d while putting card into sleep",
 				 mmc_hostname(host), err);
 	}
 	return err;
 }
 static int mmc_awake(struct mmc_host *host)
 {
 	struct mmc_card *card = host->card;
 	int err = -ENOSYS;
 	if (card && card->ext_csd.rev >= 3) {
 		err = mmc_card_sleepawake(host, 0);
 		if (err < 0)
 			pr_debug("%s: Error %d while awaking sleeping card",
 				 mmc_hostname(host), err);
 	}
 	return err;
 }
 static const struct mmc_bus_ops mmc_ops = {
 	.awake = mmc_awake,
 	.sleep = mmc_sleep,
 	.remove = mmc_remove,
 	.detect = mmc_detect,
 	.suspend = NULL,
 	.resume = NULL,
 	.power_restore = mmc_power_restore,
 	.alive = mmc_alive,
 };
 static const struct mmc_bus_ops mmc_ops_unsafe = {
 	.awake = mmc_awake,
 	.sleep = mmc_sleep,
 	.remove = mmc_remove,
 	.detect = mmc_detect,
 	.suspend = mmc_suspend,
 	.resume = mmc_resume,
 	.power_restore = mmc_power_restore,
 	.alive = mmc_alive,
 };
 static void mmc_attach_bus_ops(struct mmc_host *host)
 {
 	const struct mmc_bus_ops *bus_ops;
 	if (!mmc_card_is_removable(host))
 		bus_ops = &mmc_ops_unsafe;
 	else
 		bus_ops = &mmc_ops;
 	mmc_attach_bus(host, bus_ops);
 }
 /*
  * Starting point for MMC card init.
  */
 int mmc_attach_mmc(struct mmc_host *host)
 {
 	int err;
 	u32 ocr;
 	BUG_ON(!host);
 	WARN_ON(!host->claimed);
 	/* Set correct bus mode for MMC before attempting attach */
 	if (!mmc_host_is_spi(host))
 		mmc_set_bus_mode(host, MMC_BUSMODE_OPENDRAIN);
 	err = mmc_send_op_cond(host, 0, &ocr);
 	if (err)
 		return err;
 	mmc_attach_bus_ops(host);
 	if (host->ocr_avail_mmc)
 		host->ocr_avail = host->ocr_avail_mmc;
 	/*
 	 * We need to get OCR a different way for SPI.
 	 */
 	if (mmc_host_is_spi(host)) {
 		err = mmc_spi_read_ocr(host, 1, &ocr);
 		if (err)
 			goto err;
 	}
 	/*
 	 * Sanity check the voltages that the card claims to
 	 * support.
 	 */
 	if (ocr & 0x7F) {
 		pr_warning("%s: card claims to support voltages "
 		       "below the defined range. These will be ignored.\n",
 		       mmc_hostname(host));
 		ocr &= ~0x7F;
 	}
 	host->ocr = mmc_select_voltage(host, ocr);
 	/*
 	 * Can we support the voltage of the card?
 	 */
 	if (!host->ocr) {
 		err = -EINVAL;
 		goto err;
 	}
 	/*
 	 * Detect and init the card.
 	 */
 	err = mmc_init_card(host, host->ocr, NULL);
 	if (err)
 		goto err;
 	mmc_release_host(host);
 	err = mmc_add_card(host->card);
 	mmc_claim_host(host);
 	if (err)
 		goto remove_card;
 	return 0;
 remove_card:
 	mmc_release_host(host);
 	mmc_remove_card(host->card);
 	mmc_claim_host(host);
 	host->card = NULL;
 err:
 	mmc_detach_bus(host);
 	pr_err("%s: error %d whilst initialising MMC card\n",
 		mmc_hostname(host), err);
 	return err;
 }

drivers/mmc/core/sd.c

Diff comments View file @ e774747

 /*
  *  linux/drivers/mmc/core/sd.c
  *
  *  Copyright (C) 2003-2004 Russell King, All Rights Reserved.
  *  SD support Copyright (C) 2004 Ian Molton, All Rights Reserved.
  *  Copyright (C) 2005-2007 Pierre Ossman, All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
 #include <linux/err.h>
 #include <linux/slab.h>
 #include <linux/stat.h>
 #include <linux/mmc/host.h>
 #include <linux/mmc/card.h>
 #include <linux/mmc/mmc.h>
 #include <linux/mmc/sd.h>
 #include "core.h"
 #include "bus.h"
 #include "mmc_ops.h"
 #include "sd.h"
 #include "sd_ops.h"
 static const unsigned int tran_exp[] = {
 	10000,		100000,		1000000,	10000000,
 	0,		0,		0,		0
 };
 static const unsigned char tran_mant[] = {
 	0,	10,	12,	13,	15,	20,	25,	30,
 	35,	40,	45,	50,	55,	60,	70,	80,
 };
 static const unsigned int tacc_exp[] = {
 	1,	10,	100,	1000,	10000,	100000,	1000000, 10000000,
 };
 static const unsigned int tacc_mant[] = {
 	0,	10,	12,	13,	15,	20,	25,	30,
 	35,	40,	45,	50,	55,	60,	70,	80,
 };
 #define UNSTUFF_BITS(resp,start,size)					\
 	({								\
 		const int __size = size;				\
 		const u32 __mask = (__size < 32 ? 1 << __size : 0) - 1;	\
 		const int __off = 3 - ((start) / 32);			\
 		const int __shft = (start) & 31;			\
 		u32 __res;						\
 									\
 		__res = resp[__off] >> __shft;				\
 		if (__size + __shft > 32)				\
 			__res |= resp[__off-1] << ((32 - __shft) % 32);	\
 		__res & __mask;						\
 	})
 /*
  * Given the decoded CSD structure, decode the raw CID to our CID structure.
  */
 void mmc_decode_cid(struct mmc_card *card)
 {
 	u32 *resp = card->raw_cid;
 	memset(&card->cid, 0, sizeof(struct mmc_cid));
 	/*
 	 * SD doesn't currently have a version field so we will
 	 * have to assume we can parse this.
 	 */
 	card->cid.manfid		= UNSTUFF_BITS(resp, 120, 8);
 	card->cid.oemid			= UNSTUFF_BITS(resp, 104, 16);
 	card->cid.prod_name[0]		= UNSTUFF_BITS(resp, 96, 8);
 	card->cid.prod_name[1]		= UNSTUFF_BITS(resp, 88, 8);
 	card->cid.prod_name[2]		= UNSTUFF_BITS(resp, 80, 8);
 	card->cid.prod_name[3]		= UNSTUFF_BITS(resp, 72, 8);
 	card->cid.prod_name[4]		= UNSTUFF_BITS(resp, 64, 8);
 	card->cid.hwrev			= UNSTUFF_BITS(resp, 60, 4);
 	card->cid.fwrev			= UNSTUFF_BITS(resp, 56, 4);
 	card->cid.serial		= UNSTUFF_BITS(resp, 24, 32);
 	card->cid.year			= UNSTUFF_BITS(resp, 12, 8);
 	card->cid.month			= UNSTUFF_BITS(resp, 8, 4);
 	card->cid.year += 2000; /* SD cards year offset */
 }
 /*
  * Given a 128-bit response, decode to our card CSD structure.
  */
 static int mmc_decode_csd(struct mmc_card *card)
 {
 	struct mmc_csd *csd = &card->csd;
 	unsigned int e, m, csd_struct;
 	u32 *resp = card->raw_csd;
 	csd_struct = UNSTUFF_BITS(resp, 126, 2);
 	switch (csd_struct) {
 	case 0:
 		m = UNSTUFF_BITS(resp, 115, 4);
 		e = UNSTUFF_BITS(resp, 112, 3);
 		csd->tacc_ns	 = (tacc_exp[e] * tacc_mant[m] + 9) / 10;
 		csd->tacc_clks	 = UNSTUFF_BITS(resp, 104, 8) * 100;
 		m = UNSTUFF_BITS(resp, 99, 4);
 		e = UNSTUFF_BITS(resp, 96, 3);
 		csd->max_dtr	  = tran_exp[e] * tran_mant[m];
 		csd->cmdclass	  = UNSTUFF_BITS(resp, 84, 12);
 		e = UNSTUFF_BITS(resp, 47, 3);
 		m = UNSTUFF_BITS(resp, 62, 12);
 		csd->capacity	  = (1 + m) << (e + 2);
 		csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4);
 		csd->read_partial = UNSTUFF_BITS(resp, 79, 1);
 		csd->write_misalign = UNSTUFF_BITS(resp, 78, 1);
 		csd->read_misalign = UNSTUFF_BITS(resp, 77, 1);
 		csd->r2w_factor = UNSTUFF_BITS(resp, 26, 3);
 		csd->write_blkbits = UNSTUFF_BITS(resp, 22, 4);
 		csd->write_partial = UNSTUFF_BITS(resp, 21, 1);
 		if (UNSTUFF_BITS(resp, 46, 1)) {
 			csd->erase_size = 1;
 		} else if (csd->write_blkbits >= 9) {
 			csd->erase_size = UNSTUFF_BITS(resp, 39, 7) + 1;
 			csd->erase_size <<= csd->write_blkbits - 9;
 		}
 		break;
 	case 1:
 		/*
 		 * This is a block-addressed SDHC or SDXC card. Most
 		 * interesting fields are unused and have fixed
 		 * values. To avoid getting tripped by buggy cards,
 		 * we assume those fixed values ourselves.
 		 */
 		mmc_card_set_blockaddr(card);
 		csd->tacc_ns	 = 0; /* Unused */
 		csd->tacc_clks	 = 0; /* Unused */
 		m = UNSTUFF_BITS(resp, 99, 4);
 		e = UNSTUFF_BITS(resp, 96, 3);
 		csd->max_dtr	  = tran_exp[e] * tran_mant[m];
 		csd->cmdclass	  = UNSTUFF_BITS(resp, 84, 12);
 		csd->c_size	  = UNSTUFF_BITS(resp, 48, 22);
 		/* SDXC cards have a minimum C_SIZE of 0x00FFFF */
 		if (csd->c_size >= 0xFFFF)
 			mmc_card_set_ext_capacity(card);
 		m = UNSTUFF_BITS(resp, 48, 22);
 		csd->capacity     = (1 + m) << 10;
 		csd->read_blkbits = 9;
 		csd->read_partial = 0;
 		csd->write_misalign = 0;
 		csd->read_misalign = 0;
 		csd->r2w_factor = 4; /* Unused */
 		csd->write_blkbits = 9;
 		csd->write_partial = 0;
 		csd->erase_size = 1;
 		break;
 	default:
 		pr_err("%s: unrecognised CSD structure version %d\n",
 			mmc_hostname(card->host), csd_struct);
 		return -EINVAL;
 	}
 	card->erase_size = csd->erase_size;
 	return 0;
 }
 /*
  * Given a 64-bit response, decode to our card SCR structure.
  */
 static int mmc_decode_scr(struct mmc_card *card)
 {
 	struct sd_scr *scr = &card->scr;
 	unsigned int scr_struct;
 	u32 resp[4];
 	resp[3] = card->raw_scr[1];
 	resp[2] = card->raw_scr[0];
 	scr_struct = UNSTUFF_BITS(resp, 60, 4);
 	if (scr_struct != 0) {
 		pr_err("%s: unrecognised SCR structure version %d\n",
 			mmc_hostname(card->host), scr_struct);
 		return -EINVAL;
 	}
 	scr->sda_vsn = UNSTUFF_BITS(resp, 56, 4);
 	scr->bus_widths = UNSTUFF_BITS(resp, 48, 4);
 	if (scr->sda_vsn == SCR_SPEC_VER_2)
 		/* Check if Physical Layer Spec v3.0 is supported */
 		scr->sda_spec3 = UNSTUFF_BITS(resp, 47, 1);
 	if (UNSTUFF_BITS(resp, 55, 1))
 		card->erased_byte = 0xFF;
 	else
 		card->erased_byte = 0x0;
 	if (scr->sda_spec3)
 		scr->cmds = UNSTUFF_BITS(resp, 32, 2);
 	return 0;
 }
 /*
  * Fetch and process SD Status register.
  */
 static int mmc_read_ssr(struct mmc_card *card)
 {
 	unsigned int au, es, et, eo;
 	int err, i;
 	u32 *ssr;
 	if (!(card->csd.cmdclass & CCC_APP_SPEC)) {
 		pr_warning("%s: card lacks mandatory SD Status "
 			"function.\n", mmc_hostname(card->host));
 		return 0;
 	}
 	ssr = kmalloc(64, GFP_KERNEL);
 	if (!ssr)
 		return -ENOMEM;
 	err = mmc_app_sd_status(card, ssr);
 	if (err) {
 		pr_warning("%s: problem reading SD Status "
 			"register.\n", mmc_hostname(card->host));
 		err = 0;
 		goto out;
 	}
 	for (i = 0; i < 16; i++)
 		ssr[i] = be32_to_cpu(ssr[i]);
 	/*
 	 * UNSTUFF_BITS only works with four u32s so we have to offset the
 	 * bitfield positions accordingly.
 	 */
 	au = UNSTUFF_BITS(ssr, 428 - 384, 4);
 	if (au > 0 || au <= 9) {
 		card->ssr.au = 1 << (au + 4);
 		es = UNSTUFF_BITS(ssr, 408 - 384, 16);
 		et = UNSTUFF_BITS(ssr, 402 - 384, 6);
 		eo = UNSTUFF_BITS(ssr, 400 - 384, 2);
 		if (es && et) {
 			card->ssr.erase_timeout = (et * 1000) / es;
 			card->ssr.erase_offset = eo * 1000;
 		}
 	} else {
 		pr_warning("%s: SD Status: Invalid Allocation Unit "
 			"size.\n", mmc_hostname(card->host));
 	}
 out:
 	kfree(ssr);
 	return err;
 }
 /*
  * Fetches and decodes switch information
  */
 static int mmc_read_switch(struct mmc_card *card)
 {
 	int err;
 	u8 *status;
 	if (card->scr.sda_vsn < SCR_SPEC_VER_1)
 		return 0;
 	if (!(card->csd.cmdclass & CCC_SWITCH)) {
 		pr_warning("%s: card lacks mandatory switch "
 			"function, performance might suffer.\n",
 			mmc_hostname(card->host));
 		return 0;
 	}
 	err = -EIO;
 	status = kmalloc(64, GFP_KERNEL);
 	if (!status) {
 		pr_err("%s: could not allocate a buffer for "
 			"switch capabilities.\n",
 			mmc_hostname(card->host));
 		return -ENOMEM;
 	}
 	/* Find out the supported Bus Speed Modes. */
 	err = mmc_sd_switch(card, 0, 0, 1, status);
 	if (err) {
 		/*
 		 * If the host or the card can't do the switch,
 		 * fail more gracefully.
 		 */
 		if (err != -EINVAL && err != -ENOSYS && err != -EFAULT)
 			goto out;
 		pr_warning("%s: problem reading Bus Speed modes.\n",
 			mmc_hostname(card->host));
 		err = 0;
 		goto out;
 	}
 	if (status[13] & SD_MODE_HIGH_SPEED)
 		card->sw_caps.hs_max_dtr = HIGH_SPEED_MAX_DTR;
 	if (card->scr.sda_spec3) {
 		card->sw_caps.sd3_bus_mode = status[13];
 		/* Find out Driver Strengths supported by the card */
 		err = mmc_sd_switch(card, 0, 2, 1, status);
 		if (err) {
 			/*
 			 * If the host or the card can't do the switch,
 			 * fail more gracefully.
 			 */
 			if (err != -EINVAL && err != -ENOSYS && err != -EFAULT)
 				goto out;
 			pr_warning("%s: problem reading "
 				"Driver Strength.\n",
 				mmc_hostname(card->host));
 			err = 0;
 			goto out;
 		}
 		card->sw_caps.sd3_drv_type = status[9];
 		/* Find out Current Limits supported by the card */
 		err = mmc_sd_switch(card, 0, 3, 1, status);
 		if (err) {
 			/*
 			 * If the host or the card can't do the switch,
 			 * fail more gracefully.
 			 */
 			if (err != -EINVAL && err != -ENOSYS && err != -EFAULT)
 				goto out;
 			pr_warning("%s: problem reading "
 				"Current Limit.\n",
 				mmc_hostname(card->host));
 			err = 0;
 			goto out;
 		}
 		card->sw_caps.sd3_curr_limit = status[7];
 	}
 out:
 	kfree(status);
 	return err;
 }
 /*
  * Test if the card supports high-speed mode and, if so, switch to it.
  */
 int mmc_sd_switch_hs(struct mmc_card *card)
 {
 	int err;
 	u8 *status;
 	if (card->scr.sda_vsn < SCR_SPEC_VER_1)
 		return 0;
 	if (!(card->csd.cmdclass & CCC_SWITCH))
 		return 0;
 	if (!(card->host->caps & MMC_CAP_SD_HIGHSPEED))
 		return 0;
 	if (card->sw_caps.hs_max_dtr == 0)
 		return 0;
 	err = -EIO;
 	status = kmalloc(64, GFP_KERNEL);
 	if (!status) {
 		pr_err("%s: could not allocate a buffer for "
 			"switch capabilities.\n", mmc_hostname(card->host));
 		return -ENOMEM;
 	}
 	err = mmc_sd_switch(card, 1, 0, 1, status);
 	if (err)
 		goto out;
 	if ((status[16] & 0xF) != 1) {
 		pr_warning("%s: Problem switching card "
 			"into high-speed mode!\n",
 			mmc_hostname(card->host));
 		err = 0;
 	} else {
 		err = 1;
 	}
 out:
 	kfree(status);
 	return err;
 }
 static int sd_select_driver_type(struct mmc_card *card, u8 *status)
 {
 	int host_drv_type = SD_DRIVER_TYPE_B;
 	int card_drv_type = SD_DRIVER_TYPE_B;
 	int drive_strength;
 	int err;
 	/*
 	 * If the host doesn't support any of the Driver Types A,C or D,
 	 * or there is no board specific handler then default Driver
 	 * Type B is used.
 	 */
 	if (!(card->host->caps & (MMC_CAP_DRIVER_TYPE_A | MMC_CAP_DRIVER_TYPE_C
 	    | MMC_CAP_DRIVER_TYPE_D)))
 		return 0;
 	if (!card->host->ops->select_drive_strength)
 		return 0;
 	if (card->host->caps & MMC_CAP_DRIVER_TYPE_A)
 		host_drv_type |= SD_DRIVER_TYPE_A;
 	if (card->host->caps & MMC_CAP_DRIVER_TYPE_C)
 		host_drv_type |= SD_DRIVER_TYPE_C;
 	if (card->host->caps & MMC_CAP_DRIVER_TYPE_D)
 		host_drv_type |= SD_DRIVER_TYPE_D;
 	if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_A)
 		card_drv_type |= SD_DRIVER_TYPE_A;
 	if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_C)
 		card_drv_type |= SD_DRIVER_TYPE_C;
 	if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_D)
 		card_drv_type |= SD_DRIVER_TYPE_D;
 	/*
 	 * The drive strength that the hardware can support
 	 * depends on the board design.  Pass the appropriate
 	 * information and let the hardware specific code
 	 * return what is possible given the options
 	 */
 	mmc_host_clk_hold(card->host);
 	drive_strength = card->host->ops->select_drive_strength(
 		card->sw_caps.uhs_max_dtr,
 		host_drv_type, card_drv_type);
 	mmc_host_clk_release(card->host);
 	err = mmc_sd_switch(card, 1, 2, drive_strength, status);
 	if (err)
 		return err;
 	if ((status[15] & 0xF) != drive_strength) {
 		pr_warning("%s: Problem setting drive strength!\n",
 			mmc_hostname(card->host));
 		return 0;
 	}
 	mmc_set_driver_type(card->host, drive_strength);
 	return 0;
 }
 static void sd_update_bus_speed_mode(struct mmc_card *card)
 {
 	/*
 	 * If the host doesn't support any of the UHS-I modes, fallback on
 	 * default speed.
 	 */
 	if (!(card->host->caps & (MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 |
 	    MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR104 | MMC_CAP_UHS_DDR50))) {
 		card->sd_bus_speed = 0;
 		return;
 	}
 	if ((card->host->caps & MMC_CAP_UHS_SDR104) &&
 	    (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR104)) {
 			card->sd_bus_speed = UHS_SDR104_BUS_SPEED;
 	} else if ((card->host->caps & MMC_CAP_UHS_DDR50) &&
 		   (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_DDR50)) {
 			card->sd_bus_speed = UHS_DDR50_BUS_SPEED;
 	} else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
 		    MMC_CAP_UHS_SDR50)) && (card->sw_caps.sd3_bus_mode &
 		    SD_MODE_UHS_SDR50)) {
 			card->sd_bus_speed = UHS_SDR50_BUS_SPEED;
 	} else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
 		    MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25)) &&
 		   (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR25)) {
 			card->sd_bus_speed = UHS_SDR25_BUS_SPEED;
 	} else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
 		    MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25 |
 		    MMC_CAP_UHS_SDR12)) && (card->sw_caps.sd3_bus_mode &
 		    SD_MODE_UHS_SDR12)) {
 			card->sd_bus_speed = UHS_SDR12_BUS_SPEED;
 	}
 }
 static int sd_set_bus_speed_mode(struct mmc_card *card, u8 *status)
 {
 	int err;
 	unsigned int timing = 0;
 	switch (card->sd_bus_speed) {
 	case UHS_SDR104_BUS_SPEED:
 		timing = MMC_TIMING_UHS_SDR104;
 		card->sw_caps.uhs_max_dtr = UHS_SDR104_MAX_DTR;
 		break;
 	case UHS_DDR50_BUS_SPEED:
 		timing = MMC_TIMING_UHS_DDR50;
 		card->sw_caps.uhs_max_dtr = UHS_DDR50_MAX_DTR;
 		break;
 	case UHS_SDR50_BUS_SPEED:
 		timing = MMC_TIMING_UHS_SDR50;
 		card->sw_caps.uhs_max_dtr = UHS_SDR50_MAX_DTR;
 		break;
 	case UHS_SDR25_BUS_SPEED:
 		timing = MMC_TIMING_UHS_SDR25;
 		card->sw_caps.uhs_max_dtr = UHS_SDR25_MAX_DTR;
 		break;
 	case UHS_SDR12_BUS_SPEED:
 		timing = MMC_TIMING_UHS_SDR12;
 		card->sw_caps.uhs_max_dtr = UHS_SDR12_MAX_DTR;
 		break;
 	default:
 		return 0;
 	}
 	err = mmc_sd_switch(card, 1, 0, card->sd_bus_speed, status);
 	if (err)
 		return err;
 	if ((status[16] & 0xF) != card->sd_bus_speed)
 		pr_warning("%s: Problem setting bus speed mode!\n",
 			mmc_hostname(card->host));
 	else {
 		mmc_set_timing(card->host, timing);
 		mmc_set_clock(card->host, card->sw_caps.uhs_max_dtr);
 	}
 	return 0;
 }
 static int sd_set_current_limit(struct mmc_card *card, u8 *status)
 {
 	int current_limit = 0;
 	int err;
 	/*
 	 * Current limit switch is only defined for SDR50, SDR104, and DDR50
 	 * bus speed modes. For other bus speed modes, we set the default
 	 * current limit of 200mA.
 	 */
 	if ((card->sd_bus_speed == UHS_SDR50_BUS_SPEED) ||
 	    (card->sd_bus_speed == UHS_SDR104_BUS_SPEED) ||
 	    (card->sd_bus_speed == UHS_DDR50_BUS_SPEED)) {
 		if (card->host->caps & MMC_CAP_MAX_CURRENT_800) {
 			if (card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_800)
 				current_limit = SD_SET_CURRENT_LIMIT_800;
 			else if (card->sw_caps.sd3_curr_limit &
 					SD_MAX_CURRENT_600)
 				current_limit = SD_SET_CURRENT_LIMIT_600;
 			else if (card->sw_caps.sd3_curr_limit &
 					SD_MAX_CURRENT_400)
 				current_limit = SD_SET_CURRENT_LIMIT_400;
 			else if (card->sw_caps.sd3_curr_limit &
 					SD_MAX_CURRENT_200)
 				current_limit = SD_SET_CURRENT_LIMIT_200;
 		} else if (card->host->caps & MMC_CAP_MAX_CURRENT_600) {
 			if (card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_600)
 				current_limit = SD_SET_CURRENT_LIMIT_600;
 			else if (card->sw_caps.sd3_curr_limit &
 					SD_MAX_CURRENT_400)
 				current_limit = SD_SET_CURRENT_LIMIT_400;
 			else if (card->sw_caps.sd3_curr_limit &
 					SD_MAX_CURRENT_200)
 				current_limit = SD_SET_CURRENT_LIMIT_200;
 		} else if (card->host->caps & MMC_CAP_MAX_CURRENT_400) {
 			if (card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_400)
 				current_limit = SD_SET_CURRENT_LIMIT_400;
 			else if (card->sw_caps.sd3_curr_limit &
 					SD_MAX_CURRENT_200)
 				current_limit = SD_SET_CURRENT_LIMIT_200;
 		} else if (card->host->caps & MMC_CAP_MAX_CURRENT_200) {
 			if (card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_200)
 				current_limit = SD_SET_CURRENT_LIMIT_200;
 		}
 	} else
 		current_limit = SD_SET_CURRENT_LIMIT_200;
 	err = mmc_sd_switch(card, 1, 3, current_limit, status);
 	if (err)
 		return err;
 	if (((status[15] >> 4) & 0x0F) != current_limit)
 		pr_warning("%s: Problem setting current limit!\n",
 			mmc_hostname(card->host));
 	return 0;
 }
 /*
  * UHS-I specific initialization procedure
  */
 static int mmc_sd_init_uhs_card(struct mmc_card *card)
 {
 	int err;
 	u8 *status;
 	if (!card->scr.sda_spec3)
 		return 0;
 	if (!(card->csd.cmdclass & CCC_SWITCH))
 		return 0;
 	status = kmalloc(64, GFP_KERNEL);
 	if (!status) {
 		pr_err("%s: could not allocate a buffer for "
 			"switch capabilities.\n", mmc_hostname(card->host));
 		return -ENOMEM;
 	}
 	/* Set 4-bit bus width */
 	if ((card->host->caps & MMC_CAP_4_BIT_DATA) &&
 	    (card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {
 		err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
 		if (err)
 			goto out;
 		mmc_set_bus_width(card->host, MMC_BUS_WIDTH_4);
 	}
 	/*
 	 * Select the bus speed mode depending on host
 	 * and card capability.
 	 */
 	sd_update_bus_speed_mode(card);
 	/* Set the driver strength for the card */
 	err = sd_select_driver_type(card, status);
 	if (err)
 		goto out;
 	/* Set current limit for the card */
 	err = sd_set_current_limit(card, status);
 	if (err)
 		goto out;
 	/* Set bus speed mode of the card */
 	err = sd_set_bus_speed_mode(card, status);
 	if (err)
 		goto out;
 	/* SPI mode doesn't define CMD19 */
 	if (!mmc_host_is_spi(card->host) && card->host->ops->execute_tuning) {
 		mmc_host_clk_hold(card->host);
 		err = card->host->ops->execute_tuning(card->host,
 						      MMC_SEND_TUNING_BLOCK);
 		mmc_host_clk_release(card->host);
 	}
 out:
 	kfree(status);
 	return err;
 }
 MMC_DEV_ATTR(cid, "%08x%08x%08x%08x\n", card->raw_cid[0], card->raw_cid[1],
 	card->raw_cid[2], card->raw_cid[3]);
 MMC_DEV_ATTR(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1],
 	card->raw_csd[2], card->raw_csd[3]);
 MMC_DEV_ATTR(scr, "%08x%08x\n", card->raw_scr[0], card->raw_scr[1]);
 MMC_DEV_ATTR(date, "%02d/%04d\n", card->cid.month, card->cid.year);
 MMC_DEV_ATTR(erase_size, "%u\n", card->erase_size << 9);
 MMC_DEV_ATTR(preferred_erase_size, "%u\n", card->pref_erase << 9);
 MMC_DEV_ATTR(fwrev, "0x%x\n", card->cid.fwrev);
 MMC_DEV_ATTR(hwrev, "0x%x\n", card->cid.hwrev);
 MMC_DEV_ATTR(manfid, "0x%06x\n", card->cid.manfid);
 MMC_DEV_ATTR(name, "%s\n", card->cid.prod_name);
 MMC_DEV_ATTR(oemid, "0x%04x\n", card->cid.oemid);
 MMC_DEV_ATTR(serial, "0x%08x\n", card->cid.serial);
 static struct attribute *sd_std_attrs[] = {
 	&dev_attr_cid.attr,
 	&dev_attr_csd.attr,
 	&dev_attr_scr.attr,
 	&dev_attr_date.attr,
 	&dev_attr_erase_size.attr,
 	&dev_attr_preferred_erase_size.attr,
 	&dev_attr_fwrev.attr,
 	&dev_attr_hwrev.attr,
 	&dev_attr_manfid.attr,
 	&dev_attr_name.attr,
 	&dev_attr_oemid.attr,
 	&dev_attr_serial.attr,
 	NULL,
 };
 static struct attribute_group sd_std_attr_group = {
 	.attrs = sd_std_attrs,
 };
 static const struct attribute_group *sd_attr_groups[] = {
 	&sd_std_attr_group,
 	NULL,
 };
 struct device_type sd_type = {
 	.groups = sd_attr_groups,
 };
 /*
  * Fetch CID from card.
  */
 int mmc_sd_get_cid(struct mmc_host *host, u32 ocr, u32 *cid, u32 *rocr)
 {
 	int err;
 	/*
 	 * Since we're changing the OCR value, we seem to
 	 * need to tell some cards to go back to the idle
 	 * state.  We wait 1ms to give cards time to
 	 * respond.
 	 */
 	mmc_go_idle(host);
 	/*
 	 * If SD_SEND_IF_COND indicates an SD 2.0
 	 * compliant card and we should set bit 30
 	 * of the ocr to indicate that we can handle
 	 * block-addressed SDHC cards.
 	 */
 	err = mmc_send_if_cond(host, ocr);
 	if (!err)
 		ocr |= SD_OCR_CCS;
 	/*
 	 * If the host supports one of UHS-I modes, request the card
 	 * to switch to 1.8V signaling level.
 	 */
 	if (host->caps & (MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 |
 	    MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR104 | MMC_CAP_UHS_DDR50))
 		ocr |= SD_OCR_S18R;
 	/* If the host can supply more than 150mA, XPC should be set to 1. */
 	if (host->caps & (MMC_CAP_SET_XPC_330 | MMC_CAP_SET_XPC_300 |
 	    MMC_CAP_SET_XPC_180))
 		ocr |= SD_OCR_XPC;
 try_again:
 	err = mmc_send_app_op_cond(host, ocr, rocr);
 	if (err)
 		return err;
 	/*
 	 * In case CCS and S18A in the response is set, start Signal Voltage
 	 * Switch procedure. SPI mode doesn't support CMD11.
 	 */
 	if (!mmc_host_is_spi(host) && rocr &&
 	   ((*rocr & 0x41000000) == 0x41000000)) {
 		err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180, true);
 		if (err) {
 			ocr &= ~SD_OCR_S18R;
 			goto try_again;
 		}
 	}
 	if (mmc_host_is_spi(host))
 		err = mmc_send_cid(host, cid);
 	else
 		err = mmc_all_send_cid(host, cid);
 	return err;
 }
 int mmc_sd_get_csd(struct mmc_host *host, struct mmc_card *card)
 {
 	int err;
 	/*
 	 * Fetch CSD from card.
 	 */
 	err = mmc_send_csd(card, card->raw_csd);
 	if (err)
 		return err;
 	err = mmc_decode_csd(card);
 	if (err)
 		return err;
 	return 0;
 }
 int mmc_sd_setup_card(struct mmc_host *host, struct mmc_card *card,
 	bool reinit)
 {
 	int err;
 	if (!reinit) {
 		/*
 		 * Fetch SCR from card.
 		 */
 		err = mmc_app_send_scr(card, card->raw_scr);
 		if (err)
 			return err;
 		err = mmc_decode_scr(card);
 		if (err)
 			return err;
 		/*
 		 * Fetch and process SD Status register.
 		 */
 		err = mmc_read_ssr(card);
 		if (err)
 			return err;
 		/* Erase init depends on CSD and SSR */
 		mmc_init_erase(card);
 		/*
 		 * Fetch switch information from card.
 		 */
 		err = mmc_read_switch(card);
 		if (err)
 			return err;
 	}
 	/*
 	 * For SPI, enable CRC as appropriate.
 	 * This CRC enable is located AFTER the reading of the
 	 * card registers because some SDHC cards are not able
 	 * to provide valid CRCs for non-512-byte blocks.
 	 */
 	if (mmc_host_is_spi(host)) {
 		err = mmc_spi_set_crc(host, use_spi_crc);
 		if (err)
 			return err;
 	}
 	/*
 	 * Check if read-only switch is active.
 	 */
 	if (!reinit) {
 		int ro = -1;
 		if (host->ops->get_ro) {
 			mmc_host_clk_hold(card->host);
 			ro = host->ops->get_ro(host);
 			mmc_host_clk_release(card->host);
 		}
 		if (ro < 0) {
 			pr_warning("%s: host does not "
 				"support reading read-only "
 				"switch. assuming write-enable.\n",
 				mmc_hostname(host));
 		} else if (ro > 0) {
 			mmc_card_set_readonly(card);
 		}
 	}
 	return 0;
 }
 unsigned mmc_sd_get_max_clock(struct mmc_card *card)
 {
 	unsigned max_dtr = (unsigned int)-1;
 	if (mmc_card_highspeed(card)) {
 		if (max_dtr > card->sw_caps.hs_max_dtr)
 			max_dtr = card->sw_caps.hs_max_dtr;
 	} else if (max_dtr > card->csd.max_dtr) {
 		max_dtr = card->csd.max_dtr;
 	}
 	return max_dtr;
 }
 void mmc_sd_go_highspeed(struct mmc_card *card)
 {
 	mmc_card_set_highspeed(card);
 	mmc_set_timing(card->host, MMC_TIMING_SD_HS);
 }
 /*
  * Handle the detection and initialisation of a card.
  *
  * In the case of a resume, "oldcard" will contain the card
  * we're trying to reinitialise.
  */
 static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
 	struct mmc_card *oldcard)
 {
 	struct mmc_card *card;
 	int err;
 	u32 cid[4];
 	u32 rocr = 0;
 	BUG_ON(!host);
 	WARN_ON(!host->claimed);
+	/* The initialization should be done at 3.3 V I/O voltage. */
+	mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330, 0);
 	err = mmc_sd_get_cid(host, ocr, cid, &rocr);
 	if (err)
 		return err;
 	if (oldcard) {
 		if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0)
 			return -ENOENT;
 		card = oldcard;
 	} else {
 		/*
 		 * Allocate card structure.
 		 */
 		card = mmc_alloc_card(host, &sd_type);
 		if (IS_ERR(card))
 			return PTR_ERR(card);
 		card->type = MMC_TYPE_SD;
 		memcpy(card->raw_cid, cid, sizeof(card->raw_cid));
 	}
 	/*
 	 * For native busses:  get card RCA and quit open drain mode.
 	 */
 	if (!mmc_host_is_spi(host)) {
 		err = mmc_send_relative_addr(host, &card->rca);
 		if (err)
 			return err;
 	}
 	if (!oldcard) {
 		err = mmc_sd_get_csd(host, card);
 		if (err)
 			return err;
 		mmc_decode_cid(card);
 	}
 	/*
 	 * Select card, as all following commands rely on that.
 	 */
 	if (!mmc_host_is_spi(host)) {
 		err = mmc_select_card(card);
 		if (err)
 			return err;
 	}
 	err = mmc_sd_setup_card(host, card, oldcard != NULL);
 	if (err)
 		goto free_card;
 	/* Initialization sequence for UHS-I cards */
 	if (rocr & SD_ROCR_S18A) {
 		err = mmc_sd_init_uhs_card(card);
 		if (err)
 			goto free_card;
 		/* Card is an ultra-high-speed card */
 		mmc_card_set_uhs(card);
 		/*
 		 * Since initialization is now complete, enable preset
 		 * value registers for UHS-I cards.
 		 */
 		if (host->ops->enable_preset_value) {
 			mmc_host_clk_hold(card->host);
 			host->ops->enable_preset_value(host, true);
 			mmc_host_clk_release(card->host);
 		}
 	} else {
 		/*
 		 * Attempt to change to high-speed (if supported)
 		 */
 		err = mmc_sd_switch_hs(card);
 		if (err > 0)
 			mmc_sd_go_highspeed(card);
 		else if (err)
 			goto free_card;
 		/*
 		 * Set bus speed.
 		 */
 		mmc_set_clock(host, mmc_sd_get_max_clock(card));
 		/*
 		 * Switch to wider bus (if supported).
 		 */
 		if ((host->caps & MMC_CAP_4_BIT_DATA) &&
 			(card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {
 			err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
 			if (err)
 				goto free_card;
 			mmc_set_bus_width(host, MMC_BUS_WIDTH_4);
 		}
 	}
 	host->card = card;
 	return 0;
 free_card:
 	if (!oldcard)
 		mmc_remove_card(card);
 	return err;
 }
 /*
  * Host is being removed. Free up the current card.
  */
 static void mmc_sd_remove(struct mmc_host *host)
 {
 	BUG_ON(!host);
 	BUG_ON(!host->card);
 	mmc_remove_card(host->card);
 	host->card = NULL;
 }
 /*
  * Card detection - card is alive.
  */
 static int mmc_sd_alive(struct mmc_host *host)
 {
 	return mmc_send_status(host->card, NULL);
 }
 /*
  * Card detection callback from host.
  */
 static void mmc_sd_detect(struct mmc_host *host)
 {
 	int err;
 	BUG_ON(!host);
 	BUG_ON(!host->card);
 	mmc_claim_host(host);
 	/*
 	 * Just check if our card has been removed.
 	 */
 	err = _mmc_detect_card_removed(host);
 	mmc_release_host(host);
 	if (err) {
 		mmc_sd_remove(host);
 		mmc_claim_host(host);
 		mmc_detach_bus(host);
 		mmc_power_off(host);
 		mmc_release_host(host);
 	}
 }
 /*
  * Suspend callback from host.
  */
 static int mmc_sd_suspend(struct mmc_host *host)
 {
 	BUG_ON(!host);
 	BUG_ON(!host->card);
 	mmc_claim_host(host);
 	if (!mmc_host_is_spi(host))
 		mmc_deselect_cards(host);
 	host->card->state &= ~MMC_STATE_HIGHSPEED;
 	mmc_release_host(host);
 	return 0;
 }
 /*
  * Resume callback from host.
  *
  * This function tries to determine if the same card is still present
  * and, if so, restore all state to it.
  */
 static int mmc_sd_resume(struct mmc_host *host)
 {
 	int err;
 	BUG_ON(!host);
 	BUG_ON(!host->card);
 	mmc_claim_host(host);
 	err = mmc_sd_init_card(host, host->ocr, host->card);
 	mmc_release_host(host);
 	return err;
 }
 static int mmc_sd_power_restore(struct mmc_host *host)
 {
 	int ret;
 	host->card->state &= ~MMC_STATE_HIGHSPEED;
 	mmc_claim_host(host);
 	ret = mmc_sd_init_card(host, host->ocr, host->card);
 	mmc_release_host(host);
 	return ret;
 }
 static const struct mmc_bus_ops mmc_sd_ops = {
 	.remove = mmc_sd_remove,
 	.detect = mmc_sd_detect,
 	.suspend = NULL,
 	.resume = NULL,
 	.power_restore = mmc_sd_power_restore,
 	.alive = mmc_sd_alive,
 };
 static const struct mmc_bus_ops mmc_sd_ops_unsafe = {
 	.remove = mmc_sd_remove,
 	.detect = mmc_sd_detect,
 	.suspend = mmc_sd_suspend,
 	.resume = mmc_sd_resume,
 	.power_restore = mmc_sd_power_restore,
 	.alive = mmc_sd_alive,
 };
 static void mmc_sd_attach_bus_ops(struct mmc_host *host)
 {
 	const struct mmc_bus_ops *bus_ops;
 	if (!mmc_card_is_removable(host))
 		bus_ops = &mmc_sd_ops_unsafe;
 	else
 		bus_ops = &mmc_sd_ops;
 	mmc_attach_bus(host, bus_ops);
 }
 /*
  * Starting point for SD card init.
  */
 int mmc_attach_sd(struct mmc_host *host)
 {
 	int err;
 	u32 ocr;
 	BUG_ON(!host);
 	WARN_ON(!host->claimed);
-	/* Make sure we are at 3.3V signalling voltage */
-	err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330, false);
-	if (err)
-		return err;
 	/* Disable preset value enable if already set since last time */
 	if (host->ops->enable_preset_value) {
 		mmc_host_clk_hold(host);
 		host->ops->enable_preset_value(host, false);
 		mmc_host_clk_release(host);
 	}
 	err = mmc_send_app_op_cond(host, 0, &ocr);
 	if (err)
 		return err;
 	mmc_sd_attach_bus_ops(host);
 	if (host->ocr_avail_sd)
 		host->ocr_avail = host->ocr_avail_sd;
 	/*
 	 * We need to get OCR a different way for SPI.
 	 */
 	if (mmc_host_is_spi(host)) {
 		mmc_go_idle(host);
 		err = mmc_spi_read_ocr(host, 0, &ocr);
 		if (err)
 			goto err;
 	}
 	/*
 	 * Sanity check the voltages that the card claims to
 	 * support.
 	 */
 	if (ocr & 0x7F) {
 		pr_warning("%s: card claims to support voltages "
 		       "below the defined range. These will be ignored.\n",
 		       mmc_hostname(host));
 		ocr &= ~0x7F;
 	}
 	if ((ocr & MMC_VDD_165_195) &&
 	    !(host->ocr_avail_sd & MMC_VDD_165_195)) {
 		pr_warning("%s: SD card claims to support the "
 		       "incompletely defined 'low voltage range'. This "
 		       "will be ignored.\n", mmc_hostname(host));
 		ocr &= ~MMC_VDD_165_195;
 	}
 	host->ocr = mmc_select_voltage(host, ocr);
 	/*
 	 * Can we support the voltage(s) of the card(s)?
 	 */
 	if (!host->ocr) {
 		err = -EINVAL;
 		goto err;
 	}
 	/*
 	 * Detect and init the card.
 	 */
 	err = mmc_sd_init_card(host, host->ocr, NULL);
 	if (err)
 		goto err;
 	mmc_release_host(host);
 	err = mmc_add_card(host->card);
 	mmc_claim_host(host);
 	if (err)
 		goto remove_card;
 	return 0;
 remove_card:
 	mmc_release_host(host);
 	mmc_remove_card(host->card);
 	host->card = NULL;
 	mmc_claim_host(host);
 err:
 	mmc_detach_bus(host);
 	pr_err("%s: error %d whilst initialising SD card\n",
 		mmc_hostname(host), err);
 	return err;

drivers/mmc/core/sdio.c

Diff comments View file @ e774747

 /*
  *  linux/drivers/mmc/sdio.c
  *
  *  Copyright 2006-2007 Pierre Ossman
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or (at
  * your option) any later version.
  */
 #include <linux/err.h>
 #include <linux/pm_runtime.h>
 #include <linux/mmc/host.h>
 #include <linux/mmc/card.h>
 #include <linux/mmc/mmc.h>
 #include <linux/mmc/sdio.h>
 #include <linux/mmc/sdio_func.h>
 #include <linux/mmc/sdio_ids.h>
 #include "core.h"
 #include "bus.h"
 #include "sd.h"
 #include "sdio_bus.h"
 #include "mmc_ops.h"
 #include "sd_ops.h"
 #include "sdio_ops.h"
 #include "sdio_cis.h"
 static int sdio_read_fbr(struct sdio_func *func)
 {
 	int ret;
 	unsigned char data;
 	if (mmc_card_nonstd_func_interface(func->card)) {
 		func->class = SDIO_CLASS_NONE;
 		return 0;
 	}
 	ret = mmc_io_rw_direct(func->card, 0, 0,
 		SDIO_FBR_BASE(func->num) + SDIO_FBR_STD_IF, 0, &data);
 	if (ret)
 		goto out;
 	data &= 0x0f;
 	if (data == 0x0f) {
 		ret = mmc_io_rw_direct(func->card, 0, 0,
 			SDIO_FBR_BASE(func->num) + SDIO_FBR_STD_IF_EXT, 0, &data);
 		if (ret)
 			goto out;
 	}
 	func->class = data;
 out:
 	return ret;
 }
 static int sdio_init_func(struct mmc_card *card, unsigned int fn)
 {
 	int ret;
 	struct sdio_func *func;
 	BUG_ON(fn > SDIO_MAX_FUNCS);
 	func = sdio_alloc_func(card);
 	if (IS_ERR(func))
 		return PTR_ERR(func);
 	func->num = fn;
 	if (!(card->quirks & MMC_QUIRK_NONSTD_SDIO)) {
 		ret = sdio_read_fbr(func);
 		if (ret)
 			goto fail;
 		ret = sdio_read_func_cis(func);
 		if (ret)
 			goto fail;
 	} else {
 		func->vendor = func->card->cis.vendor;
 		func->device = func->card->cis.device;
 		func->max_blksize = func->card->cis.blksize;
 	}
 	card->sdio_func[fn - 1] = func;
 	return 0;
 fail:
 	/*
 	 * It is okay to remove the function here even though we hold
 	 * the host lock as we haven't registered the device yet.
 	 */
 	sdio_remove_func(func);
 	return ret;
 }
 static int sdio_read_cccr(struct mmc_card *card, u32 ocr)
 {
 	int ret;
 	int cccr_vsn;
 	int uhs = ocr & R4_18V_PRESENT;
 	unsigned char data;
 	unsigned char speed;
 	memset(&card->cccr, 0, sizeof(struct sdio_cccr));
 	ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_CCCR, 0, &data);
 	if (ret)
 		goto out;
 	cccr_vsn = data & 0x0f;
 	if (cccr_vsn > SDIO_CCCR_REV_3_00) {
 		pr_err("%s: unrecognised CCCR structure version %d\n",
 			mmc_hostname(card->host), cccr_vsn);
 		return -EINVAL;
 	}
 	card->cccr.sdio_vsn = (data & 0xf0) >> 4;
 	ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_CAPS, 0, &data);
 	if (ret)
 		goto out;
 	if (data & SDIO_CCCR_CAP_SMB)
 		card->cccr.multi_block = 1;
 	if (data & SDIO_CCCR_CAP_LSC)
 		card->cccr.low_speed = 1;
 	if (data & SDIO_CCCR_CAP_4BLS)
 		card->cccr.wide_bus = 1;
 	if (cccr_vsn >= SDIO_CCCR_REV_1_10) {
 		ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_POWER, 0, &data);
 		if (ret)
 			goto out;
 		if (data & SDIO_POWER_SMPC)
 			card->cccr.high_power = 1;
 	}
 	if (cccr_vsn >= SDIO_CCCR_REV_1_20) {
 		ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_SPEED, 0, &speed);
 		if (ret)
 			goto out;
 		card->scr.sda_spec3 = 0;
 		card->sw_caps.sd3_bus_mode = 0;
 		card->sw_caps.sd3_drv_type = 0;
 		if (cccr_vsn >= SDIO_CCCR_REV_3_00 && uhs) {
 			card->scr.sda_spec3 = 1;
 			ret = mmc_io_rw_direct(card, 0, 0,
 				SDIO_CCCR_UHS, 0, &data);
 			if (ret)
 				goto out;
 			if (card->host->caps &
 				(MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 |
 				 MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR104 |
 				 MMC_CAP_UHS_DDR50)) {
 				if (data & SDIO_UHS_DDR50)
 					card->sw_caps.sd3_bus_mode
 						|= SD_MODE_UHS_DDR50;
 				if (data & SDIO_UHS_SDR50)
 					card->sw_caps.sd3_bus_mode
 						|= SD_MODE_UHS_SDR50;
 				if (data & SDIO_UHS_SDR104)
 					card->sw_caps.sd3_bus_mode
 						|= SD_MODE_UHS_SDR104;
 			}
 			ret = mmc_io_rw_direct(card, 0, 0,
 				SDIO_CCCR_DRIVE_STRENGTH, 0, &data);
 			if (ret)
 				goto out;
 			if (data & SDIO_DRIVE_SDTA)
 				card->sw_caps.sd3_drv_type |= SD_DRIVER_TYPE_A;
 			if (data & SDIO_DRIVE_SDTC)
 				card->sw_caps.sd3_drv_type |= SD_DRIVER_TYPE_C;
 			if (data & SDIO_DRIVE_SDTD)
 				card->sw_caps.sd3_drv_type |= SD_DRIVER_TYPE_D;
 		}
 		/* if no uhs mode ensure we check for high speed */
 		if (!card->sw_caps.sd3_bus_mode) {
 			if (speed & SDIO_SPEED_SHS) {
 				card->cccr.high_speed = 1;
 				card->sw_caps.hs_max_dtr = 50000000;
 			} else {
 				card->cccr.high_speed = 0;
 				card->sw_caps.hs_max_dtr = 25000000;
 			}
 		}
 	}
 out:
 	return ret;
 }
 static int sdio_enable_wide(struct mmc_card *card)
 {
 	int ret;
 	u8 ctrl;
 	if (!(card->host->caps & MMC_CAP_4_BIT_DATA))
 		return 0;
 	if (card->cccr.low_speed && !card->cccr.wide_bus)
 		return 0;
 	ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_IF, 0, &ctrl);
 	if (ret)
 		return ret;
 	ctrl |= SDIO_BUS_WIDTH_4BIT;
 	ret = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_IF, ctrl, NULL);
 	if (ret)
 		return ret;
 	return 1;
 }
 /*
  * If desired, disconnect the pull-up resistor on CD/DAT[3] (pin 1)
  * of the card. This may be required on certain setups of boards,
  * controllers and embedded sdio device which do not need the card's
  * pull-up. As a result, card detection is disabled and power is saved.
  */
 static int sdio_disable_cd(struct mmc_card *card)
 {
 	int ret;
 	u8 ctrl;
 	if (!mmc_card_disable_cd(card))
 		return 0;
 	ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_IF, 0, &ctrl);
 	if (ret)
 		return ret;
 	ctrl |= SDIO_BUS_CD_DISABLE;
 	return mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_IF, ctrl, NULL);
 }
 /*
  * Devices that remain active during a system suspend are
  * put back into 1-bit mode.
  */
 static int sdio_disable_wide(struct mmc_card *card)
 {
 	int ret;
 	u8 ctrl;
 	if (!(card->host->caps & MMC_CAP_4_BIT_DATA))
 		return 0;
 	if (card->cccr.low_speed && !card->cccr.wide_bus)
 		return 0;
 	ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_IF, 0, &ctrl);
 	if (ret)
 		return ret;
 	if (!(ctrl & SDIO_BUS_WIDTH_4BIT))
 		return 0;
 	ctrl &= ~SDIO_BUS_WIDTH_4BIT;
 	ctrl |= SDIO_BUS_ASYNC_INT;
 	ret = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_IF, ctrl, NULL);
 	if (ret)
 		return ret;
 	mmc_set_bus_width(card->host, MMC_BUS_WIDTH_1);
 	return 0;
 }
 static int sdio_enable_4bit_bus(struct mmc_card *card)
 {
 	int err;
 	if (card->type == MMC_TYPE_SDIO)
 		return sdio_enable_wide(card);
 	if ((card->host->caps & MMC_CAP_4_BIT_DATA) &&
 		(card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {
 		err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
 		if (err)
 			return err;
 	} else
 		return 0;
 	err = sdio_enable_wide(card);
 	if (err <= 0)
 		mmc_app_set_bus_width(card, MMC_BUS_WIDTH_1);
 	return err;
 }
 /*
  * Test if the card supports high-speed mode and, if so, switch to it.
  */
 static int mmc_sdio_switch_hs(struct mmc_card *card, int enable)
 {
 	int ret;
 	u8 speed;
 	if (!(card->host->caps & MMC_CAP_SD_HIGHSPEED))
 		return 0;
 	if (!card->cccr.high_speed)
 		return 0;
 	ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_SPEED, 0, &speed);
 	if (ret)
 		return ret;
 	if (enable)
 		speed |= SDIO_SPEED_EHS;
 	else
 		speed &= ~SDIO_SPEED_EHS;
 	ret = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_SPEED, speed, NULL);
 	if (ret)
 		return ret;
 	return 1;
 }
 /*
  * Enable SDIO/combo card's high-speed mode. Return 0/1 if [not]supported.
  */
 static int sdio_enable_hs(struct mmc_card *card)
 {
 	int ret;
 	ret = mmc_sdio_switch_hs(card, true);
 	if (ret <= 0 || card->type == MMC_TYPE_SDIO)
 		return ret;
 	ret = mmc_sd_switch_hs(card);
 	if (ret <= 0)
 		mmc_sdio_switch_hs(card, false);
 	return ret;
 }
 static unsigned mmc_sdio_get_max_clock(struct mmc_card *card)
 {
 	unsigned max_dtr;
 	if (mmc_card_highspeed(card)) {
 		/*
 		 * The SDIO specification doesn't mention how
 		 * the CIS transfer speed register relates to
 		 * high-speed, but it seems that 50 MHz is
 		 * mandatory.
 		 */
 		max_dtr = 50000000;
 	} else {
 		max_dtr = card->cis.max_dtr;
 	}
 	if (card->type == MMC_TYPE_SD_COMBO)
 		max_dtr = min(max_dtr, mmc_sd_get_max_clock(card));
 	return max_dtr;
 }
 static unsigned char host_drive_to_sdio_drive(int host_strength)
 {
 	switch (host_strength) {
 	case MMC_SET_DRIVER_TYPE_A:
 		return SDIO_DTSx_SET_TYPE_A;
 	case MMC_SET_DRIVER_TYPE_B:
 		return SDIO_DTSx_SET_TYPE_B;
 	case MMC_SET_DRIVER_TYPE_C:
 		return SDIO_DTSx_SET_TYPE_C;
 	case MMC_SET_DRIVER_TYPE_D:
 		return SDIO_DTSx_SET_TYPE_D;
 	default:
 		return SDIO_DTSx_SET_TYPE_B;
 	}
 }
 static void sdio_select_driver_type(struct mmc_card *card)
 {
 	int host_drv_type = SD_DRIVER_TYPE_B;
 	int card_drv_type = SD_DRIVER_TYPE_B;
 	int drive_strength;
 	unsigned char card_strength;
 	int err;
 	/*
 	 * If the host doesn't support any of the Driver Types A,C or D,
 	 * or there is no board specific handler then default Driver
 	 * Type B is used.
 	 */
 	if (!(card->host->caps &
 		(MMC_CAP_DRIVER_TYPE_A |
 		 MMC_CAP_DRIVER_TYPE_C |
 		 MMC_CAP_DRIVER_TYPE_D)))
 		return;
 	if (!card->host->ops->select_drive_strength)
 		return;
 	if (card->host->caps & MMC_CAP_DRIVER_TYPE_A)
 		host_drv_type |= SD_DRIVER_TYPE_A;
 	if (card->host->caps & MMC_CAP_DRIVER_TYPE_C)
 		host_drv_type |= SD_DRIVER_TYPE_C;
 	if (card->host->caps & MMC_CAP_DRIVER_TYPE_D)
 		host_drv_type |= SD_DRIVER_TYPE_D;
 	if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_A)
 		card_drv_type |= SD_DRIVER_TYPE_A;
 	if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_C)
 		card_drv_type |= SD_DRIVER_TYPE_C;
 	if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_D)
 		card_drv_type |= SD_DRIVER_TYPE_D;
 	/*
 	 * The drive strength that the hardware can support
 	 * depends on the board design.  Pass the appropriate
 	 * information and let the hardware specific code
 	 * return what is possible given the options
 	 */
 	drive_strength = card->host->ops->select_drive_strength(
 		card->sw_caps.uhs_max_dtr,
 		host_drv_type, card_drv_type);
 	/* if error just use default for drive strength B */
 	err = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_DRIVE_STRENGTH, 0,
 		&card_strength);
 	if (err)
 		return;
 	card_strength &= ~(SDIO_DRIVE_DTSx_MASK<<SDIO_DRIVE_DTSx_SHIFT);
 	card_strength |= host_drive_to_sdio_drive(drive_strength);
 	err = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_DRIVE_STRENGTH,
 		card_strength, NULL);
 	/* if error default to drive strength B */
 	if (!err)
 		mmc_set_driver_type(card->host, drive_strength);
 }
 static int sdio_set_bus_speed_mode(struct mmc_card *card)
 {
 	unsigned int bus_speed, timing;
 	int err;
 	unsigned char speed;
 	/*
 	 * If the host doesn't support any of the UHS-I modes, fallback on
 	 * default speed.
 	 */
 	if (!(card->host->caps & (MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 |
 	    MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR104 | MMC_CAP_UHS_DDR50)))
 		return 0;
 	bus_speed = SDIO_SPEED_SDR12;
 	timing = MMC_TIMING_UHS_SDR12;
 	if ((card->host->caps & MMC_CAP_UHS_SDR104) &&
 	    (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR104)) {
 			bus_speed = SDIO_SPEED_SDR104;
 			timing = MMC_TIMING_UHS_SDR104;
 			card->sw_caps.uhs_max_dtr = UHS_SDR104_MAX_DTR;
 	} else if ((card->host->caps & MMC_CAP_UHS_DDR50) &&
 		   (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_DDR50)) {
 			bus_speed = SDIO_SPEED_DDR50;
 			timing = MMC_TIMING_UHS_DDR50;
 			card->sw_caps.uhs_max_dtr = UHS_DDR50_MAX_DTR;
 	} else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
 		    MMC_CAP_UHS_SDR50)) && (card->sw_caps.sd3_bus_mode &
 		    SD_MODE_UHS_SDR50)) {
 			bus_speed = SDIO_SPEED_SDR50;
 			timing = MMC_TIMING_UHS_SDR50;
 			card->sw_caps.uhs_max_dtr = UHS_SDR50_MAX_DTR;
 	} else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
 		    MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25)) &&
 		   (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR25)) {
 			bus_speed = SDIO_SPEED_SDR25;
 			timing = MMC_TIMING_UHS_SDR25;
 			card->sw_caps.uhs_max_dtr = UHS_SDR25_MAX_DTR;
 	} else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
 		    MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25 |
 		    MMC_CAP_UHS_SDR12)) && (card->sw_caps.sd3_bus_mode &
 		    SD_MODE_UHS_SDR12)) {
 			bus_speed = SDIO_SPEED_SDR12;
 			timing = MMC_TIMING_UHS_SDR12;
 			card->sw_caps.uhs_max_dtr = UHS_SDR12_MAX_DTR;
 	}
 	err = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_SPEED, 0, &speed);
 	if (err)
 		return err;
 	speed &= ~SDIO_SPEED_BSS_MASK;
 	speed |= bus_speed;
 	err = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_SPEED, speed, NULL);
 	if (err)
 		return err;
 	if (bus_speed) {
 		mmc_set_timing(card->host, timing);
 		mmc_set_clock(card->host, card->sw_caps.uhs_max_dtr);
 	}
 	return 0;
 }
 /*
  * UHS-I specific initialization procedure
  */
 static int mmc_sdio_init_uhs_card(struct mmc_card *card)
 {
 	int err;
 	if (!card->scr.sda_spec3)
 		return 0;
 	/*
 	 * Switch to wider bus (if supported).
 	 */
 	if (card->host->caps & MMC_CAP_4_BIT_DATA) {
 		err = sdio_enable_4bit_bus(card);
 		if (err > 0) {
 			mmc_set_bus_width(card->host, MMC_BUS_WIDTH_4);
 			err = 0;
 		}
 	}
 	/* Set the driver strength for the card */
 	sdio_select_driver_type(card);
 	/* Set bus speed mode of the card */
 	err = sdio_set_bus_speed_mode(card);
 	if (err)
 		goto out;
 	/* Initialize and start re-tuning timer */
 	if (!mmc_host_is_spi(card->host) && card->host->ops->execute_tuning)
 		err = card->host->ops->execute_tuning(card->host,
 						      MMC_SEND_TUNING_BLOCK);
 out:
 	return err;
 }
 /*
  * Handle the detection and initialisation of a card.
  *
  * In the case of a resume, "oldcard" will contain the card
  * we're trying to reinitialise.
  */
 static int mmc_sdio_init_card(struct mmc_host *host, u32 ocr,
 			      struct mmc_card *oldcard, int powered_resume)
 {
 	struct mmc_card *card;
 	int err;
 	BUG_ON(!host);
 	WARN_ON(!host->claimed);
 	/*
 	 * Inform the card of the voltage
 	 */
 	if (!powered_resume) {
+		/* The initialization should be done at 3.3 V I/O voltage. */
+		mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330, 0);
 		err = mmc_send_io_op_cond(host, host->ocr, &ocr);
 		if (err)
 			goto err;
 	}
 	/*
 	 * For SPI, enable CRC as appropriate.
 	 */
 	if (mmc_host_is_spi(host)) {
 		err = mmc_spi_set_crc(host, use_spi_crc);
 		if (err)
 			goto err;
 	}
 	/*
 	 * Allocate card structure.
 	 */
 	card = mmc_alloc_card(host, NULL);
 	if (IS_ERR(card)) {
 		err = PTR_ERR(card);
 		goto err;
 	}
 	if ((ocr & R4_MEMORY_PRESENT) &&
 	    mmc_sd_get_cid(host, host->ocr & ocr, card->raw_cid, NULL) == 0) {
 		card->type = MMC_TYPE_SD_COMBO;
 		if (oldcard && (oldcard->type != MMC_TYPE_SD_COMBO ||
 		    memcmp(card->raw_cid, oldcard->raw_cid, sizeof(card->raw_cid)) != 0)) {
 			mmc_remove_card(card);
 			return -ENOENT;
 		}
 	} else {
 		card->type = MMC_TYPE_SDIO;
 		if (oldcard && oldcard->type != MMC_TYPE_SDIO) {
 			mmc_remove_card(card);
 			return -ENOENT;
 		}
 	}
 	/*
 	 * Call the optional HC's init_card function to handle quirks.
 	 */
 	if (host->ops->init_card)
 		host->ops->init_card(host, card);
 	/*
 	 * If the host and card support UHS-I mode request the card
 	 * to switch to 1.8V signaling level.  No 1.8v signalling if
 	 * UHS mode is not enabled to maintain compatibilty and some
 	 * systems that claim 1.8v signalling in fact do not support
 	 * it.
 	 */
 	if ((ocr & R4_18V_PRESENT) &&
 		(host->caps &
 			(MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 |
 			 MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR104 |
 			 MMC_CAP_UHS_DDR50))) {
 		err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180,
 				true);
 		if (err) {
 			ocr &= ~R4_18V_PRESENT;
 			host->ocr &= ~R4_18V_PRESENT;
 		}
 		err = 0;
 	} else {
 		ocr &= ~R4_18V_PRESENT;
 		host->ocr &= ~R4_18V_PRESENT;
 	}
 	/*
 	 * For native busses:  set card RCA and quit open drain mode.
 	 */
 	if (!powered_resume && !mmc_host_is_spi(host)) {
 		err = mmc_send_relative_addr(host, &card->rca);
 		if (err)
 			goto remove;
 		/*
 		 * Update oldcard with the new RCA received from the SDIO
 		 * device -- we're doing this so that it's updated in the
 		 * "card" struct when oldcard overwrites that later.
 		 */
 		if (oldcard)
 			oldcard->rca = card->rca;
 	}
 	/*
 	 * Read CSD, before selecting the card
 	 */
 	if (!oldcard && card->type == MMC_TYPE_SD_COMBO) {
 		err = mmc_sd_get_csd(host, card);
 		if (err)
 			return err;
 		mmc_decode_cid(card);
 	}
 	/*
 	 * Select card, as all following commands rely on that.
 	 */
 	if (!powered_resume && !mmc_host_is_spi(host)) {
 		err = mmc_select_card(card);
 		if (err)
 			goto remove;
 	}
 	if (card->quirks & MMC_QUIRK_NONSTD_SDIO) {
 		/*
 		 * This is non-standard SDIO device, meaning it doesn't
 		 * have any CIA (Common I/O area) registers present.
 		 * It's host's responsibility to fill cccr and cis
 		 * structures in init_card().
 		 */
 		mmc_set_clock(host, card->cis.max_dtr);
 		if (card->cccr.high_speed) {
 			mmc_card_set_highspeed(card);
 			mmc_set_timing(card->host, MMC_TIMING_SD_HS);
 		}
 		goto finish;
 	}
 	/*
 	 * Read the common registers.
 	 */
 	err = sdio_read_cccr(card, ocr);
 	if (err)
 		goto remove;
 	/*
 	 * Read the common CIS tuples.
 	 */
 	err = sdio_read_common_cis(card);
 	if (err)
 		goto remove;
 	if (oldcard) {
 		int same = (card->cis.vendor == oldcard->cis.vendor &&
 			    card->cis.device == oldcard->cis.device);
 		mmc_remove_card(card);
 		if (!same)
 			return -ENOENT;
 		card = oldcard;
 	}
 	mmc_fixup_device(card, NULL);
 	if (card->type == MMC_TYPE_SD_COMBO) {
 		err = mmc_sd_setup_card(host, card, oldcard != NULL);
 		/* handle as SDIO-only card if memory init failed */
 		if (err) {
 			mmc_go_idle(host);
 			if (mmc_host_is_spi(host))
 				/* should not fail, as it worked previously */
 				mmc_spi_set_crc(host, use_spi_crc);
 			card->type = MMC_TYPE_SDIO;
 		} else
 			card->dev.type = &sd_type;
 	}
 	/*
 	 * If needed, disconnect card detection pull-up resistor.
 	 */
 	err = sdio_disable_cd(card);
 	if (err)
 		goto remove;
 	/* Initialization sequence for UHS-I cards */
 	/* Only if card supports 1.8v and UHS signaling */
 	if ((ocr & R4_18V_PRESENT) && card->sw_caps.sd3_bus_mode) {
 		err = mmc_sdio_init_uhs_card(card);
 		if (err)
 			goto remove;
 		/* Card is an ultra-high-speed card */
 		mmc_card_set_uhs(card);
 	} else {
 		/*
 		 * Switch to high-speed (if supported).
 		 */
 		err = sdio_enable_hs(card);
 		if (err > 0)
 			mmc_sd_go_highspeed(card);
 		else if (err)
 			goto remove;
 		/*
 		 * Change to the card's maximum speed.
 		 */
 		mmc_set_clock(host, mmc_sdio_get_max_clock(card));
 		/*
 		 * Switch to wider bus (if supported).
 		 */
 		err = sdio_enable_4bit_bus(card);
 		if (err > 0)
 			mmc_set_bus_width(card->host, MMC_BUS_WIDTH_4);
 		else if (err)
 			goto remove;
 	}
 finish:
 	if (!oldcard)
 		host->card = card;
 	return 0;
 remove:
 	if (!oldcard)
 		mmc_remove_card(card);
 err:
 	return err;
 }
 /*
  * Host is being removed. Free up the current card.
  */
 static void mmc_sdio_remove(struct mmc_host *host)
 {
 	int i;
 	BUG_ON(!host);
 	BUG_ON(!host->card);
 	for (i = 0;i < host->card->sdio_funcs;i++) {
 		if (host->card->sdio_func[i]) {
 			sdio_remove_func(host->card->sdio_func[i]);
 			host->card->sdio_func[i] = NULL;
 		}
 	}
 	mmc_remove_card(host->card);
 	host->card = NULL;
 }
 /*
  * Card detection - card is alive.
  */
 static int mmc_sdio_alive(struct mmc_host *host)
 {
 	return mmc_select_card(host->card);
 }
 /*
  * Card detection callback from host.
  */
 static void mmc_sdio_detect(struct mmc_host *host)
 {
 	int err;
 	BUG_ON(!host);
 	BUG_ON(!host->card);
 	/* Make sure card is powered before detecting it */
 	if (host->caps & MMC_CAP_POWER_OFF_CARD) {
 		err = pm_runtime_get_sync(&host->card->dev);
 		if (err < 0)
 			goto out;
 	}
 	mmc_claim_host(host);
 	/*
 	 * Just check if our card has been removed.
 	 */
 	err = _mmc_detect_card_removed(host);
 	mmc_release_host(host);
 	/*
 	 * Tell PM core it's OK to power off the card now.
 	 *
 	 * The _sync variant is used in order to ensure that the card
 	 * is left powered off in case an error occurred, and the card
 	 * is going to be removed.
 	 *
 	 * Since there is no specific reason to believe a new user
 	 * is about to show up at this point, the _sync variant is
 	 * desirable anyway.
 	 */
 	if (host->caps & MMC_CAP_POWER_OFF_CARD)
 		pm_runtime_put_sync(&host->card->dev);
 out:
 	if (err) {
 		mmc_sdio_remove(host);
 		mmc_claim_host(host);
 		mmc_detach_bus(host);
 		mmc_power_off(host);
 		mmc_release_host(host);
 	}
 }
 /*
  * SDIO suspend.  We need to suspend all functions separately.
  * Therefore all registered functions must have drivers with suspend
  * and resume methods.  Failing that we simply remove the whole card.
  */
 static int mmc_sdio_suspend(struct mmc_host *host)
 {
 	int i, err = 0;
 	for (i = 0; i < host->card->sdio_funcs; i++) {
 		struct sdio_func *func = host->card->sdio_func[i];
 		if (func && sdio_func_present(func) && func->dev.driver) {
 			const struct dev_pm_ops *pmops = func->dev.driver->pm;
 			if (!pmops || !pmops->suspend || !pmops->resume) {
 				/* force removal of entire card in that case */
 				err = -ENOSYS;
 			} else
 				err = pmops->suspend(&func->dev);
 			if (err)
 				break;
 		}
 	}
 	while (err && --i >= 0) {
 		struct sdio_func *func = host->card->sdio_func[i];
 		if (func && sdio_func_present(func) && func->dev.driver) {
 			const struct dev_pm_ops *pmops = func->dev.driver->pm;
 			pmops->resume(&func->dev);
 		}
 	}
 	if (!err && mmc_card_keep_power(host) && mmc_card_wake_sdio_irq(host)) {
 		mmc_claim_host(host);
 		sdio_disable_wide(host->card);
 		mmc_release_host(host);
 	}
 	return err;
 }
 static int mmc_sdio_resume(struct mmc_host *host)
 {
 	int i, err = 0;
 	BUG_ON(!host);
 	BUG_ON(!host->card);
 	/* Basic card reinitialization. */
 	mmc_claim_host(host);
 	/* No need to reinitialize powered-resumed nonremovable cards */
 	if (mmc_card_is_removable(host) || !mmc_card_keep_power(host))
 		err = mmc_sdio_init_card(host, host->ocr, host->card,
 					mmc_card_keep_power(host));
 	else if (mmc_card_keep_power(host) && mmc_card_wake_sdio_irq(host)) {
 		/* We may have switched to 1-bit mode during suspend */
 		err = sdio_enable_4bit_bus(host->card);
 		if (err > 0) {
 			mmc_set_bus_width(host, MMC_BUS_WIDTH_4);
 			err = 0;
 		}
 	}
 	if (!err && host->sdio_irqs)
 		mmc_signal_sdio_irq(host);
 	mmc_release_host(host);
 	/*
 	 * If the card looked to be the same as before suspending, then
 	 * we proceed to resume all card functions.  If one of them returns
 	 * an error then we simply return that error to the core and the
 	 * card will be redetected as new.  It is the responsibility of
 	 * the function driver to perform further tests with the extra
 	 * knowledge it has of the card to confirm the card is indeed the
 	 * same as before suspending (same MAC address for network cards,
 	 * etc.) and return an error otherwise.
 	 */
 	for (i = 0; !err && i < host->card->sdio_funcs; i++) {
 		struct sdio_func *func = host->card->sdio_func[i];
 		if (func && sdio_func_present(func) && func->dev.driver) {
 			const struct dev_pm_ops *pmops = func->dev.driver->pm;
 			err = pmops->resume(&func->dev);
 		}
 	}
 	return err;
 }
 static int mmc_sdio_power_restore(struct mmc_host *host)
 {
 	int ret;
 	u32 ocr;
 	BUG_ON(!host);
 	BUG_ON(!host->card);
 	mmc_claim_host(host);
 	/*
 	 * Reset the card by performing the same steps that are taken by
 	 * mmc_rescan_try_freq() and mmc_attach_sdio() during a "normal" probe.
 	 *
 	 * sdio_reset() is technically not needed. Having just powered up the
 	 * hardware, it should already be in reset state. However, some
 	 * platforms (such as SD8686 on OLPC) do not instantly cut power,
 	 * meaning that a reset is required when restoring power soon after
 	 * powering off. It is harmless in other cases.
 	 *
 	 * The CMD5 reset (mmc_send_io_op_cond()), according to the SDIO spec,
 	 * is not necessary for non-removable cards. However, it is required
 	 * for OLPC SD8686 (which expects a [CMD5,5,3,7] init sequence), and
 	 * harmless in other situations.
 	 *
 	 * With these steps taken, mmc_select_voltage() is also required to
 	 * restore the correct voltage setting of the card.
 	 */
+	/* The initialization should be done at 3.3 V I/O voltage. */
+	if (!mmc_card_keep_power(host))
+		mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330, 0);
 	sdio_reset(host);
 	mmc_go_idle(host);
 	mmc_send_if_cond(host, host->ocr_avail);
 	ret = mmc_send_io_op_cond(host, 0, &ocr);
 	if (ret)
 		goto out;
 	if (host->ocr_avail_sdio)
 		host->ocr_avail = host->ocr_avail_sdio;
 	host->ocr = mmc_select_voltage(host, ocr & ~0x7F);
 	if (!host->ocr) {
 		ret = -EINVAL;
 		goto out;
 	}
 	ret = mmc_sdio_init_card(host, host->ocr, host->card,
 				mmc_card_keep_power(host));
 	if (!ret && host->sdio_irqs)
 		mmc_signal_sdio_irq(host);
 out:
 	mmc_release_host(host);
 	return ret;
 }
 static const struct mmc_bus_ops mmc_sdio_ops = {
 	.remove = mmc_sdio_remove,
 	.detect = mmc_sdio_detect,
 	.suspend = mmc_sdio_suspend,
 	.resume = mmc_sdio_resume,
 	.power_restore = mmc_sdio_power_restore,
 	.alive = mmc_sdio_alive,
 };
 /*
  * Starting point for SDIO card init.
  */
 int mmc_attach_sdio(struct mmc_host *host)
 {
 	int err, i, funcs;
 	u32 ocr;
 	struct mmc_card *card;
 	BUG_ON(!host);
 	WARN_ON(!host->claimed);
 	err = mmc_send_io_op_cond(host, 0, &ocr);
 	if (err)
 		return err;
 	mmc_attach_bus(host, &mmc_sdio_ops);
 	if (host->ocr_avail_sdio)
 		host->ocr_avail = host->ocr_avail_sdio;
 	/*
 	 * Sanity check the voltages that the card claims to
 	 * support.
 	 */
 	if (ocr & 0x7F) {
 		pr_warning("%s: card claims to support voltages "
 		       "below the defined range. These will be ignored.\n",
 		       mmc_hostname(host));
 		ocr &= ~0x7F;
 	}
 	host->ocr = mmc_select_voltage(host, ocr);
 	/*
 	 * Can we support the voltage(s) of the card(s)?
 	 */
 	if (!host->ocr) {
 		err = -EINVAL;
 		goto err;
 	}
 	/*
 	 * Detect and init the card.
 	 */
 	err = mmc_sdio_init_card(host, host->ocr, NULL, 0);
 	if (err) {
 		if (err == -EAGAIN) {
 			/*
 			 * Retry initialization with S18R set to 0.
 			 */
 			host->ocr &= ~R4_18V_PRESENT;
 			err = mmc_sdio_init_card(host, host->ocr, NULL, 0);
 		}
 		if (err)
 			goto err;
 	}
 	card = host->card;
 	/*
 	 * Enable runtime PM only if supported by host+card+board
 	 */
 	if (host->caps & MMC_CAP_POWER_OFF_CARD) {
 		/*
 		 * Let runtime PM core know our card is active
 		 */
 		err = pm_runtime_set_active(&card->dev);
 		if (err)
 			goto remove;
 		/*
 		 * Enable runtime PM for this card
 		 */
 		pm_runtime_enable(&card->dev);
 	}
 	/*
 	 * The number of functions on the card is encoded inside
 	 * the ocr.
 	 */
 	funcs = (ocr & 0x70000000) >> 28;
 	card->sdio_funcs = 0;
 	/*
 	 * Initialize (but don't add) all present functions.
 	 */
 	for (i = 0; i < funcs; i++, card->sdio_funcs++) {
 		err = sdio_init_func(host->card, i + 1);
 		if (err)
 			goto remove;
 		/*
 		 * Enable Runtime PM for this func (if supported)
 		 */
 		if (host->caps & MMC_CAP_POWER_OFF_CARD)
 			pm_runtime_enable(&card->sdio_func[i]->dev);
 	}
 	/*
 	 * First add the card to the driver model...
 	 */
 	mmc_release_host(host);
 	err = mmc_add_card(host->card);
 	if (err)
 		goto remove_added;
 	/*
 	 * ...then the SDIO functions.
 	 */
 	for (i = 0;i < funcs;i++) {
 		err = sdio_add_func(host->card->sdio_func[i]);
 		if (err)
 			goto remove_added;
 	}
 	mmc_claim_host(host);
 	return 0;
 remove_added:
 	/* Remove without lock if the device has been added. */
 	mmc_sdio_remove(host);
 	mmc_claim_host(host);
 remove:
 	/* And with lock if it hasn't been added. */
 	mmc_release_host(host);
 	if (host->card)
 		mmc_sdio_remove(host);
 	mmc_claim_host(host);
 err:
 	mmc_detach_bus(host);
 	pr_err("%s: error %d whilst initialising SDIO card\n",
 		mmc_hostname(host), err);
 	return err;
 }