2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2007-02-28 14:33:10 +00:00
|
|
|
* linux/drivers/mmc/core/core.c
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* Copyright (C) 2003-2004 Russell King, All Rights Reserved.
|
2005-09-06 22:18:56 +00:00
|
|
|
* SD support Copyright (C) 2004 Ian Molton, All Rights Reserved.
|
2008-06-28 10:52:45 +00:00
|
|
|
* Copyright (C) 2005-2008 Pierre Ossman, All Rights Reserved.
|
2006-10-21 10:35:02 +00:00
|
|
|
* MMCv4 support Copyright (C) 2006 Philip Langdale, All Rights Reserved.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* 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>
|
2007-09-24 05:15:48 +00:00
|
|
|
#include <linux/leds.h>
|
2005-09-06 22:18:53 +00:00
|
|
|
#include <linux/scatterlist.h>
|
2008-11-26 19:54:17 +00:00
|
|
|
#include <linux/log2.h>
|
2009-03-11 11:30:43 +00:00
|
|
|
#include <linux/regulator/consumer.h>
|
2010-11-28 05:21:30 +00:00
|
|
|
#include <linux/pm_runtime.h>
|
2011-07-26 00:13:11 +00:00
|
|
|
#include <linux/suspend.h>
|
2011-08-19 12:52:37 +00:00
|
|
|
#include <linux/fault-inject.h>
|
|
|
|
#include <linux/random.h>
|
2012-09-17 08:42:02 +00:00
|
|
|
#include <linux/slab.h>
|
2009-03-23 19:20:37 +00:00
|
|
|
#include <linux/wakelock.h>
|
2011-02-17 16:07:48 +00:00
|
|
|
#include <linux/pm.h>
|
2012-10-11 11:47:03 +00:00
|
|
|
#include <linux/jiffies.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-05-16 03:13:13 +00:00
|
|
|
#include <trace/events/mmc.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#include <linux/mmc/card.h>
|
|
|
|
#include <linux/mmc/host.h>
|
2006-12-24 21:46:55 +00:00
|
|
|
#include <linux/mmc/mmc.h>
|
|
|
|
#include <linux/mmc/sd.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-02-28 14:33:10 +00:00
|
|
|
#include "core.h"
|
2007-05-19 12:32:22 +00:00
|
|
|
#include "bus.h"
|
|
|
|
#include "host.h"
|
2007-05-26 11:48:18 +00:00
|
|
|
#include "sdio_bus.h"
|
2006-12-24 21:46:55 +00:00
|
|
|
|
|
|
|
#include "mmc_ops.h"
|
|
|
|
#include "sd_ops.h"
|
2007-05-21 18:23:20 +00:00
|
|
|
#include "sdio_ops.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-04-18 01:29:57 +00:00
|
|
|
#ifdef CONFIG_MMC_SUPPORT_STLOG
|
|
|
|
#include <linux/stlog.h>
|
|
|
|
#else
|
|
|
|
#define ST_LOG(fmt,...)
|
|
|
|
#endif
|
|
|
|
|
2012-11-16 15:31:41 +00:00
|
|
|
/* If the device is not responding */
|
|
|
|
#define MMC_CORE_TIMEOUT_MS (10 * 60 * 1000) /* 10 minute timeout */
|
|
|
|
|
2012-09-17 08:42:02 +00:00
|
|
|
/*
|
|
|
|
* Background operations can take a long time, depending on the housekeeping
|
|
|
|
* operations the card has to perform.
|
|
|
|
*/
|
2012-12-15 16:28:44 +00:00
|
|
|
#define MMC_BKOPS_MAX_TIMEOUT (30 * 1000) /* max time to wait in ms */
|
2012-09-17 08:42:02 +00:00
|
|
|
|
2013-06-30 06:31:21 +00:00
|
|
|
/* Flushing a large amount of cached data may take a long time. */
|
2014-09-23 09:26:42 +00:00
|
|
|
#define MMC_FLUSH_REQ_TIMEOUT_MS 180000 /* msec */
|
2013-06-30 06:31:21 +00:00
|
|
|
|
2007-05-19 12:32:22 +00:00
|
|
|
static struct workqueue_struct *workqueue;
|
2012-05-09 14:15:26 +00:00
|
|
|
static const unsigned freqs[] = { 400000, 300000, 200000, 100000 };
|
2007-05-19 12:32:22 +00:00
|
|
|
|
MMC core learns about SPI
Teach the MMC/SD/SDIO core about using SPI mode.
- Use mmc_host_is_spi() so enumeration works through SPI signaling
and protocols, not just the native versions.
- Provide the SPI response type flags with each request issued,
including requests from the new lock/unlock code.
- Understand that cmd->resp[0] and mmc_get_status() results for SPI
return different values than for "native" MMC/SD protocol; this
affects resetting, checking card lock status, and some others.
- Understand that some commands act a bit differently ... notably:
* OP_COND command doesn't return the OCR
* APP_CMD status doesn't have an R1_APP_CMD analogue
Those changes required some new and updated primitives:
- Provide utilities to access two SPI-only requests, and one
request that wasn't previously needed:
* mmc_spi_read_ocr() ... SPI only
* mmc_spi_set_crc() ... SPI only (override by module parm)
* mmc_send_cid() ... for use without broadcast mode
- Updated internal routines:
* Previous mmc_send_csd() modified into mmc_send_cxd_native();
it uses native "R2" responses, which include 16 bytes of data.
* Previous mmc_send_ext_csd() becomes new mmc_send_cxd_data()
helper for command-and-data access
* Bugfix to that mmc_send_cxd_data() code: dma-to-stack is
unsafe/nonportable, so kmalloc a bounce buffer instead.
- Modified mmc_send_ext_csd() now uses mmc_send_cxd_data() helper
- Modified mmc_send_csd(), and new mmc_spi_send_cid(), routines use
those helper routines based on whether they're native or SPI
The newest categories of cards supported by the MMC stack aren't expected
to work yet with SPI: MMC or SD cards with over 4GB data, and SDIO.
All those cards support SPI mode, so eventually they should work too.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Pierre Ossman <drzeus@drzeus.cx>
2007-08-08 16:11:32 +00:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2012-01-12 23:02:20 +00:00
|
|
|
bool use_spi_crc = 1;
|
MMC core learns about SPI
Teach the MMC/SD/SDIO core about using SPI mode.
- Use mmc_host_is_spi() so enumeration works through SPI signaling
and protocols, not just the native versions.
- Provide the SPI response type flags with each request issued,
including requests from the new lock/unlock code.
- Understand that cmd->resp[0] and mmc_get_status() results for SPI
return different values than for "native" MMC/SD protocol; this
affects resetting, checking card lock status, and some others.
- Understand that some commands act a bit differently ... notably:
* OP_COND command doesn't return the OCR
* APP_CMD status doesn't have an R1_APP_CMD analogue
Those changes required some new and updated primitives:
- Provide utilities to access two SPI-only requests, and one
request that wasn't previously needed:
* mmc_spi_read_ocr() ... SPI only
* mmc_spi_set_crc() ... SPI only (override by module parm)
* mmc_send_cid() ... for use without broadcast mode
- Updated internal routines:
* Previous mmc_send_csd() modified into mmc_send_cxd_native();
it uses native "R2" responses, which include 16 bytes of data.
* Previous mmc_send_ext_csd() becomes new mmc_send_cxd_data()
helper for command-and-data access
* Bugfix to that mmc_send_cxd_data() code: dma-to-stack is
unsafe/nonportable, so kmalloc a bounce buffer instead.
- Modified mmc_send_ext_csd() now uses mmc_send_cxd_data() helper
- Modified mmc_send_csd(), and new mmc_spi_send_cid(), routines use
those helper routines based on whether they're native or SPI
The newest categories of cards supported by the MMC stack aren't expected
to work yet with SPI: MMC or SD cards with over 4GB data, and SDIO.
All those cards support SPI mode, so eventually they should work too.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Pierre Ossman <drzeus@drzeus.cx>
2007-08-08 16:11:32 +00:00
|
|
|
module_param(use_spi_crc, bool, 0);
|
|
|
|
|
2009-12-15 02:01:29 +00:00
|
|
|
/*
|
|
|
|
* 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
|
2012-01-12 23:02:20 +00:00
|
|
|
bool mmc_assume_removable;
|
2009-12-15 02:01:29 +00:00
|
|
|
#else
|
2012-01-12 23:02:20 +00:00
|
|
|
bool mmc_assume_removable = 1;
|
2009-12-15 02:01:29 +00:00
|
|
|
#endif
|
2010-09-27 08:42:19 +00:00
|
|
|
EXPORT_SYMBOL(mmc_assume_removable);
|
2009-12-15 02:01:29 +00:00
|
|
|
module_param_named(removable, mmc_assume_removable, bool, 0644);
|
|
|
|
MODULE_PARM_DESC(
|
|
|
|
removable,
|
|
|
|
"MMC/SD cards are removable and may be removed during suspend");
|
|
|
|
|
2012-10-11 16:29:28 +00:00
|
|
|
#define MMC_UPDATE_BKOPS_STATS_HPI(stats) \
|
|
|
|
do { \
|
|
|
|
spin_lock(&stats.lock); \
|
|
|
|
if (stats.enabled) \
|
|
|
|
stats.hpi++; \
|
|
|
|
spin_unlock(&stats.lock); \
|
|
|
|
} while (0);
|
|
|
|
#define MMC_UPDATE_BKOPS_STATS_SUSPEND(stats) \
|
|
|
|
do { \
|
|
|
|
spin_lock(&stats.lock); \
|
|
|
|
if (stats.enabled) \
|
|
|
|
stats.suspend++; \
|
|
|
|
spin_unlock(&stats.lock); \
|
|
|
|
} while (0);
|
|
|
|
#define MMC_UPDATE_STATS_BKOPS_SEVERITY_LEVEL(stats, level) \
|
|
|
|
do { \
|
|
|
|
if (level <= 0 || level > BKOPS_NUM_OF_SEVERITY_LEVELS) \
|
|
|
|
break; \
|
|
|
|
spin_lock(&stats.lock); \
|
|
|
|
if (stats.enabled) \
|
|
|
|
stats.bkops_level[level-1]++; \
|
|
|
|
spin_unlock(&stats.lock); \
|
|
|
|
} while (0);
|
|
|
|
|
2007-05-19 12:32:22 +00:00
|
|
|
/*
|
|
|
|
* 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);
|
|
|
|
}
|
|
|
|
|
2011-08-19 12:52:37 +00:00
|
|
|
#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;
|
|
|
|
|
2013-04-29 23:21:31 +00:00
|
|
|
data->error = data_errors[prandom_u32() % ARRAY_SIZE(data_errors)];
|
|
|
|
data->bytes_xfered = (prandom_u32() % (data->bytes_xfered >> 9)) << 9;
|
2012-07-27 12:40:19 +00:00
|
|
|
data->fault_injected = true;
|
2011-08-19 12:52:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#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 */
|
|
|
|
|
2014-04-21 07:26:21 +00:00
|
|
|
static inline void
|
|
|
|
mmc_clk_scaling_update_state(struct mmc_host *host, struct mmc_request *mrq)
|
|
|
|
{
|
|
|
|
if (mrq) {
|
|
|
|
switch (mrq->cmd->opcode) {
|
|
|
|
case MMC_READ_SINGLE_BLOCK:
|
|
|
|
case MMC_READ_MULTIPLE_BLOCK:
|
|
|
|
case MMC_WRITE_BLOCK:
|
|
|
|
case MMC_WRITE_MULTIPLE_BLOCK:
|
|
|
|
host->clk_scaling.invalid_state = false;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
host->clk_scaling.invalid_state = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* force clock scaling transitions,
|
|
|
|
* if other conditions are met
|
|
|
|
*/
|
|
|
|
host->clk_scaling.invalid_state = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-06-01 14:23:42 +00:00
|
|
|
void mmc_update_clk_scaling(struct mmc_host *host,
|
|
|
|
bool is_cmdq_dcmd)
|
2013-04-15 09:54:35 +00:00
|
|
|
{
|
2015-06-01 14:23:42 +00:00
|
|
|
bool cmdq_mode = !!mmc_card_cmdq(host->card);
|
|
|
|
|
|
|
|
if (!host->clk_scaling.enable || host->clk_scaling.invalid_state)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For CQ mode: In completion of DCMD request, start busy time in
|
|
|
|
* case of pending data requests
|
|
|
|
*/
|
|
|
|
if (is_cmdq_dcmd) {
|
|
|
|
if (host->cmdq_ctx.data_active_reqs) {
|
|
|
|
host->clk_scaling.cq_is_busy_started = true;
|
|
|
|
host->clk_scaling.start_busy = ktime_get();
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
host->clk_scaling.busy_time_us +=
|
|
|
|
ktime_to_us(ktime_sub(ktime_get(),
|
|
|
|
host->clk_scaling.start_busy));
|
|
|
|
|
|
|
|
if ((!cmdq_mode) || (cmdq_mode && host->cmdq_ctx.data_active_reqs)) {
|
|
|
|
host->clk_scaling.cq_is_busy_started = true;
|
2013-04-11 07:31:06 +00:00
|
|
|
host->clk_scaling.start_busy = ktime_get();
|
2015-06-01 14:23:42 +00:00
|
|
|
} else {
|
|
|
|
host->clk_scaling.cq_is_busy_started = false;
|
2013-04-11 07:31:06 +00:00
|
|
|
}
|
2013-04-15 09:54:35 +00:00
|
|
|
}
|
2015-06-01 14:23:42 +00:00
|
|
|
EXPORT_SYMBOL(mmc_update_clk_scaling);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
2006-05-04 12:51:45 +00:00
|
|
|
* mmc_request_done - finish processing an MMC request
|
|
|
|
* @host: MMC host which completed request
|
|
|
|
* @mrq: MMC request which request
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* MMC drivers should call this function when they have completed
|
2006-05-04 12:51:45 +00:00
|
|
|
* their processing of a request.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
void mmc_request_done(struct mmc_host *host, struct mmc_request *mrq)
|
|
|
|
{
|
|
|
|
struct mmc_command *cmd = mrq->cmd;
|
2006-05-04 17:22:51 +00:00
|
|
|
int err = cmd->error;
|
2010-06-11 12:43:05 +00:00
|
|
|
#ifdef CONFIG_MMC_PERF_PROFILING
|
|
|
|
ktime_t diff;
|
|
|
|
#endif
|
2013-04-15 09:54:35 +00:00
|
|
|
if (host->card)
|
2015-06-01 14:23:42 +00:00
|
|
|
mmc_update_clk_scaling(host, false);
|
2006-05-04 17:22:51 +00:00
|
|
|
|
MMC core learns about SPI
Teach the MMC/SD/SDIO core about using SPI mode.
- Use mmc_host_is_spi() so enumeration works through SPI signaling
and protocols, not just the native versions.
- Provide the SPI response type flags with each request issued,
including requests from the new lock/unlock code.
- Understand that cmd->resp[0] and mmc_get_status() results for SPI
return different values than for "native" MMC/SD protocol; this
affects resetting, checking card lock status, and some others.
- Understand that some commands act a bit differently ... notably:
* OP_COND command doesn't return the OCR
* APP_CMD status doesn't have an R1_APP_CMD analogue
Those changes required some new and updated primitives:
- Provide utilities to access two SPI-only requests, and one
request that wasn't previously needed:
* mmc_spi_read_ocr() ... SPI only
* mmc_spi_set_crc() ... SPI only (override by module parm)
* mmc_send_cid() ... for use without broadcast mode
- Updated internal routines:
* Previous mmc_send_csd() modified into mmc_send_cxd_native();
it uses native "R2" responses, which include 16 bytes of data.
* Previous mmc_send_ext_csd() becomes new mmc_send_cxd_data()
helper for command-and-data access
* Bugfix to that mmc_send_cxd_data() code: dma-to-stack is
unsafe/nonportable, so kmalloc a bounce buffer instead.
- Modified mmc_send_ext_csd() now uses mmc_send_cxd_data() helper
- Modified mmc_send_csd(), and new mmc_spi_send_cid(), routines use
those helper routines based on whether they're native or SPI
The newest categories of cards supported by the MMC stack aren't expected
to work yet with SPI: MMC or SD cards with over 4GB data, and SDIO.
All those cards support SPI mode, so eventually they should work too.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Pierre Ossman <drzeus@drzeus.cx>
2007-08-08 16:11:32 +00:00
|
|
|
if (err && cmd->retries && mmc_host_is_spi(host)) {
|
|
|
|
if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND)
|
|
|
|
cmd->retries = 0;
|
|
|
|
}
|
|
|
|
|
2011-11-28 14:22:00 +00:00
|
|
|
if (err && cmd->retries && !mmc_card_removed(host->card)) {
|
2011-10-03 12:33:33 +00:00
|
|
|
/*
|
|
|
|
* Request starter must handle retries - see
|
|
|
|
* mmc_wait_for_req_done().
|
|
|
|
*/
|
|
|
|
if (mrq->done)
|
|
|
|
mrq->done(mrq);
|
2007-07-24 19:46:49 +00:00
|
|
|
} else {
|
2011-08-19 12:52:37 +00:00
|
|
|
mmc_should_fail_request(host, mrq);
|
|
|
|
|
2007-09-24 05:15:48 +00:00
|
|
|
led_trigger_event(host->led, LED_OFF);
|
|
|
|
|
2007-07-24 19:46:49 +00:00
|
|
|
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) {
|
2010-06-11 12:43:05 +00:00
|
|
|
#ifdef CONFIG_MMC_PERF_PROFILING
|
2012-03-25 05:45:41 +00:00
|
|
|
if (host->perf_enable) {
|
|
|
|
diff = ktime_sub(ktime_get(), host->perf.start);
|
|
|
|
if (mrq->data->flags == MMC_DATA_READ) {
|
|
|
|
host->perf.rbytes_drv +=
|
|
|
|
mrq->data->bytes_xfered;
|
|
|
|
host->perf.rtime_drv =
|
|
|
|
ktime_add(host->perf.rtime_drv,
|
|
|
|
diff);
|
|
|
|
} else {
|
|
|
|
host->perf.wbytes_drv +=
|
2010-06-11 12:43:05 +00:00
|
|
|
mrq->data->bytes_xfered;
|
2012-03-25 05:45:41 +00:00
|
|
|
host->perf.wtime_drv =
|
|
|
|
ktime_add(host->perf.wtime_drv,
|
|
|
|
diff);
|
|
|
|
}
|
2010-06-11 12:43:05 +00:00
|
|
|
}
|
|
|
|
#endif
|
2007-07-24 19:46:49 +00:00
|
|
|
pr_debug("%s: %d bytes transferred: %d\n",
|
|
|
|
mmc_hostname(host),
|
|
|
|
mrq->data->bytes_xfered, mrq->data->error);
|
2013-05-16 03:13:13 +00:00
|
|
|
trace_mmc_blk_rw_end(cmd->opcode, cmd->arg, mrq->data);
|
2007-07-24 19:46:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
2010-11-09 02:36:50 +00:00
|
|
|
|
2011-08-18 12:23:47 +00:00
|
|
|
mmc_host_clk_release(host);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(mmc_request_done);
|
|
|
|
|
2007-07-24 22:40:58 +00:00
|
|
|
static void
|
2005-04-16 22:20:36 +00:00
|
|
|
mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
|
|
|
|
{
|
2007-04-13 20:47:01 +00:00
|
|
|
#ifdef CONFIG_MMC_DEBUG
|
|
|
|
unsigned int i, sz;
|
2008-07-28 23:09:37 +00:00
|
|
|
struct scatterlist *sg;
|
2007-04-13 20:47:01 +00:00
|
|
|
#endif
|
|
|
|
|
2012-02-07 05:13:10 +00:00
|
|
|
if (mrq->sbc) {
|
|
|
|
pr_debug("<%s: starting CMD%u arg %08x flags %08x>\n",
|
|
|
|
mmc_hostname(host), mrq->sbc->opcode,
|
|
|
|
mrq->sbc->arg, mrq->sbc->flags);
|
|
|
|
}
|
|
|
|
|
2006-05-04 17:22:51 +00:00
|
|
|
pr_debug("%s: starting CMD%u arg %08x flags %08x\n",
|
|
|
|
mmc_hostname(host), mrq->cmd->opcode,
|
|
|
|
mrq->cmd->arg, mrq->cmd->flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-07-24 19:46:49 +00:00
|
|
|
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,
|
2007-08-07 12:06:18 +00:00
|
|
|
mrq->data->timeout_ns / 1000000,
|
2007-07-24 19:46:49 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2006-12-26 14:11:23 +00:00
|
|
|
WARN_ON(!host->claimed);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
mrq->cmd->error = 0;
|
|
|
|
mrq->cmd->mrq = mrq;
|
|
|
|
if (mrq->data) {
|
2006-11-21 16:54:23 +00:00
|
|
|
BUG_ON(mrq->data->blksz > host->max_blk_size);
|
2006-11-21 16:55:45 +00:00
|
|
|
BUG_ON(mrq->data->blocks > host->max_blk_count);
|
|
|
|
BUG_ON(mrq->data->blocks * mrq->data->blksz >
|
|
|
|
host->max_req_size);
|
2006-11-21 16:54:23 +00:00
|
|
|
|
2007-04-13 20:47:01 +00:00
|
|
|
#ifdef CONFIG_MMC_DEBUG
|
|
|
|
sz = 0;
|
2008-07-28 23:09:37 +00:00
|
|
|
for_each_sg(mrq->data->sg, sg, mrq->data->sg_len, i)
|
|
|
|
sz += sg->length;
|
2007-04-13 20:47:01 +00:00
|
|
|
BUG_ON(sz != mrq->data->blocks * mrq->data->blksz);
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
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;
|
|
|
|
}
|
2010-06-11 12:43:05 +00:00
|
|
|
#ifdef CONFIG_MMC_PERF_PROFILING
|
2012-03-25 05:45:41 +00:00
|
|
|
if (host->perf_enable)
|
|
|
|
host->perf.start = ktime_get();
|
2010-06-11 12:43:05 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2011-08-18 12:23:47 +00:00
|
|
|
mmc_host_clk_hold(host);
|
2011-02-06 18:02:48 +00:00
|
|
|
led_trigger_event(host->led, LED_FULL);
|
2012-10-11 11:47:03 +00:00
|
|
|
|
|
|
|
if (host->card && host->clk_scaling.enable) {
|
|
|
|
/*
|
|
|
|
* Check if we need to scale the clocks. Clocks
|
|
|
|
* will be scaled up immediately if necessary
|
|
|
|
* conditions are satisfied. Scaling down the
|
|
|
|
* frequency will be done after current thread
|
|
|
|
* releases host.
|
|
|
|
*/
|
2014-04-21 07:26:21 +00:00
|
|
|
mmc_clk_scaling_update_state(host, mrq);
|
|
|
|
if (!host->clk_scaling.invalid_state) {
|
|
|
|
mmc_clk_scaling(host, false);
|
|
|
|
host->clk_scaling.start_busy = ktime_get();
|
|
|
|
}
|
2012-10-11 11:47:03 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
host->ops->request(host, mrq);
|
|
|
|
}
|
|
|
|
|
2012-10-11 16:29:28 +00:00
|
|
|
void mmc_blk_init_bkops_statistics(struct mmc_card *card)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct mmc_bkops_stats *bkops_stats;
|
|
|
|
|
|
|
|
if (!card)
|
|
|
|
return;
|
|
|
|
|
|
|
|
bkops_stats = &card->bkops_info.bkops_stats;
|
|
|
|
|
|
|
|
spin_lock(&bkops_stats->lock);
|
|
|
|
|
|
|
|
for (i = 0 ; i < BKOPS_NUM_OF_SEVERITY_LEVELS ; ++i)
|
|
|
|
bkops_stats->bkops_level[i] = 0;
|
|
|
|
|
|
|
|
bkops_stats->suspend = 0;
|
|
|
|
bkops_stats->hpi = 0;
|
|
|
|
bkops_stats->enabled = true;
|
|
|
|
|
|
|
|
spin_unlock(&bkops_stats->lock);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mmc_blk_init_bkops_statistics);
|
|
|
|
|
2014-03-21 09:10:57 +00:00
|
|
|
static void mmc_start_cmdq_request(struct mmc_host *host,
|
|
|
|
struct mmc_request *mrq)
|
|
|
|
{
|
|
|
|
if (mrq->data) {
|
|
|
|
pr_debug("%s: blksz %d blocks %d flags %08x tsac %lu ms nsac %d\n",
|
|
|
|
mmc_hostname(host), mrq->data->blksz,
|
|
|
|
mrq->data->blocks, mrq->data->flags,
|
|
|
|
mrq->data->timeout_ns / NSEC_PER_MSEC,
|
|
|
|
mrq->data->timeout_clks);
|
|
|
|
|
|
|
|
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);
|
|
|
|
mrq->data->error = 0;
|
|
|
|
mrq->data->mrq = mrq;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mrq->cmd) {
|
|
|
|
mrq->cmd->error = 0;
|
|
|
|
mrq->cmd->mrq = mrq;
|
|
|
|
}
|
|
|
|
|
|
|
|
mmc_host_clk_hold(host);
|
|
|
|
if (likely(host->cmdq_ops->request))
|
|
|
|
host->cmdq_ops->request(host, mrq);
|
|
|
|
else
|
|
|
|
pr_err("%s: %s: issue request failed\n", mmc_hostname(host),
|
|
|
|
__func__);
|
|
|
|
}
|
|
|
|
|
mmc: core: Add support for idle time BKOPS
Devices have various maintenance operations need to perform internally.
In order to reduce latencies during time critical operations like read
and write, it is better to execute maintenance operations in other
times - when the host is not being serviced. Such operations are called
Background operations (BKOPS).
The device notifies the status of the BKOPS need by updating BKOPS_STATUS
(EXT_CSD byte [246]).
According to the standard a host that supports BKOPS shall check the
status periodically and start background operations as needed, so that
the device has enough time for its maintenance operations.
This patch adds support for this periodic check of the BKOPS status.
Since foreground operations are of higher priority than background
operations the host will check the need for BKOPS when it is idle,
and in case of an incoming request the BKOPS operation will be
interrupted.
When the mmcqd thread is idle, a delayed work is created to check the
need for BKOPS. The time to start the delayed work is calculated based
on the host controller suspend timeout, in case it was set. If not, a
default time is used.
If BKOPS are required in level 1, which is non-blocking, there will be
polling of the card status to wait for the BKOPS completion and prevent
suspend that will interrupt the BKOPS.
If the card raised an exception, the need for urgent BKOPS (level 2/3)
will be checked immediately and if needed, the BKOPS will be performed
without waiting for the next idle time.
Change-Id: I7460afea1bc94498a93ff6553276b994d3bba012
Signed-off-by: Maya Erez <merez@codeaurora.org>
2012-10-10 01:47:54 +00:00
|
|
|
/**
|
|
|
|
* mmc_start_delayed_bkops() - Start a delayed work to check for
|
|
|
|
* the need of non urgent BKOPS
|
|
|
|
*
|
|
|
|
* @card: MMC card to start BKOPS on
|
|
|
|
*/
|
|
|
|
void mmc_start_delayed_bkops(struct mmc_card *card)
|
|
|
|
{
|
2014-12-30 09:24:39 +00:00
|
|
|
if (!card ||
|
|
|
|
!(mmc_card_get_bkops_en_manual(card)) ||
|
|
|
|
mmc_card_doing_bkops(card))
|
mmc: core: Add support for idle time BKOPS
Devices have various maintenance operations need to perform internally.
In order to reduce latencies during time critical operations like read
and write, it is better to execute maintenance operations in other
times - when the host is not being serviced. Such operations are called
Background operations (BKOPS).
The device notifies the status of the BKOPS need by updating BKOPS_STATUS
(EXT_CSD byte [246]).
According to the standard a host that supports BKOPS shall check the
status periodically and start background operations as needed, so that
the device has enough time for its maintenance operations.
This patch adds support for this periodic check of the BKOPS status.
Since foreground operations are of higher priority than background
operations the host will check the need for BKOPS when it is idle,
and in case of an incoming request the BKOPS operation will be
interrupted.
When the mmcqd thread is idle, a delayed work is created to check the
need for BKOPS. The time to start the delayed work is calculated based
on the host controller suspend timeout, in case it was set. If not, a
default time is used.
If BKOPS are required in level 1, which is non-blocking, there will be
polling of the card status to wait for the BKOPS completion and prevent
suspend that will interrupt the BKOPS.
If the card raised an exception, the need for urgent BKOPS (level 2/3)
will be checked immediately and if needed, the BKOPS will be performed
without waiting for the next idle time.
Change-Id: I7460afea1bc94498a93ff6553276b994d3bba012
Signed-off-by: Maya Erez <merez@codeaurora.org>
2012-10-10 01:47:54 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
if (card->bkops_info.sectors_changed <
|
2012-10-11 09:36:24 +00:00
|
|
|
card->bkops_info.min_sectors_to_queue_delayed_work)
|
mmc: core: Add support for idle time BKOPS
Devices have various maintenance operations need to perform internally.
In order to reduce latencies during time critical operations like read
and write, it is better to execute maintenance operations in other
times - when the host is not being serviced. Such operations are called
Background operations (BKOPS).
The device notifies the status of the BKOPS need by updating BKOPS_STATUS
(EXT_CSD byte [246]).
According to the standard a host that supports BKOPS shall check the
status periodically and start background operations as needed, so that
the device has enough time for its maintenance operations.
This patch adds support for this periodic check of the BKOPS status.
Since foreground operations are of higher priority than background
operations the host will check the need for BKOPS when it is idle,
and in case of an incoming request the BKOPS operation will be
interrupted.
When the mmcqd thread is idle, a delayed work is created to check the
need for BKOPS. The time to start the delayed work is calculated based
on the host controller suspend timeout, in case it was set. If not, a
default time is used.
If BKOPS are required in level 1, which is non-blocking, there will be
polling of the card status to wait for the BKOPS completion and prevent
suspend that will interrupt the BKOPS.
If the card raised an exception, the need for urgent BKOPS (level 2/3)
will be checked immediately and if needed, the BKOPS will be performed
without waiting for the next idle time.
Change-Id: I7460afea1bc94498a93ff6553276b994d3bba012
Signed-off-by: Maya Erez <merez@codeaurora.org>
2012-10-10 01:47:54 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
pr_debug("%s: %s: queueing delayed_bkops_work\n",
|
|
|
|
mmc_hostname(card->host), __func__);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* cancel_delayed_bkops_work will prevent a race condition between
|
|
|
|
* fetching a request by the mmcqd and the delayed work, in case
|
|
|
|
* it was removed from the queue work but not started yet
|
|
|
|
*/
|
|
|
|
card->bkops_info.cancel_delayed_work = false;
|
|
|
|
queue_delayed_work(system_nrt_wq, &card->bkops_info.dw,
|
|
|
|
msecs_to_jiffies(
|
|
|
|
card->bkops_info.delay_ms));
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mmc_start_delayed_bkops);
|
|
|
|
|
2012-09-17 08:42:02 +00:00
|
|
|
/**
|
|
|
|
* mmc_start_bkops - start BKOPS for supported cards
|
|
|
|
* @card: MMC card to start BKOPS
|
mmc: core: Add support for idle time BKOPS
Devices have various maintenance operations need to perform internally.
In order to reduce latencies during time critical operations like read
and write, it is better to execute maintenance operations in other
times - when the host is not being serviced. Such operations are called
Background operations (BKOPS).
The device notifies the status of the BKOPS need by updating BKOPS_STATUS
(EXT_CSD byte [246]).
According to the standard a host that supports BKOPS shall check the
status periodically and start background operations as needed, so that
the device has enough time for its maintenance operations.
This patch adds support for this periodic check of the BKOPS status.
Since foreground operations are of higher priority than background
operations the host will check the need for BKOPS when it is idle,
and in case of an incoming request the BKOPS operation will be
interrupted.
When the mmcqd thread is idle, a delayed work is created to check the
need for BKOPS. The time to start the delayed work is calculated based
on the host controller suspend timeout, in case it was set. If not, a
default time is used.
If BKOPS are required in level 1, which is non-blocking, there will be
polling of the card status to wait for the BKOPS completion and prevent
suspend that will interrupt the BKOPS.
If the card raised an exception, the need for urgent BKOPS (level 2/3)
will be checked immediately and if needed, the BKOPS will be performed
without waiting for the next idle time.
Change-Id: I7460afea1bc94498a93ff6553276b994d3bba012
Signed-off-by: Maya Erez <merez@codeaurora.org>
2012-10-10 01:47:54 +00:00
|
|
|
* @from_exception: A flag to indicate if this function was
|
2012-09-17 08:42:02 +00:00
|
|
|
* called due to an exception raised by the card
|
|
|
|
*
|
|
|
|
* Start background operations whenever requested.
|
|
|
|
* When the urgent BKOPS bit is set in a R1 command response
|
|
|
|
* then background operations should be started immediately.
|
|
|
|
*/
|
|
|
|
void mmc_start_bkops(struct mmc_card *card, bool from_exception)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
BUG_ON(!card);
|
2014-12-30 09:24:39 +00:00
|
|
|
if (!(mmc_card_get_bkops_en_manual(card)))
|
2012-09-17 08:42:02 +00:00
|
|
|
return;
|
|
|
|
|
2013-01-24 10:54:03 +00:00
|
|
|
if ((card->bkops_info.cancel_delayed_work) && !from_exception) {
|
|
|
|
pr_debug("%s: %s: cancel_delayed_work was set, exit\n",
|
|
|
|
mmc_hostname(card->host), __func__);
|
|
|
|
card->bkops_info.cancel_delayed_work = false;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-02-11 10:01:35 +00:00
|
|
|
mmc_rpm_hold(card->host, &card->dev);
|
2013-01-29 19:42:02 +00:00
|
|
|
/* In case of delayed bkops we might be in race with suspend. */
|
2013-02-11 10:01:35 +00:00
|
|
|
if (!mmc_try_claim_host(card->host)) {
|
|
|
|
mmc_rpm_release(card->host, &card->dev);
|
2013-01-29 19:42:02 +00:00
|
|
|
return;
|
2013-02-11 10:01:35 +00:00
|
|
|
}
|
mmc: core: Add support for idle time BKOPS
Devices have various maintenance operations need to perform internally.
In order to reduce latencies during time critical operations like read
and write, it is better to execute maintenance operations in other
times - when the host is not being serviced. Such operations are called
Background operations (BKOPS).
The device notifies the status of the BKOPS need by updating BKOPS_STATUS
(EXT_CSD byte [246]).
According to the standard a host that supports BKOPS shall check the
status periodically and start background operations as needed, so that
the device has enough time for its maintenance operations.
This patch adds support for this periodic check of the BKOPS status.
Since foreground operations are of higher priority than background
operations the host will check the need for BKOPS when it is idle,
and in case of an incoming request the BKOPS operation will be
interrupted.
When the mmcqd thread is idle, a delayed work is created to check the
need for BKOPS. The time to start the delayed work is calculated based
on the host controller suspend timeout, in case it was set. If not, a
default time is used.
If BKOPS are required in level 1, which is non-blocking, there will be
polling of the card status to wait for the BKOPS completion and prevent
suspend that will interrupt the BKOPS.
If the card raised an exception, the need for urgent BKOPS (level 2/3)
will be checked immediately and if needed, the BKOPS will be performed
without waiting for the next idle time.
Change-Id: I7460afea1bc94498a93ff6553276b994d3bba012
Signed-off-by: Maya Erez <merez@codeaurora.org>
2012-10-10 01:47:54 +00:00
|
|
|
|
2013-01-24 10:54:03 +00:00
|
|
|
/*
|
|
|
|
* Since the cancel_delayed_work can be changed while we are waiting
|
|
|
|
* for the lock we will to re-check it
|
|
|
|
*/
|
mmc: core: Add support for idle time BKOPS
Devices have various maintenance operations need to perform internally.
In order to reduce latencies during time critical operations like read
and write, it is better to execute maintenance operations in other
times - when the host is not being serviced. Such operations are called
Background operations (BKOPS).
The device notifies the status of the BKOPS need by updating BKOPS_STATUS
(EXT_CSD byte [246]).
According to the standard a host that supports BKOPS shall check the
status periodically and start background operations as needed, so that
the device has enough time for its maintenance operations.
This patch adds support for this periodic check of the BKOPS status.
Since foreground operations are of higher priority than background
operations the host will check the need for BKOPS when it is idle,
and in case of an incoming request the BKOPS operation will be
interrupted.
When the mmcqd thread is idle, a delayed work is created to check the
need for BKOPS. The time to start the delayed work is calculated based
on the host controller suspend timeout, in case it was set. If not, a
default time is used.
If BKOPS are required in level 1, which is non-blocking, there will be
polling of the card status to wait for the BKOPS completion and prevent
suspend that will interrupt the BKOPS.
If the card raised an exception, the need for urgent BKOPS (level 2/3)
will be checked immediately and if needed, the BKOPS will be performed
without waiting for the next idle time.
Change-Id: I7460afea1bc94498a93ff6553276b994d3bba012
Signed-off-by: Maya Erez <merez@codeaurora.org>
2012-10-10 01:47:54 +00:00
|
|
|
if ((card->bkops_info.cancel_delayed_work) && !from_exception) {
|
|
|
|
pr_debug("%s: %s: cancel_delayed_work was set, exit\n",
|
|
|
|
mmc_hostname(card->host), __func__);
|
|
|
|
card->bkops_info.cancel_delayed_work = false;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mmc_card_doing_bkops(card)) {
|
|
|
|
pr_debug("%s: %s: already doing bkops, exit\n",
|
|
|
|
mmc_hostname(card->host), __func__);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2013-01-04 08:55:00 +00:00
|
|
|
if (from_exception && mmc_card_need_bkops(card))
|
mmc: core: Add support for idle time BKOPS
Devices have various maintenance operations need to perform internally.
In order to reduce latencies during time critical operations like read
and write, it is better to execute maintenance operations in other
times - when the host is not being serviced. Such operations are called
Background operations (BKOPS).
The device notifies the status of the BKOPS need by updating BKOPS_STATUS
(EXT_CSD byte [246]).
According to the standard a host that supports BKOPS shall check the
status periodically and start background operations as needed, so that
the device has enough time for its maintenance operations.
This patch adds support for this periodic check of the BKOPS status.
Since foreground operations are of higher priority than background
operations the host will check the need for BKOPS when it is idle,
and in case of an incoming request the BKOPS operation will be
interrupted.
When the mmcqd thread is idle, a delayed work is created to check the
need for BKOPS. The time to start the delayed work is calculated based
on the host controller suspend timeout, in case it was set. If not, a
default time is used.
If BKOPS are required in level 1, which is non-blocking, there will be
polling of the card status to wait for the BKOPS completion and prevent
suspend that will interrupt the BKOPS.
If the card raised an exception, the need for urgent BKOPS (level 2/3)
will be checked immediately and if needed, the BKOPS will be performed
without waiting for the next idle time.
Change-Id: I7460afea1bc94498a93ff6553276b994d3bba012
Signed-off-by: Maya Erez <merez@codeaurora.org>
2012-10-10 01:47:54 +00:00
|
|
|
goto out;
|
2012-09-17 08:42:02 +00:00
|
|
|
|
2013-01-04 08:55:00 +00:00
|
|
|
/*
|
|
|
|
* If the need BKOPS flag is set, there is no need to check if BKOPS
|
|
|
|
* is needed since we already know that it does
|
|
|
|
*/
|
|
|
|
if (!mmc_card_need_bkops(card)) {
|
|
|
|
err = mmc_read_bkops_status(card);
|
|
|
|
if (err) {
|
|
|
|
pr_err("%s: %s: Failed to read bkops status: %d\n",
|
|
|
|
mmc_hostname(card->host), __func__, err);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!card->ext_csd.raw_bkops_status)
|
|
|
|
goto out;
|
mmc: core: Add support for idle time BKOPS
Devices have various maintenance operations need to perform internally.
In order to reduce latencies during time critical operations like read
and write, it is better to execute maintenance operations in other
times - when the host is not being serviced. Such operations are called
Background operations (BKOPS).
The device notifies the status of the BKOPS need by updating BKOPS_STATUS
(EXT_CSD byte [246]).
According to the standard a host that supports BKOPS shall check the
status periodically and start background operations as needed, so that
the device has enough time for its maintenance operations.
This patch adds support for this periodic check of the BKOPS status.
Since foreground operations are of higher priority than background
operations the host will check the need for BKOPS when it is idle,
and in case of an incoming request the BKOPS operation will be
interrupted.
When the mmcqd thread is idle, a delayed work is created to check the
need for BKOPS. The time to start the delayed work is calculated based
on the host controller suspend timeout, in case it was set. If not, a
default time is used.
If BKOPS are required in level 1, which is non-blocking, there will be
polling of the card status to wait for the BKOPS completion and prevent
suspend that will interrupt the BKOPS.
If the card raised an exception, the need for urgent BKOPS (level 2/3)
will be checked immediately and if needed, the BKOPS will be performed
without waiting for the next idle time.
Change-Id: I7460afea1bc94498a93ff6553276b994d3bba012
Signed-off-by: Maya Erez <merez@codeaurora.org>
2012-10-10 01:47:54 +00:00
|
|
|
|
2013-01-04 08:55:00 +00:00
|
|
|
pr_info("%s: %s: raw_bkops_status=0x%x, from_exception=%d\n",
|
|
|
|
mmc_hostname(card->host), __func__,
|
|
|
|
card->ext_csd.raw_bkops_status,
|
|
|
|
from_exception);
|
|
|
|
}
|
2012-09-17 08:42:02 +00:00
|
|
|
|
mmc: core: Add support for idle time BKOPS
Devices have various maintenance operations need to perform internally.
In order to reduce latencies during time critical operations like read
and write, it is better to execute maintenance operations in other
times - when the host is not being serviced. Such operations are called
Background operations (BKOPS).
The device notifies the status of the BKOPS need by updating BKOPS_STATUS
(EXT_CSD byte [246]).
According to the standard a host that supports BKOPS shall check the
status periodically and start background operations as needed, so that
the device has enough time for its maintenance operations.
This patch adds support for this periodic check of the BKOPS status.
Since foreground operations are of higher priority than background
operations the host will check the need for BKOPS when it is idle,
and in case of an incoming request the BKOPS operation will be
interrupted.
When the mmcqd thread is idle, a delayed work is created to check the
need for BKOPS. The time to start the delayed work is calculated based
on the host controller suspend timeout, in case it was set. If not, a
default time is used.
If BKOPS are required in level 1, which is non-blocking, there will be
polling of the card status to wait for the BKOPS completion and prevent
suspend that will interrupt the BKOPS.
If the card raised an exception, the need for urgent BKOPS (level 2/3)
will be checked immediately and if needed, the BKOPS will be performed
without waiting for the next idle time.
Change-Id: I7460afea1bc94498a93ff6553276b994d3bba012
Signed-off-by: Maya Erez <merez@codeaurora.org>
2012-10-10 01:47:54 +00:00
|
|
|
/*
|
2013-01-04 08:55:00 +00:00
|
|
|
* If the function was called due to exception, BKOPS will be performed
|
|
|
|
* after handling the last pending request
|
mmc: core: Add support for idle time BKOPS
Devices have various maintenance operations need to perform internally.
In order to reduce latencies during time critical operations like read
and write, it is better to execute maintenance operations in other
times - when the host is not being serviced. Such operations are called
Background operations (BKOPS).
The device notifies the status of the BKOPS need by updating BKOPS_STATUS
(EXT_CSD byte [246]).
According to the standard a host that supports BKOPS shall check the
status periodically and start background operations as needed, so that
the device has enough time for its maintenance operations.
This patch adds support for this periodic check of the BKOPS status.
Since foreground operations are of higher priority than background
operations the host will check the need for BKOPS when it is idle,
and in case of an incoming request the BKOPS operation will be
interrupted.
When the mmcqd thread is idle, a delayed work is created to check the
need for BKOPS. The time to start the delayed work is calculated based
on the host controller suspend timeout, in case it was set. If not, a
default time is used.
If BKOPS are required in level 1, which is non-blocking, there will be
polling of the card status to wait for the BKOPS completion and prevent
suspend that will interrupt the BKOPS.
If the card raised an exception, the need for urgent BKOPS (level 2/3)
will be checked immediately and if needed, the BKOPS will be performed
without waiting for the next idle time.
Change-Id: I7460afea1bc94498a93ff6553276b994d3bba012
Signed-off-by: Maya Erez <merez@codeaurora.org>
2012-10-10 01:47:54 +00:00
|
|
|
*/
|
2013-01-04 08:55:00 +00:00
|
|
|
if (from_exception) {
|
|
|
|
pr_debug("%s: %s: Level %d from exception, exit",
|
|
|
|
mmc_hostname(card->host), __func__,
|
|
|
|
card->ext_csd.raw_bkops_status);
|
|
|
|
mmc_card_set_need_bkops(card);
|
mmc: core: Add support for idle time BKOPS
Devices have various maintenance operations need to perform internally.
In order to reduce latencies during time critical operations like read
and write, it is better to execute maintenance operations in other
times - when the host is not being serviced. Such operations are called
Background operations (BKOPS).
The device notifies the status of the BKOPS need by updating BKOPS_STATUS
(EXT_CSD byte [246]).
According to the standard a host that supports BKOPS shall check the
status periodically and start background operations as needed, so that
the device has enough time for its maintenance operations.
This patch adds support for this periodic check of the BKOPS status.
Since foreground operations are of higher priority than background
operations the host will check the need for BKOPS when it is idle,
and in case of an incoming request the BKOPS operation will be
interrupted.
When the mmcqd thread is idle, a delayed work is created to check the
need for BKOPS. The time to start the delayed work is calculated based
on the host controller suspend timeout, in case it was set. If not, a
default time is used.
If BKOPS are required in level 1, which is non-blocking, there will be
polling of the card status to wait for the BKOPS completion and prevent
suspend that will interrupt the BKOPS.
If the card raised an exception, the need for urgent BKOPS (level 2/3)
will be checked immediately and if needed, the BKOPS will be performed
without waiting for the next idle time.
Change-Id: I7460afea1bc94498a93ff6553276b994d3bba012
Signed-off-by: Maya Erez <merez@codeaurora.org>
2012-10-10 01:47:54 +00:00
|
|
|
goto out;
|
2012-10-18 11:58:18 +00:00
|
|
|
}
|
2013-01-04 08:55:00 +00:00
|
|
|
pr_info("%s: %s: Starting bkops\n", mmc_hostname(card->host), __func__);
|
2012-09-17 08:42:02 +00:00
|
|
|
|
|
|
|
err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
|
2013-01-04 08:55:00 +00:00
|
|
|
EXT_CSD_BKOPS_START, 1, 0, false, false);
|
2012-09-17 08:42:02 +00:00
|
|
|
if (err) {
|
2012-10-18 11:58:18 +00:00
|
|
|
pr_warn("%s: %s: Error %d when starting bkops\n",
|
|
|
|
mmc_hostname(card->host), __func__, err);
|
2012-09-17 08:42:02 +00:00
|
|
|
goto out;
|
|
|
|
}
|
2012-10-11 16:29:28 +00:00
|
|
|
MMC_UPDATE_STATS_BKOPS_SEVERITY_LEVEL(card->bkops_info.bkops_stats,
|
|
|
|
card->ext_csd.raw_bkops_status);
|
2013-01-04 08:55:00 +00:00
|
|
|
mmc_card_clr_need_bkops(card);
|
2012-09-17 08:42:02 +00:00
|
|
|
|
2013-01-04 08:55:00 +00:00
|
|
|
mmc_card_set_doing_bkops(card);
|
2012-09-17 08:42:02 +00:00
|
|
|
out:
|
|
|
|
mmc_release_host(card->host);
|
2013-02-11 10:01:35 +00:00
|
|
|
mmc_rpm_release(card->host, &card->dev);
|
2012-09-17 08:42:02 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mmc_start_bkops);
|
|
|
|
|
2013-01-14 19:28:17 +00:00
|
|
|
/*
|
|
|
|
* mmc_wait_data_done() - done callback for data request
|
|
|
|
* @mrq: done data request
|
|
|
|
*
|
|
|
|
* Wakes up mmc context, passed as a callback to host controller driver
|
|
|
|
*/
|
|
|
|
static void mmc_wait_data_done(struct mmc_request *mrq)
|
|
|
|
{
|
2014-06-11 07:59:42 +00:00
|
|
|
unsigned long flags;
|
|
|
|
struct mmc_context_info *context_info = &mrq->host->context_info;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&context_info->lock, flags);
|
2013-01-14 19:28:17 +00:00
|
|
|
mrq->host->context_info.is_done_rcv = true;
|
|
|
|
wake_up_interruptible(&mrq->host->context_info.wait);
|
2014-06-11 07:59:42 +00:00
|
|
|
spin_unlock_irqrestore(&context_info->lock, flags);
|
2013-01-14 19:28:17 +00:00
|
|
|
}
|
|
|
|
|
mmc: core: Add support for idle time BKOPS
Devices have various maintenance operations need to perform internally.
In order to reduce latencies during time critical operations like read
and write, it is better to execute maintenance operations in other
times - when the host is not being serviced. Such operations are called
Background operations (BKOPS).
The device notifies the status of the BKOPS need by updating BKOPS_STATUS
(EXT_CSD byte [246]).
According to the standard a host that supports BKOPS shall check the
status periodically and start background operations as needed, so that
the device has enough time for its maintenance operations.
This patch adds support for this periodic check of the BKOPS status.
Since foreground operations are of higher priority than background
operations the host will check the need for BKOPS when it is idle,
and in case of an incoming request the BKOPS operation will be
interrupted.
When the mmcqd thread is idle, a delayed work is created to check the
need for BKOPS. The time to start the delayed work is calculated based
on the host controller suspend timeout, in case it was set. If not, a
default time is used.
If BKOPS are required in level 1, which is non-blocking, there will be
polling of the card status to wait for the BKOPS completion and prevent
suspend that will interrupt the BKOPS.
If the card raised an exception, the need for urgent BKOPS (level 2/3)
will be checked immediately and if needed, the BKOPS will be performed
without waiting for the next idle time.
Change-Id: I7460afea1bc94498a93ff6553276b994d3bba012
Signed-off-by: Maya Erez <merez@codeaurora.org>
2012-10-10 01:47:54 +00:00
|
|
|
/**
|
|
|
|
* mmc_start_idle_time_bkops() - check if a non urgent BKOPS is
|
|
|
|
* needed
|
|
|
|
* @work: The idle time BKOPS work
|
|
|
|
*/
|
|
|
|
void mmc_start_idle_time_bkops(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct mmc_card *card = container_of(work, struct mmc_card,
|
|
|
|
bkops_info.dw.work);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Prevent a race condition between mmc_stop_bkops and the delayed
|
|
|
|
* BKOPS work in case the delayed work is executed on another CPU
|
|
|
|
*/
|
|
|
|
if (card->bkops_info.cancel_delayed_work)
|
|
|
|
return;
|
|
|
|
|
|
|
|
mmc_start_bkops(card, false);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mmc_start_idle_time_bkops);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static void mmc_wait_done(struct mmc_request *mrq)
|
|
|
|
{
|
2011-07-01 16:55:22 +00:00
|
|
|
complete(&mrq->completion);
|
|
|
|
}
|
|
|
|
|
2013-01-14 19:28:17 +00:00
|
|
|
/*
|
|
|
|
*__mmc_start_data_req() - starts data request
|
|
|
|
* @host: MMC host to start the request
|
|
|
|
* @mrq: data request to start
|
|
|
|
*
|
|
|
|
* Sets the done callback to be called when request is completed by the card.
|
|
|
|
* Starts data mmc request execution
|
|
|
|
*/
|
|
|
|
static int __mmc_start_data_req(struct mmc_host *host, struct mmc_request *mrq)
|
|
|
|
{
|
|
|
|
mrq->done = mmc_wait_data_done;
|
|
|
|
mrq->host = host;
|
|
|
|
if (mmc_card_removed(host->card)) {
|
|
|
|
mrq->cmd->error = -ENOMEDIUM;
|
2013-01-22 10:48:03 +00:00
|
|
|
mmc_wait_data_done(mrq);
|
2013-01-14 19:28:17 +00:00
|
|
|
return -ENOMEDIUM;
|
|
|
|
}
|
|
|
|
mmc_start_request(host, mrq);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-03-05 14:52:43 +00:00
|
|
|
static int __mmc_start_req(struct mmc_host *host, struct mmc_request *mrq)
|
2011-07-01 16:55:22 +00:00
|
|
|
{
|
|
|
|
init_completion(&mrq->completion);
|
|
|
|
mrq->done = mmc_wait_done;
|
2011-11-28 14:22:00 +00:00
|
|
|
if (mmc_card_removed(host->card)) {
|
|
|
|
mrq->cmd->error = -ENOMEDIUM;
|
|
|
|
complete(&mrq->completion);
|
2012-03-05 14:52:43 +00:00
|
|
|
return -ENOMEDIUM;
|
2011-11-28 14:22:00 +00:00
|
|
|
}
|
2011-07-01 16:55:22 +00:00
|
|
|
mmc_start_request(host, mrq);
|
2012-03-05 14:52:43 +00:00
|
|
|
return 0;
|
2011-07-01 16:55:22 +00:00
|
|
|
}
|
|
|
|
|
2013-04-15 09:54:35 +00:00
|
|
|
/*
|
|
|
|
* mmc_should_stop_curr_req() - check for stop flow rationality
|
|
|
|
* @host: MMC host running request.
|
|
|
|
*
|
|
|
|
* Check possibility to interrupt current running request
|
|
|
|
* Returns true in case it is worth to stop transfer,
|
|
|
|
* false otherwise
|
|
|
|
*/
|
|
|
|
static bool mmc_should_stop_curr_req(struct mmc_host *host)
|
|
|
|
{
|
|
|
|
int remainder;
|
|
|
|
|
2013-04-15 10:51:47 +00:00
|
|
|
if (host->areq->cmd_flags & REQ_URGENT ||
|
|
|
|
!(host->areq->cmd_flags & REQ_WRITE) ||
|
|
|
|
(host->areq->cmd_flags & REQ_FUA))
|
|
|
|
return false;
|
|
|
|
|
2014-10-16 05:13:00 +00:00
|
|
|
mmc_host_clk_hold(host);
|
2013-04-15 09:54:35 +00:00
|
|
|
remainder = (host->ops->get_xfer_remain) ?
|
|
|
|
host->ops->get_xfer_remain(host) : -1;
|
2014-10-16 05:13:00 +00:00
|
|
|
mmc_host_clk_release(host);
|
2013-04-15 09:54:35 +00:00
|
|
|
return (remainder > 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* mmc_stop_request() - Stops current running request
|
|
|
|
* @host: MMC host to prepare the command.
|
|
|
|
*
|
|
|
|
* Triggers stop flow in the host driver and sends CMD12 (stop command) to the
|
|
|
|
* card. Sends HPI to get the card out of R1_STATE_PRG immediately
|
|
|
|
*
|
|
|
|
* Returns 0 when success, error propagated otherwise
|
|
|
|
*/
|
|
|
|
static int mmc_stop_request(struct mmc_host *host)
|
|
|
|
{
|
|
|
|
struct mmc_command cmd = {0};
|
|
|
|
struct mmc_card *card = host->card;
|
|
|
|
int err = 0;
|
|
|
|
u32 status;
|
|
|
|
|
2013-08-22 07:53:55 +00:00
|
|
|
if (!host->ops->stop_request || !card->ext_csd.hpi_en) {
|
2013-04-15 09:54:35 +00:00
|
|
|
pr_warn("%s: host ops stop_request() or HPI not supported\n",
|
|
|
|
mmc_hostname(host));
|
|
|
|
return -ENOTSUPP;
|
|
|
|
}
|
2014-10-16 05:13:00 +00:00
|
|
|
mmc_host_clk_hold(host);
|
2013-04-15 09:54:35 +00:00
|
|
|
err = host->ops->stop_request(host);
|
|
|
|
if (err) {
|
2014-06-10 12:14:20 +00:00
|
|
|
pr_debug("%s: Call to host->ops->stop_request() failed (%d)\n",
|
2013-04-15 09:54:35 +00:00
|
|
|
mmc_hostname(host), err);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
cmd.opcode = MMC_STOP_TRANSMISSION;
|
|
|
|
cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
|
|
|
|
err = mmc_wait_for_cmd(host, &cmd, 0);
|
|
|
|
if (err) {
|
|
|
|
err = mmc_send_status(card, &status);
|
|
|
|
if (err) {
|
|
|
|
pr_err("%s: Get card status fail\n",
|
|
|
|
mmc_hostname(card->host));
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
switch (R1_CURRENT_STATE(status)) {
|
|
|
|
case R1_STATE_DATA:
|
|
|
|
case R1_STATE_RCV:
|
|
|
|
pr_err("%s: CMD12 fails with error (%d)\n",
|
|
|
|
mmc_hostname(host), err);
|
|
|
|
goto out;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
err = mmc_interrupt_hpi(card);
|
|
|
|
if (err) {
|
|
|
|
pr_err("%s: mmc_interrupt_hpi() failed (%d)\n",
|
|
|
|
mmc_hostname(host), err);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
out:
|
2014-10-16 05:13:00 +00:00
|
|
|
mmc_host_clk_release(host);
|
2013-04-15 09:54:35 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2013-01-14 19:28:17 +00:00
|
|
|
/*
|
|
|
|
* mmc_wait_for_data_req_done() - wait for request completed
|
|
|
|
* @host: MMC host to prepare the command.
|
|
|
|
* @mrq: MMC request to wait for
|
|
|
|
*
|
|
|
|
* Blocks MMC context till host controller will ack end of data request
|
|
|
|
* execution or new request notification arrives from the block layer.
|
|
|
|
* Handles command retries.
|
|
|
|
*
|
|
|
|
* Returns enum mmc_blk_status after checking errors.
|
|
|
|
*/
|
|
|
|
static int mmc_wait_for_data_req_done(struct mmc_host *host,
|
|
|
|
struct mmc_request *mrq,
|
|
|
|
struct mmc_async_req *next_req)
|
|
|
|
{
|
|
|
|
struct mmc_command *cmd;
|
|
|
|
struct mmc_context_info *context_info = &host->context_info;
|
2013-04-15 09:54:35 +00:00
|
|
|
bool pending_is_urgent = false;
|
|
|
|
bool is_urgent = false;
|
2014-06-11 07:59:42 +00:00
|
|
|
bool is_done_rcv = false;
|
2014-04-28 10:57:54 +00:00
|
|
|
int err, ret;
|
2013-01-14 19:28:17 +00:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
while (1) {
|
2014-04-28 10:57:54 +00:00
|
|
|
ret = wait_io_event_interruptible(context_info->wait,
|
2013-01-14 19:28:17 +00:00
|
|
|
(context_info->is_done_rcv ||
|
2013-04-15 09:54:35 +00:00
|
|
|
context_info->is_new_req ||
|
|
|
|
context_info->is_urgent));
|
2013-01-14 19:28:17 +00:00
|
|
|
spin_lock_irqsave(&context_info->lock, flags);
|
2013-04-15 09:54:35 +00:00
|
|
|
is_urgent = context_info->is_urgent;
|
2014-06-11 07:59:42 +00:00
|
|
|
is_done_rcv = context_info->is_done_rcv;
|
2013-01-14 19:28:17 +00:00
|
|
|
context_info->is_waiting_last_req = false;
|
|
|
|
spin_unlock_irqrestore(&context_info->lock, flags);
|
2014-06-11 07:59:42 +00:00
|
|
|
if (is_done_rcv) {
|
2013-01-14 19:28:17 +00:00
|
|
|
context_info->is_done_rcv = false;
|
|
|
|
context_info->is_new_req = false;
|
|
|
|
cmd = mrq->cmd;
|
2013-04-18 12:48:00 +00:00
|
|
|
|
2013-01-14 19:28:17 +00:00
|
|
|
if (!cmd->error || !cmd->retries ||
|
|
|
|
mmc_card_removed(host->card)) {
|
|
|
|
err = host->areq->err_check(host->card,
|
2013-04-15 09:54:35 +00:00
|
|
|
host->areq);
|
|
|
|
if (pending_is_urgent || is_urgent) {
|
|
|
|
/*
|
|
|
|
* all the success/partial operations
|
|
|
|
* are done in an addition to handling
|
|
|
|
* the urgent request
|
|
|
|
*/
|
|
|
|
if ((err == MMC_BLK_PARTIAL) ||
|
|
|
|
(err == MMC_BLK_SUCCESS))
|
2013-04-15 10:51:47 +00:00
|
|
|
err = pending_is_urgent ?
|
|
|
|
MMC_BLK_URGENT_DONE
|
|
|
|
: MMC_BLK_URGENT;
|
|
|
|
|
2013-04-15 09:54:35 +00:00
|
|
|
/* reset is_urgent for next request */
|
|
|
|
context_info->is_urgent = false;
|
|
|
|
}
|
2013-01-14 19:28:17 +00:00
|
|
|
break; /* return err */
|
|
|
|
} else {
|
|
|
|
pr_info("%s: req failed (CMD%u): %d, retrying...\n",
|
|
|
|
mmc_hostname(host),
|
|
|
|
cmd->opcode, cmd->error);
|
|
|
|
cmd->retries--;
|
|
|
|
cmd->error = 0;
|
|
|
|
host->ops->request(host, mrq);
|
2013-04-15 09:54:35 +00:00
|
|
|
/*
|
|
|
|
* ignore urgent flow, request retry has greater
|
|
|
|
* priority than urgent flow
|
|
|
|
*/
|
|
|
|
context_info->is_urgent = false;
|
|
|
|
/* wait for done/new/urgent event again */
|
|
|
|
continue;
|
2013-01-14 19:28:17 +00:00
|
|
|
}
|
2013-04-15 09:54:35 +00:00
|
|
|
} else if (context_info->is_new_req && !is_urgent) {
|
2013-01-14 19:28:17 +00:00
|
|
|
context_info->is_new_req = false;
|
|
|
|
if (!next_req) {
|
|
|
|
err = MMC_BLK_NEW_REQUEST;
|
|
|
|
break; /* return err */
|
|
|
|
}
|
2014-04-28 10:57:54 +00:00
|
|
|
} else if (context_info->is_urgent) {
|
2013-04-15 09:54:35 +00:00
|
|
|
/*
|
|
|
|
* The case when block layer sent next urgent
|
|
|
|
* notification before it receives end_io on
|
|
|
|
* the current
|
|
|
|
*/
|
2013-07-28 13:28:48 +00:00
|
|
|
if (pending_is_urgent)
|
|
|
|
continue; /* wait for done/new/urgent event */
|
2013-04-15 09:54:35 +00:00
|
|
|
|
|
|
|
context_info->is_urgent = false;
|
|
|
|
context_info->is_new_req = false;
|
|
|
|
if (mmc_should_stop_curr_req(host)) {
|
2013-04-11 07:31:06 +00:00
|
|
|
/*
|
|
|
|
* We are going to stop the ongoing request.
|
|
|
|
* Update stuff that we ought to do when the
|
|
|
|
* request actually completes.
|
|
|
|
*/
|
2015-06-01 14:23:42 +00:00
|
|
|
mmc_update_clk_scaling(host, false);
|
2013-04-15 09:54:35 +00:00
|
|
|
err = mmc_stop_request(host);
|
2013-09-22 12:42:17 +00:00
|
|
|
if (err == MMC_BLK_NO_REQ_TO_STOP) {
|
|
|
|
pending_is_urgent = true;
|
|
|
|
/* wait for done/new/urgent event */
|
|
|
|
continue;
|
|
|
|
} else if (err && !context_info->is_done_rcv) {
|
2013-04-15 09:54:35 +00:00
|
|
|
err = MMC_BLK_ABORT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* running request has finished at this point */
|
|
|
|
if (context_info->is_done_rcv) {
|
|
|
|
err = host->areq->err_check(host->card,
|
|
|
|
host->areq);
|
|
|
|
context_info->is_done_rcv = false;
|
|
|
|
break; /* return err */
|
2013-08-15 08:56:24 +00:00
|
|
|
} else {
|
|
|
|
mmc_host_clk_release(host);
|
2013-04-15 09:54:35 +00:00
|
|
|
}
|
|
|
|
err = host->areq->update_interrupted_req(
|
|
|
|
host->card, host->areq);
|
|
|
|
if (!err)
|
|
|
|
err = MMC_BLK_URGENT;
|
|
|
|
break; /* return err */
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* The flow will back to wait for is_done_rcv,
|
|
|
|
* but in this case original is_urgent cleared.
|
|
|
|
* Mark pending_is_urgent to differentiate the
|
|
|
|
* case, when is_done_rcv and is_urgent really
|
|
|
|
* concurrent.
|
|
|
|
*/
|
|
|
|
pending_is_urgent = true;
|
|
|
|
continue; /* wait for done/new/urgent event */
|
|
|
|
}
|
2014-04-28 10:57:54 +00:00
|
|
|
} else {
|
|
|
|
pr_warn("%s: mmc thread unblocked from waiting by signal, ret=%d\n",
|
|
|
|
mmc_hostname(host),
|
|
|
|
ret);
|
|
|
|
continue;
|
2013-01-14 19:28:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2011-07-01 16:55:22 +00:00
|
|
|
static void mmc_wait_for_req_done(struct mmc_host *host,
|
|
|
|
struct mmc_request *mrq)
|
|
|
|
{
|
2011-10-03 12:33:33 +00:00
|
|
|
struct mmc_command *cmd;
|
|
|
|
|
|
|
|
while (1) {
|
2012-07-13 05:21:37 +00:00
|
|
|
wait_for_completion_io(&mrq->completion);
|
2011-10-03 12:33:33 +00:00
|
|
|
|
|
|
|
cmd = mrq->cmd;
|
2012-12-19 13:36:38 +00:00
|
|
|
|
|
|
|
/*
|
2013-06-25 07:43:24 +00:00
|
|
|
* If host has timed out waiting for the commands which can be
|
|
|
|
* HPIed then let the caller handle the timeout error as it may
|
|
|
|
* want to send the HPI command to bring the card out of
|
|
|
|
* programming state.
|
2012-12-19 13:36:38 +00:00
|
|
|
*/
|
2013-06-25 07:43:24 +00:00
|
|
|
if (cmd->ignore_timeout && cmd->error == -ETIMEDOUT)
|
|
|
|
break;
|
2012-12-19 13:36:38 +00:00
|
|
|
|
2011-11-28 14:22:00 +00:00
|
|
|
if (!cmd->error || !cmd->retries ||
|
|
|
|
mmc_card_removed(host->card))
|
2011-10-03 12:33:33 +00:00
|
|
|
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);
|
|
|
|
}
|
2011-07-01 16:55:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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)
|
|
|
|
{
|
2012-02-04 21:14:50 +00:00
|
|
|
if (host->ops->pre_req) {
|
|
|
|
mmc_host_clk_hold(host);
|
2011-07-01 16:55:22 +00:00
|
|
|
host->ops->pre_req(host, mrq, is_first_req);
|
2012-02-04 21:14:50 +00:00
|
|
|
mmc_host_clk_release(host);
|
|
|
|
}
|
2011-07-01 16:55:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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)
|
|
|
|
{
|
2012-02-04 21:14:50 +00:00
|
|
|
if (host->ops->post_req) {
|
|
|
|
mmc_host_clk_hold(host);
|
2011-07-01 16:55:22 +00:00
|
|
|
host->ops->post_req(host, mrq, err);
|
2012-02-04 21:14:50 +00:00
|
|
|
mmc_host_clk_release(host);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2015-05-20 11:22:04 +00:00
|
|
|
/**
|
|
|
|
* mmc_cmdq_discard_card_queue - discard the task[s] in the device
|
|
|
|
* @host: host instance
|
|
|
|
* @tasks: mask of tasks to be knocked off
|
|
|
|
* 0: remove all queued tasks
|
|
|
|
*/
|
|
|
|
int mmc_cmdq_discard_queue(struct mmc_host *host, u32 tasks)
|
|
|
|
{
|
|
|
|
return mmc_discard_queue(host, tasks);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mmc_cmdq_discard_queue);
|
|
|
|
|
|
|
|
|
2014-03-21 09:10:57 +00:00
|
|
|
/**
|
|
|
|
* mmc_cmdq_post_req - post process of a completed request
|
|
|
|
* @host: host instance
|
2015-09-27 16:21:01 +00:00
|
|
|
* @tag: the request tag.
|
2014-03-21 09:10:57 +00:00
|
|
|
* @err: non-zero is error, success otherwise
|
|
|
|
*/
|
2015-09-27 16:21:01 +00:00
|
|
|
void mmc_cmdq_post_req(struct mmc_host *host, int tag, int err)
|
2014-03-21 09:10:57 +00:00
|
|
|
{
|
|
|
|
if (likely(host->cmdq_ops->post_req))
|
2015-09-27 16:21:01 +00:00
|
|
|
host->cmdq_ops->post_req(host, tag, err);
|
2014-03-21 09:10:57 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mmc_cmdq_post_req);
|
|
|
|
|
2015-05-21 11:51:07 +00:00
|
|
|
/**
|
|
|
|
* mmc_cmdq_halt - halt/un-halt the command queue engine
|
|
|
|
* @host: host instance
|
|
|
|
* @halt: true - halt, un-halt otherwise
|
|
|
|
*
|
|
|
|
* Host halts the command queue engine. It should complete
|
|
|
|
* the ongoing transfer and release the bus.
|
|
|
|
* All legacy commands can be sent upon successful
|
|
|
|
* completion of this function.
|
|
|
|
* Returns 0 on success, negative otherwise
|
|
|
|
*/
|
|
|
|
int mmc_cmdq_halt(struct mmc_host *host, bool halt)
|
|
|
|
{
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
if ((halt && mmc_host_halt(host)) ||
|
2015-06-24 16:01:11 +00:00
|
|
|
(!halt && !mmc_host_halt(host))) {
|
|
|
|
pr_debug("%s: %s: CQE is already %s\n", mmc_hostname(host),
|
|
|
|
__func__, halt ? "halted" : "un-halted");
|
|
|
|
return 0;
|
|
|
|
}
|
2015-05-21 11:51:07 +00:00
|
|
|
|
2015-06-01 10:25:03 +00:00
|
|
|
mmc_host_clk_hold(host);
|
2015-05-21 11:51:07 +00:00
|
|
|
if (host->cmdq_ops->halt) {
|
|
|
|
err = host->cmdq_ops->halt(host, halt);
|
|
|
|
if (!err && halt)
|
|
|
|
mmc_host_set_halt(host);
|
|
|
|
else if (!err && !halt)
|
|
|
|
mmc_host_clr_halt(host);
|
|
|
|
} else {
|
|
|
|
err = -ENOSYS;
|
|
|
|
}
|
2015-06-01 10:25:03 +00:00
|
|
|
mmc_host_clk_release(host);
|
2015-05-21 11:51:07 +00:00
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mmc_cmdq_halt);
|
|
|
|
|
2014-03-21 09:10:57 +00:00
|
|
|
int mmc_cmdq_start_req(struct mmc_host *host, struct mmc_cmdq_req *cmdq_req)
|
|
|
|
{
|
|
|
|
struct mmc_request *mrq = &cmdq_req->mrq;
|
|
|
|
|
|
|
|
mrq->host = host;
|
|
|
|
if (mmc_card_removed(host->card)) {
|
|
|
|
mrq->cmd->error = -ENOMEDIUM;
|
|
|
|
return -ENOMEDIUM;
|
|
|
|
}
|
|
|
|
mmc_start_cmdq_request(host, mrq);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mmc_cmdq_start_req);
|
|
|
|
|
2015-04-23 04:30:27 +00:00
|
|
|
static void mmc_cmdq_dcmd_req_done(struct mmc_request *mrq)
|
|
|
|
{
|
2015-06-01 10:25:03 +00:00
|
|
|
mmc_host_clk_release(mrq->host);
|
2015-04-23 04:30:27 +00:00
|
|
|
complete(&mrq->completion);
|
|
|
|
}
|
|
|
|
|
|
|
|
int mmc_cmdq_wait_for_dcmd(struct mmc_host *host,
|
|
|
|
struct mmc_cmdq_req *cmdq_req)
|
|
|
|
{
|
|
|
|
struct mmc_request *mrq = &cmdq_req->mrq;
|
|
|
|
struct mmc_command *cmd = mrq->cmd;
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
init_completion(&mrq->completion);
|
|
|
|
mrq->done = mmc_cmdq_dcmd_req_done;
|
|
|
|
err = mmc_cmdq_start_req(host, cmdq_req);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
wait_for_completion_io(&mrq->completion);
|
|
|
|
if (cmd->error) {
|
|
|
|
pr_err("%s: DCMD %d failed with err %d\n",
|
|
|
|
mmc_hostname(host), cmd->opcode,
|
|
|
|
cmd->error);
|
|
|
|
err = cmd->error;
|
2015-07-09 07:28:07 +00:00
|
|
|
mmc_host_clk_hold(host);
|
|
|
|
host->cmdq_ops->dumpstate(host);
|
|
|
|
mmc_host_clk_release(host);
|
2015-04-23 04:30:27 +00:00
|
|
|
}
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mmc_cmdq_wait_for_dcmd);
|
|
|
|
|
2015-04-23 10:30:45 +00:00
|
|
|
int mmc_cmdq_prepare_flush(struct mmc_command *cmd)
|
|
|
|
{
|
|
|
|
return __mmc_switch_cmdq_mode(cmd, EXT_CSD_CMD_SET_NORMAL,
|
|
|
|
EXT_CSD_FLUSH_CACHE, 1,
|
|
|
|
0, true, true);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mmc_cmdq_prepare_flush);
|
|
|
|
|
2011-07-01 16:55:22 +00:00
|
|
|
/**
|
|
|
|
* 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;
|
2012-03-05 14:52:43 +00:00
|
|
|
int start_err = 0;
|
2011-07-01 16:55:22 +00:00
|
|
|
struct mmc_async_req *data = host->areq;
|
2013-04-15 10:51:47 +00:00
|
|
|
unsigned long flags;
|
|
|
|
bool is_urgent;
|
2011-07-01 16:55:22 +00:00
|
|
|
|
|
|
|
/* Prepare a new request */
|
2013-04-15 09:54:35 +00:00
|
|
|
if (areq) {
|
|
|
|
/*
|
|
|
|
* start waiting here for possible interrupt
|
|
|
|
* because mmc_pre_req() taking long time
|
|
|
|
*/
|
2011-07-01 16:55:22 +00:00
|
|
|
mmc_pre_req(host, areq->mrq, !host->areq);
|
2013-04-15 09:54:35 +00:00
|
|
|
}
|
2011-07-01 16:55:22 +00:00
|
|
|
|
|
|
|
if (host->areq) {
|
2013-04-15 09:54:35 +00:00
|
|
|
err = mmc_wait_for_data_req_done(host, host->areq->mrq,
|
|
|
|
areq);
|
2013-04-15 10:51:47 +00:00
|
|
|
if (err == MMC_BLK_URGENT || err == MMC_BLK_URGENT_DONE) {
|
2013-04-15 09:54:35 +00:00
|
|
|
mmc_post_req(host, host->areq->mrq, 0);
|
|
|
|
host->areq = NULL;
|
2013-04-15 10:51:47 +00:00
|
|
|
if (areq) {
|
2014-01-29 11:37:41 +00:00
|
|
|
if (!(areq->cmd_flags &
|
|
|
|
MMC_REQ_NOREINSERT_MASK)) {
|
2013-04-15 10:51:47 +00:00
|
|
|
areq->reinsert_req(areq);
|
|
|
|
mmc_post_req(host, areq->mrq, 0);
|
|
|
|
} else {
|
|
|
|
start_err = __mmc_start_data_req(host,
|
|
|
|
areq->mrq);
|
|
|
|
if (start_err)
|
|
|
|
mmc_post_req(host, areq->mrq,
|
|
|
|
-EINVAL);
|
|
|
|
else
|
|
|
|
host->areq = areq;
|
|
|
|
}
|
|
|
|
}
|
2013-04-15 09:54:35 +00:00
|
|
|
goto exit;
|
|
|
|
} else if (err == MMC_BLK_NEW_REQUEST) {
|
2013-02-01 05:32:22 +00:00
|
|
|
if (error)
|
|
|
|
*error = err;
|
|
|
|
/*
|
|
|
|
* The previous request was not completed,
|
|
|
|
* nothing to return
|
|
|
|
*/
|
|
|
|
return NULL;
|
|
|
|
}
|
2012-09-17 08:42:02 +00:00
|
|
|
/*
|
|
|
|
* Check BKOPS urgency for each R1 response
|
|
|
|
*/
|
|
|
|
if (host->card && mmc_card_mmc(host->card) &&
|
|
|
|
((mmc_resp_type(host->areq->mrq->cmd) == MMC_RSP_R1) ||
|
|
|
|
(mmc_resp_type(host->areq->mrq->cmd) == MMC_RSP_R1B)) &&
|
2012-10-18 11:58:18 +00:00
|
|
|
(host->areq->mrq->cmd->resp[0] & R1_EXCEPTION_EVENT)) {
|
2012-09-17 08:42:02 +00:00
|
|
|
mmc_start_bkops(host->card, true);
|
2012-10-18 11:58:18 +00:00
|
|
|
pr_debug("%s: %s: completed BKOPs due to exception",
|
|
|
|
mmc_hostname(host), __func__);
|
|
|
|
}
|
2011-07-01 16:55:22 +00:00
|
|
|
}
|
2013-05-16 03:13:13 +00:00
|
|
|
if (!err && areq) {
|
|
|
|
trace_mmc_blk_rw_start(areq->mrq->cmd->opcode,
|
|
|
|
areq->mrq->cmd->arg,
|
|
|
|
areq->mrq->data);
|
2013-04-15 10:51:47 +00:00
|
|
|
/* urgent notification may come again */
|
|
|
|
spin_lock_irqsave(&host->context_info.lock, flags);
|
|
|
|
is_urgent = host->context_info.is_urgent;
|
|
|
|
host->context_info.is_urgent = false;
|
|
|
|
spin_unlock_irqrestore(&host->context_info.lock, flags);
|
|
|
|
if (!is_urgent || (areq->cmd_flags & REQ_URGENT)) {
|
|
|
|
start_err = __mmc_start_data_req(host, areq->mrq);
|
|
|
|
} else {
|
|
|
|
/* previous request was done */
|
|
|
|
err = MMC_BLK_URGENT_DONE;
|
|
|
|
if (host->areq) {
|
|
|
|
mmc_post_req(host, host->areq->mrq, 0);
|
|
|
|
host->areq = NULL;
|
|
|
|
}
|
|
|
|
areq->reinsert_req(areq);
|
|
|
|
mmc_post_req(host, areq->mrq, 0);
|
|
|
|
goto exit;
|
|
|
|
}
|
2013-05-16 03:13:13 +00:00
|
|
|
}
|
2011-07-01 16:55:22 +00:00
|
|
|
|
|
|
|
if (host->areq)
|
|
|
|
mmc_post_req(host, host->areq->mrq, 0);
|
|
|
|
|
2012-03-05 14:52:43 +00:00
|
|
|
/* Cancel a prepared request if it was not started. */
|
|
|
|
if ((err || start_err) && areq)
|
2013-02-01 05:32:22 +00:00
|
|
|
mmc_post_req(host, areq->mrq, -EINVAL);
|
2012-03-05 14:52:43 +00:00
|
|
|
|
|
|
|
if (err)
|
|
|
|
host->areq = NULL;
|
|
|
|
else
|
|
|
|
host->areq = areq;
|
|
|
|
|
2013-04-15 09:54:35 +00:00
|
|
|
exit:
|
2011-07-01 16:55:22 +00:00
|
|
|
if (error)
|
|
|
|
*error = err;
|
|
|
|
return data;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mmc_start_req);
|
|
|
|
|
2007-07-11 18:22:11 +00:00
|
|
|
/**
|
|
|
|
* 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)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-04-18 01:29:57 +00:00
|
|
|
#ifdef CONFIG_MMC_BLOCK_DEFERRED_RESUME
|
|
|
|
if (mmc_bus_needs_resume(host))
|
|
|
|
mmc_resume_bus(host);
|
|
|
|
#endif
|
2011-07-01 16:55:22 +00:00
|
|
|
__mmc_start_req(host, mrq);
|
|
|
|
mmc_wait_for_req_done(host, mrq);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mmc_wait_for_req);
|
|
|
|
|
2013-05-22 10:04:14 +00:00
|
|
|
bool mmc_card_is_prog_state(struct mmc_card *card)
|
|
|
|
{
|
|
|
|
bool rc;
|
|
|
|
struct mmc_command cmd;
|
|
|
|
|
|
|
|
mmc_claim_host(card->host);
|
|
|
|
memset(&cmd, 0, sizeof(struct mmc_command));
|
|
|
|
cmd.opcode = MMC_SEND_STATUS;
|
|
|
|
if (!mmc_host_is_spi(card->host))
|
|
|
|
cmd.arg = card->rca << 16;
|
|
|
|
cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
|
|
|
|
|
|
|
|
rc = mmc_wait_for_cmd(card->host, &cmd, 0);
|
|
|
|
if (rc) {
|
|
|
|
pr_err("%s: Get card status fail. rc=%d\n",
|
|
|
|
mmc_hostname(card->host), rc);
|
|
|
|
rc = false;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (R1_CURRENT_STATE(cmd.resp[0]) == R1_STATE_PRG)
|
|
|
|
rc = true;
|
|
|
|
else
|
|
|
|
rc = false;
|
|
|
|
out:
|
|
|
|
mmc_release_host(card->host);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mmc_card_is_prog_state);
|
|
|
|
|
2011-10-18 05:26:42 +00:00
|
|
|
/**
|
|
|
|
* 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
|
2012-09-17 08:42:02 +00:00
|
|
|
* until out-of prg-state.
|
2011-10-18 05:26:42 +00:00
|
|
|
*/
|
|
|
|
int mmc_interrupt_hpi(struct mmc_card *card)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
u32 status;
|
2012-06-22 06:12:36 +00:00
|
|
|
unsigned long prg_wait;
|
2011-10-18 05:26:42 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2012-06-22 06:12:36 +00:00
|
|
|
switch (R1_CURRENT_STATE(status)) {
|
|
|
|
case R1_STATE_IDLE:
|
|
|
|
case R1_STATE_READY:
|
|
|
|
case R1_STATE_STBY:
|
2012-08-07 13:54:45 +00:00
|
|
|
case R1_STATE_TRAN:
|
2012-06-22 06:12:36 +00:00
|
|
|
/*
|
2012-08-07 13:54:45 +00:00
|
|
|
* In idle and transfer states, HPI is not needed and the caller
|
2012-06-22 06:12:36 +00:00
|
|
|
* can issue the next intended command immediately
|
|
|
|
*/
|
|
|
|
goto out;
|
|
|
|
case R1_STATE_PRG:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* In all other states, it's illegal to issue HPI */
|
|
|
|
pr_debug("%s: HPI cannot be sent. Card state=%d\n",
|
|
|
|
mmc_hostname(card->host), R1_CURRENT_STATE(status));
|
|
|
|
err = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = mmc_send_hpi_cmd(card, &status);
|
|
|
|
|
|
|
|
prg_wait = jiffies + msecs_to_jiffies(card->ext_csd.out_of_int_time);
|
|
|
|
do {
|
|
|
|
err = mmc_send_status(card, &status);
|
|
|
|
|
|
|
|
if (!err && R1_CURRENT_STATE(status) == R1_STATE_TRAN)
|
|
|
|
break;
|
2013-05-13 12:00:21 +00:00
|
|
|
if (time_after(jiffies, prg_wait)) {
|
|
|
|
err = mmc_send_status(card, &status);
|
|
|
|
if (!err && R1_CURRENT_STATE(status) != R1_STATE_TRAN)
|
|
|
|
err = -ETIMEDOUT;
|
|
|
|
else
|
|
|
|
break;
|
|
|
|
}
|
2012-06-22 06:12:36 +00:00
|
|
|
} while (!err);
|
2011-10-18 05:26:42 +00:00
|
|
|
|
|
|
|
out:
|
|
|
|
mmc_release_host(card->host);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mmc_interrupt_hpi);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
|
|
|
* 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)
|
|
|
|
{
|
2011-08-24 19:00:50 +00:00
|
|
|
struct mmc_request mrq = {NULL};
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-08-09 11:23:56 +00:00
|
|
|
WARN_ON(!host->claimed);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
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);
|
|
|
|
|
2013-11-07 05:07:54 +00:00
|
|
|
#ifdef CONFIG_PM_RUNTIME
|
|
|
|
static int mmc_get_bkops_status(struct mmc_card *card)
|
|
|
|
{
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
if (!mmc_use_core_runtime_pm(card->host) && mmc_card_doing_bkops(card)
|
|
|
|
&& (card->host->parent->power.runtime_status == RPM_SUSPENDING)
|
|
|
|
&& mmc_card_is_prog_state(card))
|
|
|
|
err = -EBUSY;
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static int mmc_get_bkops_status(struct mmc_card *card)
|
|
|
|
{
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
if (!mmc_use_core_runtime_pm(card->host) && mmc_card_doing_bkops(card)
|
|
|
|
&& mmc_card_is_prog_state(card))
|
|
|
|
err = -EBUSY;
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
#endif
|
2012-09-17 08:42:02 +00:00
|
|
|
/**
|
|
|
|
* mmc_stop_bkops - stop ongoing BKOPS
|
|
|
|
* @card: MMC card to check BKOPS
|
|
|
|
*
|
|
|
|
* Send HPI command to stop ongoing background operations to
|
|
|
|
* allow rapid servicing of foreground operations, e.g. read/
|
|
|
|
* writes. Wait until the card comes out of the programming state
|
2013-01-04 08:55:00 +00:00
|
|
|
* to avoid errors in servicing read/write requests.
|
|
|
|
*
|
|
|
|
* The function should be called with host claimed.
|
2012-09-17 08:42:02 +00:00
|
|
|
*/
|
|
|
|
int mmc_stop_bkops(struct mmc_card *card)
|
|
|
|
{
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
BUG_ON(!card);
|
mmc: core: Add support for idle time BKOPS
Devices have various maintenance operations need to perform internally.
In order to reduce latencies during time critical operations like read
and write, it is better to execute maintenance operations in other
times - when the host is not being serviced. Such operations are called
Background operations (BKOPS).
The device notifies the status of the BKOPS need by updating BKOPS_STATUS
(EXT_CSD byte [246]).
According to the standard a host that supports BKOPS shall check the
status periodically and start background operations as needed, so that
the device has enough time for its maintenance operations.
This patch adds support for this periodic check of the BKOPS status.
Since foreground operations are of higher priority than background
operations the host will check the need for BKOPS when it is idle,
and in case of an incoming request the BKOPS operation will be
interrupted.
When the mmcqd thread is idle, a delayed work is created to check the
need for BKOPS. The time to start the delayed work is calculated based
on the host controller suspend timeout, in case it was set. If not, a
default time is used.
If BKOPS are required in level 1, which is non-blocking, there will be
polling of the card status to wait for the BKOPS completion and prevent
suspend that will interrupt the BKOPS.
If the card raised an exception, the need for urgent BKOPS (level 2/3)
will be checked immediately and if needed, the BKOPS will be performed
without waiting for the next idle time.
Change-Id: I7460afea1bc94498a93ff6553276b994d3bba012
Signed-off-by: Maya Erez <merez@codeaurora.org>
2012-10-10 01:47:54 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Notify the delayed work to be cancelled, in case it was already
|
|
|
|
* removed from the queue, but was not started yet
|
|
|
|
*/
|
|
|
|
card->bkops_info.cancel_delayed_work = true;
|
|
|
|
if (delayed_work_pending(&card->bkops_info.dw))
|
|
|
|
cancel_delayed_work_sync(&card->bkops_info.dw);
|
|
|
|
if (!mmc_card_doing_bkops(card))
|
|
|
|
goto out;
|
|
|
|
|
2013-05-22 10:04:14 +00:00
|
|
|
/*
|
|
|
|
* If idle time bkops is running on the card, let's not get into
|
|
|
|
* suspend.
|
|
|
|
*/
|
2013-11-07 05:07:54 +00:00
|
|
|
if (mmc_get_bkops_status(card)) {
|
2013-05-22 10:04:14 +00:00
|
|
|
err = -EBUSY;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2012-09-17 08:42:02 +00:00
|
|
|
err = mmc_interrupt_hpi(card);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If err is EINVAL, we can't issue an HPI.
|
|
|
|
* It should complete the BKOPS.
|
|
|
|
*/
|
|
|
|
if (!err || (err == -EINVAL)) {
|
|
|
|
mmc_card_clr_doing_bkops(card);
|
|
|
|
err = 0;
|
|
|
|
}
|
|
|
|
|
2012-10-11 16:29:28 +00:00
|
|
|
MMC_UPDATE_BKOPS_STATS_HPI(card->bkops_info.bkops_stats);
|
|
|
|
|
mmc: core: Add support for idle time BKOPS
Devices have various maintenance operations need to perform internally.
In order to reduce latencies during time critical operations like read
and write, it is better to execute maintenance operations in other
times - when the host is not being serviced. Such operations are called
Background operations (BKOPS).
The device notifies the status of the BKOPS need by updating BKOPS_STATUS
(EXT_CSD byte [246]).
According to the standard a host that supports BKOPS shall check the
status periodically and start background operations as needed, so that
the device has enough time for its maintenance operations.
This patch adds support for this periodic check of the BKOPS status.
Since foreground operations are of higher priority than background
operations the host will check the need for BKOPS when it is idle,
and in case of an incoming request the BKOPS operation will be
interrupted.
When the mmcqd thread is idle, a delayed work is created to check the
need for BKOPS. The time to start the delayed work is calculated based
on the host controller suspend timeout, in case it was set. If not, a
default time is used.
If BKOPS are required in level 1, which is non-blocking, there will be
polling of the card status to wait for the BKOPS completion and prevent
suspend that will interrupt the BKOPS.
If the card raised an exception, the need for urgent BKOPS (level 2/3)
will be checked immediately and if needed, the BKOPS will be performed
without waiting for the next idle time.
Change-Id: I7460afea1bc94498a93ff6553276b994d3bba012
Signed-off-by: Maya Erez <merez@codeaurora.org>
2012-10-10 01:47:54 +00:00
|
|
|
out:
|
2012-09-17 08:42:02 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mmc_stop_bkops);
|
|
|
|
|
|
|
|
int mmc_read_bkops_status(struct mmc_card *card)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
u8 *ext_csd;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* In future work, we should consider storing the entire ext_csd.
|
|
|
|
*/
|
|
|
|
ext_csd = kmalloc(512, GFP_KERNEL);
|
|
|
|
if (!ext_csd) {
|
|
|
|
pr_err("%s: could not allocate buffer to receive the ext_csd.\n",
|
|
|
|
mmc_hostname(card->host));
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2012-10-18 11:58:18 +00:00
|
|
|
if (card->bkops_info.bkops_stats.ignore_card_bkops_status) {
|
|
|
|
pr_debug("%s: skipping read raw_bkops_status in unittest mode",
|
|
|
|
__func__);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-09-17 08:42:02 +00:00
|
|
|
mmc_claim_host(card->host);
|
|
|
|
err = mmc_send_ext_csd(card, ext_csd);
|
|
|
|
mmc_release_host(card->host);
|
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
card->ext_csd.raw_bkops_status = ext_csd[EXT_CSD_BKOPS_STATUS];
|
|
|
|
card->ext_csd.raw_exception_status = ext_csd[EXT_CSD_EXP_EVENTS_STATUS];
|
|
|
|
out:
|
|
|
|
kfree(ext_csd);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mmc_read_bkops_status);
|
|
|
|
|
2006-09-07 14:57:12 +00:00
|
|
|
/**
|
|
|
|
* 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
|
2007-07-11 18:22:11 +00:00
|
|
|
*
|
|
|
|
* Computes the data timeout parameters according to the
|
|
|
|
* correct algorithm given the card type.
|
2006-09-07 14:57:12 +00:00
|
|
|
*/
|
2007-07-24 17:16:54 +00:00
|
|
|
void mmc_set_data_timeout(struct mmc_data *data, const struct mmc_card *card)
|
2006-09-07 14:57:12 +00:00
|
|
|
{
|
|
|
|
unsigned int mult;
|
|
|
|
|
2013-10-07 09:23:32 +00:00
|
|
|
if (!card) {
|
|
|
|
WARN_ON(1);
|
|
|
|
return;
|
|
|
|
}
|
2007-08-07 12:11:55 +00:00
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
|
2006-09-07 14:57:12 +00:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2007-07-24 17:16:54 +00:00
|
|
|
if (data->flags & MMC_DATA_WRITE)
|
2006-09-07 14:57:12 +00:00
|
|
|
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;
|
2011-01-04 23:44:32 +00:00
|
|
|
if (mmc_host_clk_rate(card->host))
|
|
|
|
timeout_us += data->timeout_clks * 1000 /
|
|
|
|
(mmc_host_clk_rate(card->host) / 1000);
|
2006-09-07 14:57:12 +00:00
|
|
|
|
2007-07-24 17:16:54 +00:00
|
|
|
if (data->flags & MMC_DATA_WRITE)
|
2008-10-26 11:37:25 +00:00
|
|
|
/*
|
2012-03-12 10:58:00 +00:00
|
|
|
* The MMC spec "It is strongly recommended
|
|
|
|
* for hosts to implement more than 500ms
|
|
|
|
* timeout value even if the card indicates
|
|
|
|
* the 250ms maximum busy length." Even the
|
|
|
|
* previous value of 300ms is known to be
|
|
|
|
* insufficient for some cards.
|
2008-10-26 11:37:25 +00:00
|
|
|
*/
|
2012-03-12 10:58:00 +00:00
|
|
|
limit_us = 3000000;
|
2006-09-07 14:57:12 +00:00
|
|
|
else
|
|
|
|
limit_us = 100000;
|
|
|
|
|
2007-01-04 14:57:32 +00:00
|
|
|
/*
|
|
|
|
* SDHC cards always use these fixed values.
|
|
|
|
*/
|
|
|
|
if (timeout_us > limit_us || mmc_card_blockaddr(card)) {
|
2006-09-07 14:57:12 +00:00
|
|
|
data->timeout_ns = limit_us * 1000;
|
|
|
|
data->timeout_clks = 0;
|
|
|
|
}
|
|
|
|
}
|
2011-11-03 08:44:12 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Some cards require longer data read timeout than indicated in CSD.
|
|
|
|
* Address this by setting the read timeout to a "reasonably high"
|
2016-05-20 07:33:46 +00:00
|
|
|
* value. For the cards tested, 600ms has proven enough. If necessary,
|
2011-11-03 08:44:12 +00:00
|
|
|
* this value can be increased if other problematic cards require this.
|
|
|
|
*/
|
|
|
|
if (mmc_card_long_read_time(card) && data->flags & MMC_DATA_READ) {
|
2016-05-20 07:33:46 +00:00
|
|
|
data->timeout_ns = 600000000;
|
2011-11-03 08:44:12 +00:00
|
|
|
data->timeout_clks = 0;
|
|
|
|
}
|
|
|
|
|
2009-03-11 13:28:39 +00:00
|
|
|
/*
|
|
|
|
* 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 */
|
|
|
|
}
|
|
|
|
}
|
2012-04-17 09:11:19 +00:00
|
|
|
/* Increase the timeout values for some bad INAND MCP devices */
|
|
|
|
if (card->quirks & MMC_QUIRK_INAND_DATA_TIMEOUT) {
|
|
|
|
data->timeout_ns = 4000000000u; /* 4s */
|
|
|
|
data->timeout_clks = 0;
|
|
|
|
}
|
2013-12-11 10:09:40 +00:00
|
|
|
/* Some emmc cards require a longer read/write time */
|
|
|
|
if (card->quirks & MMC_QUIRK_BROKEN_DATA_TIMEOUT) {
|
|
|
|
if (data->timeout_ns < 4000000000u)
|
|
|
|
data->timeout_ns = 4000000000u; /* 4s */
|
|
|
|
}
|
2006-09-07 14:57:12 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mmc_set_data_timeout);
|
|
|
|
|
2008-06-28 10:52:45 +00:00
|
|
|
/**
|
|
|
|
* 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);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
2007-06-30 14:21:52 +00:00
|
|
|
* __mmc_claim_host - exclusively claim a host
|
2005-04-16 22:20:36 +00:00
|
|
|
* @host: mmc host to claim
|
2007-06-30 14:21:52 +00:00
|
|
|
* @abort: whether or not the operation should be aborted
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2007-06-30 14:21:52 +00:00
|
|
|
* 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.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2007-06-30 14:21:52 +00:00
|
|
|
int __mmc_claim_host(struct mmc_host *host, atomic_t *abort)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
DECLARE_WAITQUEUE(wait, current);
|
|
|
|
unsigned long flags;
|
2007-06-30 14:21:52 +00:00
|
|
|
int stop;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-07-11 18:28:02 +00:00
|
|
|
might_sleep();
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
add_wait_queue(&host->wq, &wait);
|
2011-02-17 16:07:48 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_lock_irqsave(&host->lock, flags);
|
|
|
|
while (1) {
|
|
|
|
set_current_state(TASK_UNINTERRUPTIBLE);
|
2007-06-30 14:21:52 +00:00
|
|
|
stop = abort ? atomic_read(abort) : 0;
|
2009-09-22 23:44:30 +00:00
|
|
|
if (stop || !host->claimed || host->claimer == current)
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
spin_unlock_irqrestore(&host->lock, flags);
|
|
|
|
schedule();
|
|
|
|
spin_lock_irqsave(&host->lock, flags);
|
|
|
|
}
|
|
|
|
set_current_state(TASK_RUNNING);
|
2009-09-22 23:44:30 +00:00
|
|
|
if (!stop) {
|
2007-06-30 14:21:52 +00:00
|
|
|
host->claimed = 1;
|
2009-09-22 23:44:30 +00:00
|
|
|
host->claimer = current;
|
|
|
|
host->claim_cnt += 1;
|
|
|
|
} else
|
2007-06-30 14:21:52 +00:00
|
|
|
wake_up(&host->wq);
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_unlock_irqrestore(&host->lock, flags);
|
|
|
|
remove_wait_queue(&host->wq, &wait);
|
2012-02-29 07:17:21 +00:00
|
|
|
if (host->ops->enable && !stop && host->claim_cnt == 1)
|
|
|
|
host->ops->enable(host);
|
2007-06-30 14:21:52 +00:00
|
|
|
return stop;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2007-06-30 14:21:52 +00:00
|
|
|
EXPORT_SYMBOL(__mmc_claim_host);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-09-22 23:44:30 +00:00
|
|
|
/**
|
|
|
|
* 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)
|
2009-09-22 23:44:29 +00:00
|
|
|
{
|
|
|
|
int claimed_host = 0;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&host->lock, flags);
|
2009-09-22 23:44:30 +00:00
|
|
|
if (!host->claimed || host->claimer == current) {
|
2009-09-22 23:44:29 +00:00
|
|
|
host->claimed = 1;
|
2009-09-22 23:44:30 +00:00
|
|
|
host->claimer = current;
|
|
|
|
host->claim_cnt += 1;
|
2009-09-22 23:44:29 +00:00
|
|
|
claimed_host = 1;
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&host->lock, flags);
|
2012-02-29 07:17:21 +00:00
|
|
|
if (host->ops->enable && claimed_host && host->claim_cnt == 1)
|
|
|
|
host->ops->enable(host);
|
2009-09-22 23:44:29 +00:00
|
|
|
return claimed_host;
|
|
|
|
}
|
2009-09-22 23:44:30 +00:00
|
|
|
EXPORT_SYMBOL(mmc_try_claim_host);
|
2009-09-22 23:44:29 +00:00
|
|
|
|
2011-03-09 08:11:02 +00:00
|
|
|
/**
|
2012-02-29 07:17:21 +00:00
|
|
|
* mmc_release_host - release a host
|
2011-03-09 08:11:02 +00:00
|
|
|
* @host: mmc host to release
|
|
|
|
*
|
2012-02-29 07:17:21 +00:00
|
|
|
* Release a MMC host, allowing others to claim the host
|
|
|
|
* for their operations.
|
2011-03-09 08:11:02 +00:00
|
|
|
*/
|
2012-02-29 07:17:21 +00:00
|
|
|
void mmc_release_host(struct mmc_host *host)
|
2009-09-22 23:44:29 +00:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
2012-02-29 07:17:21 +00:00
|
|
|
WARN_ON(!host->claimed);
|
|
|
|
|
|
|
|
if (host->ops->disable && host->claim_cnt == 1)
|
|
|
|
host->ops->disable(host);
|
|
|
|
|
2009-09-22 23:44:29 +00:00
|
|
|
spin_lock_irqsave(&host->lock, flags);
|
2009-09-22 23:44:30 +00:00
|
|
|
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);
|
|
|
|
}
|
2009-09-22 23:44:29 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
EXPORT_SYMBOL(mmc_release_host);
|
|
|
|
|
2006-12-30 23:11:32 +00:00
|
|
|
/*
|
|
|
|
* Internal function that does the actual ios call to the host driver,
|
|
|
|
* optionally printing some debug output.
|
|
|
|
*/
|
2012-02-09 14:31:04 +00:00
|
|
|
void mmc_set_ios(struct mmc_host *host)
|
2006-05-04 17:22:51 +00:00
|
|
|
{
|
|
|
|
struct mmc_ios *ios = &host->ios;
|
|
|
|
|
2007-02-18 11:07:47 +00:00
|
|
|
pr_debug("%s: clock %uHz busmode %u powermode %u cs %u Vdd %u "
|
|
|
|
"width %u timing %u\n",
|
2006-05-04 17:22:51 +00:00
|
|
|
mmc_hostname(host), ios->clock, ios->bus_mode,
|
|
|
|
ios->power_mode, ios->chip_select, ios->vdd,
|
2007-02-18 11:07:47 +00:00
|
|
|
ios->bus_width, ios->timing);
|
2007-01-04 14:57:32 +00:00
|
|
|
|
2010-11-09 02:36:50 +00:00
|
|
|
if (ios->clock > 0)
|
|
|
|
mmc_set_ungated(host);
|
2006-05-04 17:22:51 +00:00
|
|
|
host->ops->set_ios(host, ios);
|
2013-02-14 02:43:52 +00:00
|
|
|
if (ios->old_rate != ios->clock) {
|
|
|
|
if (likely(ios->clk_ts)) {
|
|
|
|
char trace_info[80];
|
|
|
|
snprintf(trace_info, 80,
|
|
|
|
"%s: freq_KHz %d --> %d | t = %d",
|
|
|
|
mmc_hostname(host), ios->old_rate / 1000,
|
|
|
|
ios->clock / 1000, jiffies_to_msecs(
|
|
|
|
(long)jiffies - (long)ios->clk_ts));
|
|
|
|
trace_mmc_clk(trace_info);
|
|
|
|
}
|
|
|
|
ios->old_rate = ios->clock;
|
|
|
|
ios->clk_ts = jiffies;
|
|
|
|
}
|
2006-05-04 17:22:51 +00:00
|
|
|
}
|
2012-02-09 14:31:04 +00:00
|
|
|
EXPORT_SYMBOL(mmc_set_ios);
|
2006-05-04 17:22:51 +00:00
|
|
|
|
2006-12-30 23:11:32 +00:00
|
|
|
/*
|
|
|
|
* Control chip select pin on a host.
|
|
|
|
*/
|
2006-12-24 21:46:55 +00:00
|
|
|
void mmc_set_chip_select(struct mmc_host *host, int mode)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2011-08-18 12:23:48 +00:00
|
|
|
mmc_host_clk_hold(host);
|
2006-12-24 21:46:55 +00:00
|
|
|
host->ios.chip_select = mode;
|
|
|
|
mmc_set_ios(host);
|
2011-08-18 12:23:48 +00:00
|
|
|
mmc_host_clk_release(host);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-12-30 23:11:32 +00:00
|
|
|
/*
|
|
|
|
* Sets the host clock to the highest possible frequency that
|
|
|
|
* is below "hz".
|
|
|
|
*/
|
2011-08-18 12:23:48 +00:00
|
|
|
static void __mmc_set_clock(struct mmc_host *host, unsigned int hz)
|
2006-12-30 23:11:32 +00:00
|
|
|
{
|
|
|
|
WARN_ON(hz < host->f_min);
|
|
|
|
|
|
|
|
if (hz > host->f_max)
|
|
|
|
hz = host->f_max;
|
|
|
|
|
|
|
|
host->ios.clock = hz;
|
|
|
|
mmc_set_ios(host);
|
|
|
|
}
|
|
|
|
|
2011-08-18 12:23:48 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2010-11-09 02:36:50 +00:00
|
|
|
#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;
|
|
|
|
|
2012-01-24 05:16:33 +00:00
|
|
|
WARN_ON(!host->ios.clock);
|
|
|
|
|
2010-11-09 02:36:50 +00:00
|
|
|
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) {
|
2012-01-24 05:16:33 +00:00
|
|
|
WARN_ON(host->ios.clock);
|
2010-11-09 02:36:50 +00:00
|
|
|
/* This call will also set host->clk_gated to false */
|
2011-08-18 12:23:48 +00:00
|
|
|
__mmc_set_clock(host, host->clk_old);
|
2010-11-09 02:36:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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
|
|
|
|
|
2006-12-30 23:11:32 +00:00
|
|
|
/*
|
|
|
|
* Change the bus mode (open drain/push-pull) of a host.
|
|
|
|
*/
|
|
|
|
void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode)
|
|
|
|
{
|
2011-08-18 12:23:48 +00:00
|
|
|
mmc_host_clk_hold(host);
|
2006-12-30 23:11:32 +00:00
|
|
|
host->ios.bus_mode = mode;
|
|
|
|
mmc_set_ios(host);
|
2011-08-18 12:23:48 +00:00
|
|
|
mmc_host_clk_release(host);
|
2006-12-30 23:11:32 +00:00
|
|
|
}
|
|
|
|
|
2010-08-24 10:20:26 +00:00
|
|
|
/*
|
|
|
|
* Change data bus width of a host.
|
|
|
|
*/
|
|
|
|
void mmc_set_bus_width(struct mmc_host *host, unsigned int width)
|
|
|
|
{
|
2011-08-18 12:23:48 +00:00
|
|
|
mmc_host_clk_hold(host);
|
2011-05-13 05:47:18 +00:00
|
|
|
host->ios.bus_width = width;
|
|
|
|
mmc_set_ios(host);
|
2011-08-18 12:23:48 +00:00
|
|
|
mmc_host_clk_release(host);
|
2010-08-24 10:20:26 +00:00
|
|
|
}
|
|
|
|
|
2008-11-26 19:54:17 +00:00
|
|
|
/**
|
|
|
|
* 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);
|
|
|
|
|
2009-03-11 11:30:43 +00:00
|
|
|
#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;
|
|
|
|
}
|
2012-06-11 13:39:12 +00:00
|
|
|
EXPORT_SYMBOL_GPL(mmc_regulator_get_ocrmask);
|
2009-03-11 11:30:43 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* mmc_regulator_set_ocr - set regulator to match host->ios voltage
|
2010-09-29 05:08:27 +00:00
|
|
|
* @mmc: the host to regulate
|
2009-03-11 11:30:43 +00:00
|
|
|
* @supply: regulator to use
|
2010-09-29 05:08:27 +00:00
|
|
|
* @vdd_bit: zero for power off, else a bit number (host->ios.vdd)
|
2009-03-11 11:30:43 +00:00
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
2010-09-29 05:08:27 +00:00
|
|
|
int mmc_regulator_set_ocr(struct mmc_host *mmc,
|
|
|
|
struct regulator *supply,
|
|
|
|
unsigned short vdd_bit)
|
2009-03-11 11:30:43 +00:00
|
|
|
{
|
|
|
|
int result = 0;
|
|
|
|
int min_uV, max_uV;
|
|
|
|
|
|
|
|
if (vdd_bit) {
|
|
|
|
int tmp;
|
|
|
|
int voltage;
|
|
|
|
|
2012-09-19 14:27:04 +00:00
|
|
|
/*
|
|
|
|
* REVISIT mmc_vddrange_to_ocrmask() may have set some
|
2009-03-11 11:30:43 +00:00
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
|
2012-09-19 14:27:04 +00:00
|
|
|
/*
|
|
|
|
* If we're using a fixed/static regulator, don't call
|
|
|
|
* regulator_set_voltage; it would fail.
|
2009-03-11 11:30:43 +00:00
|
|
|
*/
|
|
|
|
voltage = regulator_get_voltage(supply);
|
2012-01-16 08:49:01 +00:00
|
|
|
|
2012-12-04 14:01:02 +00:00
|
|
|
if (!regulator_can_change_voltage(supply))
|
2012-01-16 08:49:01 +00:00
|
|
|
min_uV = max_uV = voltage;
|
|
|
|
|
2009-03-11 11:30:43 +00:00
|
|
|
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;
|
|
|
|
|
2010-09-29 05:08:27 +00:00
|
|
|
if (result == 0 && !mmc->regulator_enabled) {
|
2009-03-11 11:30:43 +00:00
|
|
|
result = regulator_enable(supply);
|
2010-09-29 05:08:27 +00:00
|
|
|
if (!result)
|
|
|
|
mmc->regulator_enabled = true;
|
|
|
|
}
|
|
|
|
} else if (mmc->regulator_enabled) {
|
2009-03-11 11:30:43 +00:00
|
|
|
result = regulator_disable(supply);
|
2010-09-29 05:08:27 +00:00
|
|
|
if (result == 0)
|
|
|
|
mmc->regulator_enabled = false;
|
2009-03-11 11:30:43 +00:00
|
|
|
}
|
|
|
|
|
2010-09-29 05:08:27 +00:00
|
|
|
if (result)
|
|
|
|
dev_err(mmc_dev(mmc),
|
|
|
|
"could not set regulator OCR (%d)\n", result);
|
2009-03-11 11:30:43 +00:00
|
|
|
return result;
|
|
|
|
}
|
2012-06-11 13:39:12 +00:00
|
|
|
EXPORT_SYMBOL_GPL(mmc_regulator_set_ocr);
|
2009-03-11 11:30:43 +00:00
|
|
|
|
2012-06-20 06:28:43 +00:00
|
|
|
int mmc_regulator_get_supply(struct mmc_host *mmc)
|
|
|
|
{
|
|
|
|
struct device *dev = mmc_dev(mmc);
|
|
|
|
struct regulator *supply;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
supply = devm_regulator_get(dev, "vmmc");
|
|
|
|
mmc->supply.vmmc = supply;
|
|
|
|
mmc->supply.vqmmc = devm_regulator_get(dev, "vqmmc");
|
|
|
|
|
|
|
|
if (IS_ERR(supply))
|
|
|
|
return PTR_ERR(supply);
|
|
|
|
|
|
|
|
ret = mmc_regulator_get_ocrmask(supply);
|
|
|
|
if (ret > 0)
|
|
|
|
mmc->ocr_avail = ret;
|
|
|
|
else
|
|
|
|
dev_warn(mmc_dev(mmc), "Failed getting OCR mask: %d\n", ret);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(mmc_regulator_get_supply);
|
|
|
|
|
2010-09-29 05:08:27 +00:00
|
|
|
#endif /* CONFIG_REGULATOR */
|
2009-03-11 11:30:43 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Mask off any voltages we don't support and select
|
|
|
|
* the lowest voltage
|
|
|
|
*/
|
2006-12-30 23:11:32 +00:00
|
|
|
u32 mmc_select_voltage(struct mmc_host *host, u32 ocr)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int bit;
|
|
|
|
|
|
|
|
ocr &= host->ocr_avail;
|
|
|
|
|
|
|
|
bit = ffs(ocr);
|
|
|
|
if (bit) {
|
|
|
|
bit -= 1;
|
|
|
|
|
2006-11-02 18:43:27 +00:00
|
|
|
ocr &= 3 << bit;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-08-18 12:23:48 +00:00
|
|
|
mmc_host_clk_hold(host);
|
2005-04-16 22:20:36 +00:00
|
|
|
host->ios.vdd = bit;
|
2006-05-04 17:22:51 +00:00
|
|
|
mmc_set_ios(host);
|
2011-08-18 12:23:48 +00:00
|
|
|
mmc_host_clk_release(host);
|
2005-04-16 22:20:36 +00:00
|
|
|
} else {
|
2008-12-31 17:50:30 +00:00
|
|
|
pr_warning("%s: host doesn't support card's voltages\n",
|
|
|
|
mmc_hostname(host));
|
2005-04-16 22:20:36 +00:00
|
|
|
ocr = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ocr;
|
|
|
|
}
|
|
|
|
|
2013-01-28 14:08:27 +00:00
|
|
|
int __mmc_set_signal_voltage(struct mmc_host *host, int signal_voltage)
|
|
|
|
{
|
|
|
|
int err = 0;
|
|
|
|
int old_signal_voltage = host->ios.signal_voltage;
|
|
|
|
|
|
|
|
host->ios.signal_voltage = signal_voltage;
|
|
|
|
if (host->ops->start_signal_voltage_switch) {
|
|
|
|
mmc_host_clk_hold(host);
|
|
|
|
err = host->ops->start_signal_voltage_switch(host, &host->ios);
|
|
|
|
mmc_host_clk_release(host);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (err)
|
|
|
|
host->ios.signal_voltage = old_signal_voltage;
|
|
|
|
|
|
|
|
return err;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
int mmc_set_signal_voltage(struct mmc_host *host, int signal_voltage)
|
mmc: sd: add support for signal voltage switch procedure
Host Controller v3.00 adds another Capabilities register. Apart
from other things, this new register indicates whether the Host
Controller supports SDR50, SDR104, and DDR50 UHS-I modes. The spec
doesn't mention about explicit support for SDR12 and SDR25 UHS-I
modes, so the Host Controller v3.00 should support them by default.
Also if the controller supports SDR104 mode, it will also support
SDR50 mode as well. So depending on the host support, we set the
corresponding MMC_CAP_* flags. One more new register. Host Control2
is added in v3.00, which is used during Signal Voltage Switch
procedure described below.
Since as per v3.00 spec, UHS-I supported hosts should set S18R
to 1, we set S18R (bit 24) of OCR before sending ACMD41. We also
need to set XPC (bit 28) of OCR in case the host can supply >150mA.
This support is indicated by the Maximum Current Capabilities
register of the Host Controller.
If the response of ACMD41 has both CCS and S18A set, we start the
signal voltage switch procedure, which if successfull, will switch
the card from 3.3V signalling to 1.8V signalling. Signal voltage
switch procedure adds support for a new command CMD11 in the
Physical Layer Spec v3.01. As part of this procedure, we need to
set 1.8V Signalling Enable (bit 3) of Host Control2 register, which
if remains set after 5ms, means the switch to 1.8V signalling is
successfull. Otherwise, we clear bit 24 of OCR and retry the
initialization sequence. When we remove the card, and insert the
same or another card, we need to make sure that we start with 3.3V
signalling voltage. So we call mmc_set_signal_voltage() with
MMC_SIGNAL_VOLTAGE_330 set so that we are back to 3.3V signalling
voltage before we actually start initializing the card.
Tested by Zhangfei Gao with a Toshiba uhs card and general hs card,
on mmp2 in SDMA mode.
Signed-off-by: Arindam Nath <arindam.nath@amd.com>
Reviewed-by: Philip Rakity <prakity@marvell.com>
Tested-by: Philip Rakity <prakity@marvell.com>
Acked-by: Zhangfei Gao <zhangfei.gao@marvell.com>
Signed-off-by: Chris Ball <cjb@laptop.org>
2011-05-05 06:48:57 +00:00
|
|
|
{
|
|
|
|
struct mmc_command cmd = {0};
|
|
|
|
int err = 0;
|
2013-01-28 14:08:28 +00:00
|
|
|
u32 clock;
|
mmc: sd: add support for signal voltage switch procedure
Host Controller v3.00 adds another Capabilities register. Apart
from other things, this new register indicates whether the Host
Controller supports SDR50, SDR104, and DDR50 UHS-I modes. The spec
doesn't mention about explicit support for SDR12 and SDR25 UHS-I
modes, so the Host Controller v3.00 should support them by default.
Also if the controller supports SDR104 mode, it will also support
SDR50 mode as well. So depending on the host support, we set the
corresponding MMC_CAP_* flags. One more new register. Host Control2
is added in v3.00, which is used during Signal Voltage Switch
procedure described below.
Since as per v3.00 spec, UHS-I supported hosts should set S18R
to 1, we set S18R (bit 24) of OCR before sending ACMD41. We also
need to set XPC (bit 28) of OCR in case the host can supply >150mA.
This support is indicated by the Maximum Current Capabilities
register of the Host Controller.
If the response of ACMD41 has both CCS and S18A set, we start the
signal voltage switch procedure, which if successfull, will switch
the card from 3.3V signalling to 1.8V signalling. Signal voltage
switch procedure adds support for a new command CMD11 in the
Physical Layer Spec v3.01. As part of this procedure, we need to
set 1.8V Signalling Enable (bit 3) of Host Control2 register, which
if remains set after 5ms, means the switch to 1.8V signalling is
successfull. Otherwise, we clear bit 24 of OCR and retry the
initialization sequence. When we remove the card, and insert the
same or another card, we need to make sure that we start with 3.3V
signalling voltage. So we call mmc_set_signal_voltage() with
MMC_SIGNAL_VOLTAGE_330 set so that we are back to 3.3V signalling
voltage before we actually start initializing the card.
Tested by Zhangfei Gao with a Toshiba uhs card and general hs card,
on mmp2 in SDMA mode.
Signed-off-by: Arindam Nath <arindam.nath@amd.com>
Reviewed-by: Philip Rakity <prakity@marvell.com>
Tested-by: Philip Rakity <prakity@marvell.com>
Acked-by: Zhangfei Gao <zhangfei.gao@marvell.com>
Signed-off-by: Chris Ball <cjb@laptop.org>
2011-05-05 06:48:57 +00:00
|
|
|
|
|
|
|
BUG_ON(!host);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Send CMD11 only if the request is to switch the card to
|
|
|
|
* 1.8V signalling.
|
|
|
|
*/
|
2013-01-28 14:08:28 +00:00
|
|
|
if (signal_voltage == MMC_SIGNAL_VOLTAGE_330)
|
|
|
|
return __mmc_set_signal_voltage(host, signal_voltage);
|
mmc: sd: add support for signal voltage switch procedure
Host Controller v3.00 adds another Capabilities register. Apart
from other things, this new register indicates whether the Host
Controller supports SDR50, SDR104, and DDR50 UHS-I modes. The spec
doesn't mention about explicit support for SDR12 and SDR25 UHS-I
modes, so the Host Controller v3.00 should support them by default.
Also if the controller supports SDR104 mode, it will also support
SDR50 mode as well. So depending on the host support, we set the
corresponding MMC_CAP_* flags. One more new register. Host Control2
is added in v3.00, which is used during Signal Voltage Switch
procedure described below.
Since as per v3.00 spec, UHS-I supported hosts should set S18R
to 1, we set S18R (bit 24) of OCR before sending ACMD41. We also
need to set XPC (bit 28) of OCR in case the host can supply >150mA.
This support is indicated by the Maximum Current Capabilities
register of the Host Controller.
If the response of ACMD41 has both CCS and S18A set, we start the
signal voltage switch procedure, which if successfull, will switch
the card from 3.3V signalling to 1.8V signalling. Signal voltage
switch procedure adds support for a new command CMD11 in the
Physical Layer Spec v3.01. As part of this procedure, we need to
set 1.8V Signalling Enable (bit 3) of Host Control2 register, which
if remains set after 5ms, means the switch to 1.8V signalling is
successfull. Otherwise, we clear bit 24 of OCR and retry the
initialization sequence. When we remove the card, and insert the
same or another card, we need to make sure that we start with 3.3V
signalling voltage. So we call mmc_set_signal_voltage() with
MMC_SIGNAL_VOLTAGE_330 set so that we are back to 3.3V signalling
voltage before we actually start initializing the card.
Tested by Zhangfei Gao with a Toshiba uhs card and general hs card,
on mmp2 in SDMA mode.
Signed-off-by: Arindam Nath <arindam.nath@amd.com>
Reviewed-by: Philip Rakity <prakity@marvell.com>
Tested-by: Philip Rakity <prakity@marvell.com>
Acked-by: Zhangfei Gao <zhangfei.gao@marvell.com>
Signed-off-by: Chris Ball <cjb@laptop.org>
2011-05-05 06:48:57 +00:00
|
|
|
|
2013-01-28 14:08:28 +00:00
|
|
|
/*
|
|
|
|
* If we cannot switch voltages, return failure so the caller
|
|
|
|
* can continue without UHS mode
|
|
|
|
*/
|
|
|
|
if (!host->ops->start_signal_voltage_switch)
|
|
|
|
return -EPERM;
|
|
|
|
if (!host->ops->card_busy)
|
|
|
|
pr_warning("%s: cannot verify signal voltage switch\n",
|
|
|
|
mmc_hostname(host));
|
|
|
|
|
|
|
|
cmd.opcode = SD_SWITCH_VOLTAGE;
|
|
|
|
cmd.arg = 0;
|
|
|
|
cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
|
|
|
|
|
2013-09-06 13:37:07 +00:00
|
|
|
/*
|
|
|
|
* Hold the clock reference so clock doesn't get auto gated during this
|
|
|
|
* voltage switch sequence.
|
|
|
|
*/
|
|
|
|
mmc_host_clk_hold(host);
|
2013-01-28 14:08:28 +00:00
|
|
|
err = mmc_wait_for_cmd(host, &cmd, 0);
|
|
|
|
if (err)
|
2013-09-06 13:37:07 +00:00
|
|
|
goto exit;
|
2013-01-28 14:08:28 +00:00
|
|
|
|
2013-09-06 13:37:07 +00:00
|
|
|
if (!mmc_host_is_spi(host) && (cmd.resp[0] & R1_ERROR)) {
|
|
|
|
err = -EIO;
|
|
|
|
goto exit;
|
|
|
|
}
|
2013-01-28 14:08:28 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The card should drive cmd and dat[0:3] low immediately
|
|
|
|
* after the response of cmd11, but wait 1 ms to be sure
|
|
|
|
*/
|
|
|
|
mmc_delay(1);
|
|
|
|
if (host->ops->card_busy && !host->ops->card_busy(host)) {
|
|
|
|
err = -EAGAIN;
|
|
|
|
goto power_cycle;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* During a signal voltage level switch, the clock must be gated
|
|
|
|
* for 5 ms according to the SD spec
|
|
|
|
*/
|
2013-08-20 10:02:09 +00:00
|
|
|
host->card_clock_off = true;
|
2013-01-28 14:08:28 +00:00
|
|
|
clock = host->ios.clock;
|
|
|
|
host->ios.clock = 0;
|
|
|
|
mmc_set_ios(host);
|
mmc: sd: add support for signal voltage switch procedure
Host Controller v3.00 adds another Capabilities register. Apart
from other things, this new register indicates whether the Host
Controller supports SDR50, SDR104, and DDR50 UHS-I modes. The spec
doesn't mention about explicit support for SDR12 and SDR25 UHS-I
modes, so the Host Controller v3.00 should support them by default.
Also if the controller supports SDR104 mode, it will also support
SDR50 mode as well. So depending on the host support, we set the
corresponding MMC_CAP_* flags. One more new register. Host Control2
is added in v3.00, which is used during Signal Voltage Switch
procedure described below.
Since as per v3.00 spec, UHS-I supported hosts should set S18R
to 1, we set S18R (bit 24) of OCR before sending ACMD41. We also
need to set XPC (bit 28) of OCR in case the host can supply >150mA.
This support is indicated by the Maximum Current Capabilities
register of the Host Controller.
If the response of ACMD41 has both CCS and S18A set, we start the
signal voltage switch procedure, which if successfull, will switch
the card from 3.3V signalling to 1.8V signalling. Signal voltage
switch procedure adds support for a new command CMD11 in the
Physical Layer Spec v3.01. As part of this procedure, we need to
set 1.8V Signalling Enable (bit 3) of Host Control2 register, which
if remains set after 5ms, means the switch to 1.8V signalling is
successfull. Otherwise, we clear bit 24 of OCR and retry the
initialization sequence. When we remove the card, and insert the
same or another card, we need to make sure that we start with 3.3V
signalling voltage. So we call mmc_set_signal_voltage() with
MMC_SIGNAL_VOLTAGE_330 set so that we are back to 3.3V signalling
voltage before we actually start initializing the card.
Tested by Zhangfei Gao with a Toshiba uhs card and general hs card,
on mmp2 in SDMA mode.
Signed-off-by: Arindam Nath <arindam.nath@amd.com>
Reviewed-by: Philip Rakity <prakity@marvell.com>
Tested-by: Philip Rakity <prakity@marvell.com>
Acked-by: Zhangfei Gao <zhangfei.gao@marvell.com>
Signed-off-by: Chris Ball <cjb@laptop.org>
2011-05-05 06:48:57 +00:00
|
|
|
|
2013-01-28 14:08:28 +00:00
|
|
|
if (__mmc_set_signal_voltage(host, signal_voltage)) {
|
|
|
|
/*
|
|
|
|
* Voltages may not have been switched, but we've already
|
|
|
|
* sent CMD11, so a power cycle is required anyway
|
|
|
|
*/
|
|
|
|
err = -EAGAIN;
|
2013-08-20 10:02:09 +00:00
|
|
|
host->ios.clock = clock;
|
|
|
|
mmc_set_ios(host);
|
|
|
|
host->card_clock_off = false;
|
2013-01-28 14:08:28 +00:00
|
|
|
goto power_cycle;
|
mmc: sd: add support for signal voltage switch procedure
Host Controller v3.00 adds another Capabilities register. Apart
from other things, this new register indicates whether the Host
Controller supports SDR50, SDR104, and DDR50 UHS-I modes. The spec
doesn't mention about explicit support for SDR12 and SDR25 UHS-I
modes, so the Host Controller v3.00 should support them by default.
Also if the controller supports SDR104 mode, it will also support
SDR50 mode as well. So depending on the host support, we set the
corresponding MMC_CAP_* flags. One more new register. Host Control2
is added in v3.00, which is used during Signal Voltage Switch
procedure described below.
Since as per v3.00 spec, UHS-I supported hosts should set S18R
to 1, we set S18R (bit 24) of OCR before sending ACMD41. We also
need to set XPC (bit 28) of OCR in case the host can supply >150mA.
This support is indicated by the Maximum Current Capabilities
register of the Host Controller.
If the response of ACMD41 has both CCS and S18A set, we start the
signal voltage switch procedure, which if successfull, will switch
the card from 3.3V signalling to 1.8V signalling. Signal voltage
switch procedure adds support for a new command CMD11 in the
Physical Layer Spec v3.01. As part of this procedure, we need to
set 1.8V Signalling Enable (bit 3) of Host Control2 register, which
if remains set after 5ms, means the switch to 1.8V signalling is
successfull. Otherwise, we clear bit 24 of OCR and retry the
initialization sequence. When we remove the card, and insert the
same or another card, we need to make sure that we start with 3.3V
signalling voltage. So we call mmc_set_signal_voltage() with
MMC_SIGNAL_VOLTAGE_330 set so that we are back to 3.3V signalling
voltage before we actually start initializing the card.
Tested by Zhangfei Gao with a Toshiba uhs card and general hs card,
on mmp2 in SDMA mode.
Signed-off-by: Arindam Nath <arindam.nath@amd.com>
Reviewed-by: Philip Rakity <prakity@marvell.com>
Tested-by: Philip Rakity <prakity@marvell.com>
Acked-by: Zhangfei Gao <zhangfei.gao@marvell.com>
Signed-off-by: Chris Ball <cjb@laptop.org>
2011-05-05 06:48:57 +00:00
|
|
|
}
|
|
|
|
|
2013-01-28 14:08:28 +00:00
|
|
|
/* Keep clock gated for at least 5 ms */
|
|
|
|
mmc_delay(5);
|
|
|
|
host->ios.clock = clock;
|
|
|
|
mmc_set_ios(host);
|
|
|
|
|
2013-08-20 10:02:09 +00:00
|
|
|
host->card_clock_off = false;
|
2013-01-28 14:08:28 +00:00
|
|
|
/* Wait for at least 1 ms according to spec */
|
|
|
|
mmc_delay(1);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Failure to switch is indicated by the card holding
|
|
|
|
* dat[0:3] low
|
|
|
|
*/
|
|
|
|
if (host->ops->card_busy && host->ops->card_busy(host))
|
|
|
|
err = -EAGAIN;
|
|
|
|
|
|
|
|
power_cycle:
|
|
|
|
if (err) {
|
|
|
|
pr_debug("%s: Signal voltage switch failed, "
|
|
|
|
"power cycling card\n", mmc_hostname(host));
|
|
|
|
mmc_power_cycle(host);
|
|
|
|
}
|
|
|
|
|
2013-09-06 13:37:07 +00:00
|
|
|
exit:
|
2013-01-28 14:08:28 +00:00
|
|
|
mmc_host_clk_release(host);
|
|
|
|
|
|
|
|
return err;
|
mmc: sd: add support for signal voltage switch procedure
Host Controller v3.00 adds another Capabilities register. Apart
from other things, this new register indicates whether the Host
Controller supports SDR50, SDR104, and DDR50 UHS-I modes. The spec
doesn't mention about explicit support for SDR12 and SDR25 UHS-I
modes, so the Host Controller v3.00 should support them by default.
Also if the controller supports SDR104 mode, it will also support
SDR50 mode as well. So depending on the host support, we set the
corresponding MMC_CAP_* flags. One more new register. Host Control2
is added in v3.00, which is used during Signal Voltage Switch
procedure described below.
Since as per v3.00 spec, UHS-I supported hosts should set S18R
to 1, we set S18R (bit 24) of OCR before sending ACMD41. We also
need to set XPC (bit 28) of OCR in case the host can supply >150mA.
This support is indicated by the Maximum Current Capabilities
register of the Host Controller.
If the response of ACMD41 has both CCS and S18A set, we start the
signal voltage switch procedure, which if successfull, will switch
the card from 3.3V signalling to 1.8V signalling. Signal voltage
switch procedure adds support for a new command CMD11 in the
Physical Layer Spec v3.01. As part of this procedure, we need to
set 1.8V Signalling Enable (bit 3) of Host Control2 register, which
if remains set after 5ms, means the switch to 1.8V signalling is
successfull. Otherwise, we clear bit 24 of OCR and retry the
initialization sequence. When we remove the card, and insert the
same or another card, we need to make sure that we start with 3.3V
signalling voltage. So we call mmc_set_signal_voltage() with
MMC_SIGNAL_VOLTAGE_330 set so that we are back to 3.3V signalling
voltage before we actually start initializing the card.
Tested by Zhangfei Gao with a Toshiba uhs card and general hs card,
on mmp2 in SDMA mode.
Signed-off-by: Arindam Nath <arindam.nath@amd.com>
Reviewed-by: Philip Rakity <prakity@marvell.com>
Tested-by: Philip Rakity <prakity@marvell.com>
Acked-by: Zhangfei Gao <zhangfei.gao@marvell.com>
Signed-off-by: Chris Ball <cjb@laptop.org>
2011-05-05 06:48:57 +00:00
|
|
|
}
|
|
|
|
|
2005-09-06 22:18:53 +00:00
|
|
|
/*
|
2006-12-30 23:11:32 +00:00
|
|
|
* Select timing parameters for host.
|
2005-09-06 22:18:53 +00:00
|
|
|
*/
|
2006-12-30 23:11:32 +00:00
|
|
|
void mmc_set_timing(struct mmc_host *host, unsigned int timing)
|
2005-09-06 22:18:53 +00:00
|
|
|
{
|
2011-08-18 12:23:48 +00:00
|
|
|
mmc_host_clk_hold(host);
|
2006-12-30 23:11:32 +00:00
|
|
|
host->ios.timing = timing;
|
|
|
|
mmc_set_ios(host);
|
2011-08-18 12:23:48 +00:00
|
|
|
mmc_host_clk_release(host);
|
2005-09-06 22:18:53 +00:00
|
|
|
}
|
|
|
|
|
2011-05-05 06:48:59 +00:00
|
|
|
/*
|
|
|
|
* Select appropriate driver type for host.
|
|
|
|
*/
|
|
|
|
void mmc_set_driver_type(struct mmc_host *host, unsigned int drv_type)
|
|
|
|
{
|
2011-08-18 12:23:48 +00:00
|
|
|
mmc_host_clk_hold(host);
|
2011-05-05 06:48:59 +00:00
|
|
|
host->ios.drv_type = drv_type;
|
|
|
|
mmc_set_ios(host);
|
2011-08-18 12:23:48 +00:00
|
|
|
mmc_host_clk_release(host);
|
2011-05-05 06:48:59 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2005-12-14 14:57:35 +00:00
|
|
|
* 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.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2012-03-12 19:03:00 +00:00
|
|
|
void mmc_power_up(struct mmc_host *host)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-09-22 23:44:18 +00:00
|
|
|
int bit;
|
|
|
|
|
2012-05-09 14:15:26 +00:00
|
|
|
if (host->ios.power_mode == MMC_POWER_ON)
|
|
|
|
return;
|
|
|
|
|
2011-08-18 12:23:48 +00:00
|
|
|
mmc_host_clk_hold(host);
|
|
|
|
|
2009-09-22 23:44:18 +00:00
|
|
|
/* If ocr is set, we use it */
|
|
|
|
if (host->ocr)
|
|
|
|
bit = ffs(host->ocr) - 1;
|
|
|
|
else
|
|
|
|
bit = fls(host->ocr_avail) - 1;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
host->ios.vdd = bit;
|
2013-04-18 12:48:00 +00:00
|
|
|
if (mmc_host_is_spi(host))
|
MMC core learns about SPI
Teach the MMC/SD/SDIO core about using SPI mode.
- Use mmc_host_is_spi() so enumeration works through SPI signaling
and protocols, not just the native versions.
- Provide the SPI response type flags with each request issued,
including requests from the new lock/unlock code.
- Understand that cmd->resp[0] and mmc_get_status() results for SPI
return different values than for "native" MMC/SD protocol; this
affects resetting, checking card lock status, and some others.
- Understand that some commands act a bit differently ... notably:
* OP_COND command doesn't return the OCR
* APP_CMD status doesn't have an R1_APP_CMD analogue
Those changes required some new and updated primitives:
- Provide utilities to access two SPI-only requests, and one
request that wasn't previously needed:
* mmc_spi_read_ocr() ... SPI only
* mmc_spi_set_crc() ... SPI only (override by module parm)
* mmc_send_cid() ... for use without broadcast mode
- Updated internal routines:
* Previous mmc_send_csd() modified into mmc_send_cxd_native();
it uses native "R2" responses, which include 16 bytes of data.
* Previous mmc_send_ext_csd() becomes new mmc_send_cxd_data()
helper for command-and-data access
* Bugfix to that mmc_send_cxd_data() code: dma-to-stack is
unsafe/nonportable, so kmalloc a bounce buffer instead.
- Modified mmc_send_ext_csd() now uses mmc_send_cxd_data() helper
- Modified mmc_send_csd(), and new mmc_spi_send_cid(), routines use
those helper routines based on whether they're native or SPI
The newest categories of cards supported by the MMC stack aren't expected
to work yet with SPI: MMC or SD cards with over 4GB data, and SDIO.
All those cards support SPI mode, so eventually they should work too.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Pierre Ossman <drzeus@drzeus.cx>
2007-08-08 16:11:32 +00:00
|
|
|
host->ios.chip_select = MMC_CS_HIGH;
|
2013-02-12 01:29:56 +00:00
|
|
|
else {
|
MMC core learns about SPI
Teach the MMC/SD/SDIO core about using SPI mode.
- Use mmc_host_is_spi() so enumeration works through SPI signaling
and protocols, not just the native versions.
- Provide the SPI response type flags with each request issued,
including requests from the new lock/unlock code.
- Understand that cmd->resp[0] and mmc_get_status() results for SPI
return different values than for "native" MMC/SD protocol; this
affects resetting, checking card lock status, and some others.
- Understand that some commands act a bit differently ... notably:
* OP_COND command doesn't return the OCR
* APP_CMD status doesn't have an R1_APP_CMD analogue
Those changes required some new and updated primitives:
- Provide utilities to access two SPI-only requests, and one
request that wasn't previously needed:
* mmc_spi_read_ocr() ... SPI only
* mmc_spi_set_crc() ... SPI only (override by module parm)
* mmc_send_cid() ... for use without broadcast mode
- Updated internal routines:
* Previous mmc_send_csd() modified into mmc_send_cxd_native();
it uses native "R2" responses, which include 16 bytes of data.
* Previous mmc_send_ext_csd() becomes new mmc_send_cxd_data()
helper for command-and-data access
* Bugfix to that mmc_send_cxd_data() code: dma-to-stack is
unsafe/nonportable, so kmalloc a bounce buffer instead.
- Modified mmc_send_ext_csd() now uses mmc_send_cxd_data() helper
- Modified mmc_send_csd(), and new mmc_spi_send_cid(), routines use
those helper routines based on whether they're native or SPI
The newest categories of cards supported by the MMC stack aren't expected
to work yet with SPI: MMC or SD cards with over 4GB data, and SDIO.
All those cards support SPI mode, so eventually they should work too.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Pierre Ossman <drzeus@drzeus.cx>
2007-08-08 16:11:32 +00:00
|
|
|
host->ios.chip_select = MMC_CS_DONTCARE;
|
2013-02-12 01:29:56 +00:00
|
|
|
host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
host->ios.power_mode = MMC_POWER_UP;
|
2005-09-06 22:18:55 +00:00
|
|
|
host->ios.bus_width = MMC_BUS_WIDTH_1;
|
2007-02-18 11:07:47 +00:00
|
|
|
host->ios.timing = MMC_TIMING_LEGACY;
|
2006-05-04 17:22:51 +00:00
|
|
|
mmc_set_ios(host);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-09-19 16:38:50 +00:00
|
|
|
/*
|
|
|
|
* This delay should be sufficient to allow the power supply
|
|
|
|
* to reach the minimum voltage.
|
|
|
|
*/
|
2014-09-30 02:30:23 +00:00
|
|
|
mmc_delay(10);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-09-06 01:37:19 +00:00
|
|
|
host->ios.clock = host->f_init;
|
2009-04-09 06:32:02 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
host->ios.power_mode = MMC_POWER_ON;
|
2006-05-04 17:22:51 +00:00
|
|
|
mmc_set_ios(host);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-09-19 16:38:50 +00:00
|
|
|
/*
|
|
|
|
* This delay must be at least 74 clock sizes, or 1 ms, or the
|
|
|
|
* time required to reach a stable voltage.
|
|
|
|
*/
|
2009-03-10 01:21:21 +00:00
|
|
|
mmc_delay(10);
|
2011-08-18 12:23:48 +00:00
|
|
|
|
2013-04-16 12:43:02 +00:00
|
|
|
/* Set signal voltage to 3.3V */
|
|
|
|
__mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330);
|
|
|
|
|
2011-08-18 12:23:48 +00:00
|
|
|
mmc_host_clk_release(host);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2011-09-21 18:08:13 +00:00
|
|
|
void mmc_power_off(struct mmc_host *host)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2012-05-09 14:15:26 +00:00
|
|
|
if (host->ios.power_mode == MMC_POWER_OFF)
|
|
|
|
return;
|
|
|
|
|
2011-08-18 12:23:48 +00:00
|
|
|
mmc_host_clk_hold(host);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
host->ios.clock = 0;
|
|
|
|
host->ios.vdd = 0;
|
2011-03-05 13:36:24 +00:00
|
|
|
|
2011-10-13 06:34:16 +00:00
|
|
|
|
2011-03-05 13:36:24 +00:00
|
|
|
/*
|
|
|
|
* 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);
|
|
|
|
|
MMC core learns about SPI
Teach the MMC/SD/SDIO core about using SPI mode.
- Use mmc_host_is_spi() so enumeration works through SPI signaling
and protocols, not just the native versions.
- Provide the SPI response type flags with each request issued,
including requests from the new lock/unlock code.
- Understand that cmd->resp[0] and mmc_get_status() results for SPI
return different values than for "native" MMC/SD protocol; this
affects resetting, checking card lock status, and some others.
- Understand that some commands act a bit differently ... notably:
* OP_COND command doesn't return the OCR
* APP_CMD status doesn't have an R1_APP_CMD analogue
Those changes required some new and updated primitives:
- Provide utilities to access two SPI-only requests, and one
request that wasn't previously needed:
* mmc_spi_read_ocr() ... SPI only
* mmc_spi_set_crc() ... SPI only (override by module parm)
* mmc_send_cid() ... for use without broadcast mode
- Updated internal routines:
* Previous mmc_send_csd() modified into mmc_send_cxd_native();
it uses native "R2" responses, which include 16 bytes of data.
* Previous mmc_send_ext_csd() becomes new mmc_send_cxd_data()
helper for command-and-data access
* Bugfix to that mmc_send_cxd_data() code: dma-to-stack is
unsafe/nonportable, so kmalloc a bounce buffer instead.
- Modified mmc_send_ext_csd() now uses mmc_send_cxd_data() helper
- Modified mmc_send_csd(), and new mmc_spi_send_cid(), routines use
those helper routines based on whether they're native or SPI
The newest categories of cards supported by the MMC stack aren't expected
to work yet with SPI: MMC or SD cards with over 4GB data, and SDIO.
All those cards support SPI mode, so eventually they should work too.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Pierre Ossman <drzeus@drzeus.cx>
2007-08-08 16:11:32 +00:00
|
|
|
if (!mmc_host_is_spi(host)) {
|
|
|
|
host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
|
|
|
|
host->ios.chip_select = MMC_CS_DONTCARE;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
host->ios.power_mode = MMC_POWER_OFF;
|
2005-09-06 22:18:55 +00:00
|
|
|
host->ios.bus_width = MMC_BUS_WIDTH_1;
|
2007-02-18 11:07:47 +00:00
|
|
|
host->ios.timing = MMC_TIMING_LEGACY;
|
2006-05-04 17:22:51 +00:00
|
|
|
mmc_set_ios(host);
|
2011-08-18 12:23:48 +00:00
|
|
|
|
2011-09-07 09:22:09 +00:00
|
|
|
/*
|
|
|
|
* 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);
|
|
|
|
|
2011-08-18 12:23:48 +00:00
|
|
|
mmc_host_clk_release(host);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2013-01-28 14:08:25 +00:00
|
|
|
void mmc_power_cycle(struct mmc_host *host)
|
|
|
|
{
|
|
|
|
mmc_power_off(host);
|
|
|
|
/* Wait at least 1 ms according to SD spec */
|
|
|
|
mmc_delay(1);
|
|
|
|
mmc_power_up(host);
|
|
|
|
}
|
|
|
|
|
2007-07-24 22:40:58 +00:00
|
|
|
/*
|
|
|
|
* Cleanup when the last reference to the bus operator is dropped.
|
|
|
|
*/
|
2008-04-13 18:15:47 +00:00
|
|
|
static void __mmc_release_bus(struct mmc_host *host)
|
2007-07-24 22:40:58 +00:00
|
|
|
{
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2009-07-30 14:55:28 +00:00
|
|
|
int mmc_resume_bus(struct mmc_host *host)
|
|
|
|
{
|
2010-10-14 22:20:21 +00:00
|
|
|
unsigned long flags;
|
2016-02-10 08:41:04 +00:00
|
|
|
int err = 0;
|
2010-10-14 22:20:21 +00:00
|
|
|
|
2017-04-18 01:29:57 +00:00
|
|
|
if (!mmc_bus_needs_resume(host))
|
2009-07-30 14:55:28 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
2010-10-14 22:20:21 +00:00
|
|
|
spin_lock_irqsave(&host->lock, flags);
|
2009-07-30 14:55:28 +00:00
|
|
|
host->bus_resume_flags &= ~MMC_BUSRESUME_NEEDS_RESUME;
|
2010-10-14 22:20:21 +00:00
|
|
|
host->rescan_disable = 0;
|
|
|
|
spin_unlock_irqrestore(&host->lock, flags);
|
|
|
|
|
2009-07-30 14:55:28 +00:00
|
|
|
mmc_bus_get(host);
|
|
|
|
if (host->bus_ops && !host->bus_dead) {
|
|
|
|
mmc_power_up(host);
|
|
|
|
BUG_ON(!host->bus_ops->resume);
|
|
|
|
host->bus_ops->resume(host);
|
2016-02-10 08:41:04 +00:00
|
|
|
if (mmc_card_cmdq(host->card)) {
|
|
|
|
err = mmc_cmdq_halt(host, false);
|
|
|
|
if (err)
|
|
|
|
pr_err("%s: un-halt: failed: %d\n",
|
|
|
|
__func__, err);
|
|
|
|
else
|
|
|
|
mmc_card_clr_suspended(host->card);
|
|
|
|
}
|
|
|
|
host->dev_status = DEV_RESUMED;
|
2009-07-30 14:55:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
mmc_bus_put(host);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(mmc_resume_bus);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2006-12-30 23:11:32 +00:00
|
|
|
* Assign a mmc bus handler to a host. Only one bus handler may control a
|
|
|
|
* host at any given time.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2006-12-30 23:11:32 +00:00
|
|
|
void mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-12-30 23:11:32 +00:00
|
|
|
unsigned long flags;
|
2006-10-29 09:14:19 +00:00
|
|
|
|
2006-12-30 23:11:32 +00:00
|
|
|
BUG_ON(!host);
|
|
|
|
BUG_ON(!ops);
|
2007-01-03 18:47:29 +00:00
|
|
|
|
2007-08-09 11:23:56 +00:00
|
|
|
WARN_ON(!host->claimed);
|
2006-10-21 10:35:02 +00:00
|
|
|
|
2006-12-30 23:11:32 +00:00
|
|
|
spin_lock_irqsave(&host->lock, flags);
|
2006-10-21 10:35:02 +00:00
|
|
|
|
2006-12-30 23:11:32 +00:00
|
|
|
BUG_ON(host->bus_ops);
|
|
|
|
BUG_ON(host->bus_refs);
|
2005-09-06 22:18:53 +00:00
|
|
|
|
2006-12-30 23:11:32 +00:00
|
|
|
host->bus_ops = ops;
|
|
|
|
host->bus_refs = 1;
|
|
|
|
host->bus_dead = 0;
|
2005-09-06 22:18:53 +00:00
|
|
|
|
2006-12-30 23:11:32 +00:00
|
|
|
spin_unlock_irqrestore(&host->lock, flags);
|
2005-09-06 22:18:53 +00:00
|
|
|
}
|
|
|
|
|
2006-12-30 23:11:32 +00:00
|
|
|
/*
|
2011-09-21 18:08:13 +00:00
|
|
|
* Remove the current bus handler from a host.
|
2006-12-30 23:11:32 +00:00
|
|
|
*/
|
|
|
|
void mmc_detach_bus(struct mmc_host *host)
|
2006-11-08 22:03:10 +00:00
|
|
|
{
|
2006-12-30 23:11:32 +00:00
|
|
|
unsigned long flags;
|
2006-11-08 22:03:10 +00:00
|
|
|
|
2006-12-30 23:11:32 +00:00
|
|
|
BUG_ON(!host);
|
2006-11-08 22:03:10 +00:00
|
|
|
|
2007-08-09 11:23:56 +00:00
|
|
|
WARN_ON(!host->claimed);
|
|
|
|
WARN_ON(!host->bus_ops);
|
2007-02-18 11:07:47 +00:00
|
|
|
|
2006-12-30 23:11:32 +00:00
|
|
|
spin_lock_irqsave(&host->lock, flags);
|
2006-11-08 22:03:10 +00:00
|
|
|
|
2006-12-30 23:11:32 +00:00
|
|
|
host->bus_dead = 1;
|
2006-11-08 22:03:10 +00:00
|
|
|
|
2006-12-30 23:11:32 +00:00
|
|
|
spin_unlock_irqrestore(&host->lock, flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-12-30 23:11:32 +00:00
|
|
|
mmc_bus_put(host);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* mmc_detect_change - process change of state on a MMC socket
|
|
|
|
* @host: host which changed state.
|
2005-09-08 16:53:01 +00:00
|
|
|
* @delay: optional delay to wait before detection (jiffies)
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2007-07-11 18:22:11 +00:00
|
|
|
* 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.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2005-09-08 16:53:01 +00:00
|
|
|
void mmc_detect_change(struct mmc_host *host, unsigned long delay)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-02-11 19:43:19 +00:00
|
|
|
#ifdef CONFIG_MMC_DEBUG
|
2007-05-08 20:35:17 +00:00
|
|
|
unsigned long flags;
|
2007-05-09 09:32:34 +00:00
|
|
|
spin_lock_irqsave(&host->lock, flags);
|
2007-08-09 11:23:56 +00:00
|
|
|
WARN_ON(host->removed);
|
2007-05-09 09:32:34 +00:00
|
|
|
spin_unlock_irqrestore(&host->lock, flags);
|
2007-02-11 19:43:19 +00:00
|
|
|
#endif
|
2011-11-28 14:22:00 +00:00
|
|
|
host->detect_change = 1;
|
2011-09-08 00:28:58 +00:00
|
|
|
|
2006-11-22 14:57:56 +00:00
|
|
|
mmc_schedule_delayed_work(&host->detect, delay);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(mmc_detect_change);
|
|
|
|
|
mmc: add erase, secure erase, trim and secure trim operations
SD/MMC cards tend to support an erase operation. In addition, eMMC v4.4
cards can support secure erase, trim and secure trim operations that are
all variants of the basic erase command.
SD/MMC device attributes "erase_size" and "preferred_erase_size" have been
added.
"erase_size" is the minimum size, in bytes, of an erase operation. For
MMC, "erase_size" is the erase group size reported by the card. Note that
"erase_size" does not apply to trim or secure trim operations where the
minimum size is always one 512 byte sector. For SD, "erase_size" is 512
if the card is block-addressed, 0 otherwise.
SD/MMC cards can erase an arbitrarily large area up to and
including the whole card. When erasing a large area it may
be desirable to do it in smaller chunks for three reasons:
1. A single erase command will make all other I/O on the card
wait. This is not a problem if the whole card is being erased, but
erasing one partition will make I/O for another partition on the
same card wait for the duration of the erase - which could be a
several minutes.
2. To be able to inform the user of erase progress.
3. The erase timeout becomes too large to be very useful.
Because the erase timeout contains a margin which is multiplied by
the size of the erase area, the value can end up being several
minutes for large areas.
"erase_size" is not the most efficient unit to erase (especially for SD
where it is just one sector), hence "preferred_erase_size" provides a good
chunk size for erasing large areas.
For MMC, "preferred_erase_size" is the high-capacity erase size if a card
specifies one, otherwise it is based on the capacity of the card.
For SD, "preferred_erase_size" is the allocation unit size specified by
the card.
"preferred_erase_size" is in bytes.
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Cc: Kyungmin Park <kmpark@infradead.org>
Cc: Madhusudhan Chikkature <madhu.cr@ti.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ben Gardiner <bengardiner@nanometrics.ca>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 21:17:46 +00:00
|
|
|
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;
|
mmc: core: resolve divded by zero panic
With one special SD card, below divide by zero error observed:
...
[ 2.144300] divide error: 0000 [#1] PREEMPT SMP
[ 2.148860] Modules linked in:
[ 2.151898]
[ 2.152685] Set up 4031 stolen pages starting at 0x0001f000, GTT offset 0K
[ 2.157330] Set up 0 CI stolen pages starting at 0x00000000, GTT offset 131072K
[ 2.167581] Pid: 5, comm: kworker/u:0 Not tainted 3.0.8-138216-g974a2ab #1
[ 2.169506] [drm] PSB GTT mem manager ready, tt_start 4031, tt_size 28737 pages
[ 2.169906] [drm] SGX core id = 0x00000000
[ 2.169920] [drm] SGX core rev major = 0x00, minor = 0x00
[ 2.169934] [drm] SGX core rev maintenance = 0x00, designer = 0x00
[ 2.197370] Intel Corporation Medfield/iCDKB
[ 2.201716] EIP: 0060:[<c1697ca6>] EFLAGS: 00010246 CPU: 1
[ 2.207198] EIP is at mmc_init_erase+0x76/0x150
[ 2.211704] EAX: 00002000 EBX: dcd1b400 ECX: 00002000 EDX: 00000000
[ 2.217957] ESI: 00000000 EDI: dcd5c800 EBP: dd867e84 ESP: dd867e7c
[ 2.224214] DS: 007b ES: 007b FS: 00d8 GS: 0000 SS: 0068
[ 2.229605] Process kworker/u:0 (pid: 5, ti=dd866000 task=dd868000 task.ti=dd866000)
[ 2.237325] Stack:
[ 2.239322] dcd1b400 00000000 dd867eb0 c16a06da c1ab7c44 dd995aa8 00000003 00000000
[ 2.247054] 00000000 00000000 dcd5c800 00000000 dcd1b400 dd867ef8 c16a1012 c1698b00
[ 2.254785] 00000029 00000001 c194eb80 dcd5c9ec dd867e00 c1239b00 00000000 00000000
[ 2.262519] Call Trace:
[ 2.264975] [<c16a06da>] mmc_sd_setup_card+0x1da/0x4f0
[ 2.270183] [<c16a1012>] mmc_sd_init_card+0x192/0xc40
[ 2.275304] [<c1698b00>] ? __mmc_claim_host+0x160/0x160
[ 2.280610] [<c1239b00>] ? __schedule_bug+0x50/0x80
[ 2.285556] [<c16a1b89>] mmc_attach_sd+0xc9/0x230
[ 2.290333] [<c169b6ef>] mmc_rescan+0x25f/0x2c0
[ 2.294943] [<c1274223>] process_one_work+0x103/0x400
[ 2.300065] [<c12670fd>] ? mod_timer+0x1ad/0x3c0
[ 2.304756] [<c169b490>] ? mmc_suspend_host+0x1a0/0x1a0
[ 2.310056] [<c127502d>] worker_thread+0x12d/0x4a0
[ 2.314921] [<c18fcfbd>] ? preempt_schedule+0x2d/0x50
[ 2.320047] [<c1274f00[ 2.323976] ---[ end trace 5398ec2720494438 ]---
...
So, seems this bad SD card does not set valid value in related SSR / CSD register fields.
And then the driver will set card->erase_size to 0.
Then it triggered this divided by zero error when calculate card->pref_erase.
Submit this patch to fix the issue.
Signed-off-by: Yunpeng Gao <yunpeng.gao@intel.com>
Signed-off-by: Chuanxiao Dong <chuanxiao.dong@intel.com>
Signed-off-by: Ulf Hansson <ulf.hansson@linaro.org>
Git commit: cc8aa7de48277f62fe3fced762d75f01ce57e909
Git-repo: git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Change-Id: Icd28093ab823e20456fac9c2cb0c51475b389e1d
Signed-off-by: Sahitya Tummala <stummala@codeaurora.org>
2014-08-14 10:29:24 +00:00
|
|
|
} else if (card->erase_size) {
|
mmc: add erase, secure erase, trim and secure trim operations
SD/MMC cards tend to support an erase operation. In addition, eMMC v4.4
cards can support secure erase, trim and secure trim operations that are
all variants of the basic erase command.
SD/MMC device attributes "erase_size" and "preferred_erase_size" have been
added.
"erase_size" is the minimum size, in bytes, of an erase operation. For
MMC, "erase_size" is the erase group size reported by the card. Note that
"erase_size" does not apply to trim or secure trim operations where the
minimum size is always one 512 byte sector. For SD, "erase_size" is 512
if the card is block-addressed, 0 otherwise.
SD/MMC cards can erase an arbitrarily large area up to and
including the whole card. When erasing a large area it may
be desirable to do it in smaller chunks for three reasons:
1. A single erase command will make all other I/O on the card
wait. This is not a problem if the whole card is being erased, but
erasing one partition will make I/O for another partition on the
same card wait for the duration of the erase - which could be a
several minutes.
2. To be able to inform the user of erase progress.
3. The erase timeout becomes too large to be very useful.
Because the erase timeout contains a margin which is multiplied by
the size of the erase area, the value can end up being several
minutes for large areas.
"erase_size" is not the most efficient unit to erase (especially for SD
where it is just one sector), hence "preferred_erase_size" provides a good
chunk size for erasing large areas.
For MMC, "preferred_erase_size" is the high-capacity erase size if a card
specifies one, otherwise it is based on the capacity of the card.
For SD, "preferred_erase_size" is the allocation unit size specified by
the card.
"preferred_erase_size" is in bytes.
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Cc: Kyungmin Park <kmpark@infradead.org>
Cc: Madhusudhan Chikkature <madhu.cr@ti.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ben Gardiner <bengardiner@nanometrics.ca>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 21:17:46 +00:00
|
|
|
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;
|
|
|
|
}
|
mmc: core: resolve divded by zero panic
With one special SD card, below divide by zero error observed:
...
[ 2.144300] divide error: 0000 [#1] PREEMPT SMP
[ 2.148860] Modules linked in:
[ 2.151898]
[ 2.152685] Set up 4031 stolen pages starting at 0x0001f000, GTT offset 0K
[ 2.157330] Set up 0 CI stolen pages starting at 0x00000000, GTT offset 131072K
[ 2.167581] Pid: 5, comm: kworker/u:0 Not tainted 3.0.8-138216-g974a2ab #1
[ 2.169506] [drm] PSB GTT mem manager ready, tt_start 4031, tt_size 28737 pages
[ 2.169906] [drm] SGX core id = 0x00000000
[ 2.169920] [drm] SGX core rev major = 0x00, minor = 0x00
[ 2.169934] [drm] SGX core rev maintenance = 0x00, designer = 0x00
[ 2.197370] Intel Corporation Medfield/iCDKB
[ 2.201716] EIP: 0060:[<c1697ca6>] EFLAGS: 00010246 CPU: 1
[ 2.207198] EIP is at mmc_init_erase+0x76/0x150
[ 2.211704] EAX: 00002000 EBX: dcd1b400 ECX: 00002000 EDX: 00000000
[ 2.217957] ESI: 00000000 EDI: dcd5c800 EBP: dd867e84 ESP: dd867e7c
[ 2.224214] DS: 007b ES: 007b FS: 00d8 GS: 0000 SS: 0068
[ 2.229605] Process kworker/u:0 (pid: 5, ti=dd866000 task=dd868000 task.ti=dd866000)
[ 2.237325] Stack:
[ 2.239322] dcd1b400 00000000 dd867eb0 c16a06da c1ab7c44 dd995aa8 00000003 00000000
[ 2.247054] 00000000 00000000 dcd5c800 00000000 dcd1b400 dd867ef8 c16a1012 c1698b00
[ 2.254785] 00000029 00000001 c194eb80 dcd5c9ec dd867e00 c1239b00 00000000 00000000
[ 2.262519] Call Trace:
[ 2.264975] [<c16a06da>] mmc_sd_setup_card+0x1da/0x4f0
[ 2.270183] [<c16a1012>] mmc_sd_init_card+0x192/0xc40
[ 2.275304] [<c1698b00>] ? __mmc_claim_host+0x160/0x160
[ 2.280610] [<c1239b00>] ? __schedule_bug+0x50/0x80
[ 2.285556] [<c16a1b89>] mmc_attach_sd+0xc9/0x230
[ 2.290333] [<c169b6ef>] mmc_rescan+0x25f/0x2c0
[ 2.294943] [<c1274223>] process_one_work+0x103/0x400
[ 2.300065] [<c12670fd>] ? mod_timer+0x1ad/0x3c0
[ 2.304756] [<c169b490>] ? mmc_suspend_host+0x1a0/0x1a0
[ 2.310056] [<c127502d>] worker_thread+0x12d/0x4a0
[ 2.314921] [<c18fcfbd>] ? preempt_schedule+0x2d/0x50
[ 2.320047] [<c1274f00[ 2.323976] ---[ end trace 5398ec2720494438 ]---
...
So, seems this bad SD card does not set valid value in related SSR / CSD register fields.
And then the driver will set card->erase_size to 0.
Then it triggered this divided by zero error when calculate card->pref_erase.
Submit this patch to fix the issue.
Signed-off-by: Yunpeng Gao <yunpeng.gao@intel.com>
Signed-off-by: Chuanxiao Dong <chuanxiao.dong@intel.com>
Signed-off-by: Ulf Hansson <ulf.hansson@linaro.org>
Git commit: cc8aa7de48277f62fe3fced762d75f01ce57e909
Git-repo: git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Change-Id: Icd28093ab823e20456fac9c2cb0c51475b389e1d
Signed-off-by: Sahitya Tummala <stummala@codeaurora.org>
2014-08-14 10:29:24 +00:00
|
|
|
} else
|
|
|
|
card->pref_erase = 0;
|
mmc: add erase, secure erase, trim and secure trim operations
SD/MMC cards tend to support an erase operation. In addition, eMMC v4.4
cards can support secure erase, trim and secure trim operations that are
all variants of the basic erase command.
SD/MMC device attributes "erase_size" and "preferred_erase_size" have been
added.
"erase_size" is the minimum size, in bytes, of an erase operation. For
MMC, "erase_size" is the erase group size reported by the card. Note that
"erase_size" does not apply to trim or secure trim operations where the
minimum size is always one 512 byte sector. For SD, "erase_size" is 512
if the card is block-addressed, 0 otherwise.
SD/MMC cards can erase an arbitrarily large area up to and
including the whole card. When erasing a large area it may
be desirable to do it in smaller chunks for three reasons:
1. A single erase command will make all other I/O on the card
wait. This is not a problem if the whole card is being erased, but
erasing one partition will make I/O for another partition on the
same card wait for the duration of the erase - which could be a
several minutes.
2. To be able to inform the user of erase progress.
3. The erase timeout becomes too large to be very useful.
Because the erase timeout contains a margin which is multiplied by
the size of the erase area, the value can end up being several
minutes for large areas.
"erase_size" is not the most efficient unit to erase (especially for SD
where it is just one sector), hence "preferred_erase_size" provides a good
chunk size for erasing large areas.
For MMC, "preferred_erase_size" is the high-capacity erase size if a card
specifies one, otherwise it is based on the capacity of the card.
For SD, "preferred_erase_size" is the allocation unit size specified by
the card.
"preferred_erase_size" is in bytes.
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Cc: Kyungmin Park <kmpark@infradead.org>
Cc: Madhusudhan Chikkature <madhu.cr@ti.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ben Gardiner <bengardiner@nanometrics.ca>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 21:17:46 +00:00
|
|
|
}
|
|
|
|
|
2011-04-11 21:13:41 +00:00
|
|
|
static unsigned int mmc_mmc_erase_timeout(struct mmc_card *card,
|
|
|
|
unsigned int arg, unsigned int qty)
|
mmc: add erase, secure erase, trim and secure trim operations
SD/MMC cards tend to support an erase operation. In addition, eMMC v4.4
cards can support secure erase, trim and secure trim operations that are
all variants of the basic erase command.
SD/MMC device attributes "erase_size" and "preferred_erase_size" have been
added.
"erase_size" is the minimum size, in bytes, of an erase operation. For
MMC, "erase_size" is the erase group size reported by the card. Note that
"erase_size" does not apply to trim or secure trim operations where the
minimum size is always one 512 byte sector. For SD, "erase_size" is 512
if the card is block-addressed, 0 otherwise.
SD/MMC cards can erase an arbitrarily large area up to and
including the whole card. When erasing a large area it may
be desirable to do it in smaller chunks for three reasons:
1. A single erase command will make all other I/O on the card
wait. This is not a problem if the whole card is being erased, but
erasing one partition will make I/O for another partition on the
same card wait for the duration of the erase - which could be a
several minutes.
2. To be able to inform the user of erase progress.
3. The erase timeout becomes too large to be very useful.
Because the erase timeout contains a margin which is multiplied by
the size of the erase area, the value can end up being several
minutes for large areas.
"erase_size" is not the most efficient unit to erase (especially for SD
where it is just one sector), hence "preferred_erase_size" provides a good
chunk size for erasing large areas.
For MMC, "preferred_erase_size" is the high-capacity erase size if a card
specifies one, otherwise it is based on the capacity of the card.
For SD, "preferred_erase_size" is the allocation unit size specified by
the card.
"preferred_erase_size" is in bytes.
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Cc: Kyungmin Park <kmpark@infradead.org>
Cc: Madhusudhan Chikkature <madhu.cr@ti.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ben Gardiner <bengardiner@nanometrics.ca>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 21:17:46 +00:00
|
|
|
{
|
|
|
|
unsigned int erase_timeout;
|
|
|
|
|
2012-04-05 11:45:47 +00:00
|
|
|
if (arg == MMC_DISCARD_ARG ||
|
|
|
|
(arg == MMC_TRIM_ARG && card->ext_csd.rev >= 6)) {
|
|
|
|
erase_timeout = card->ext_csd.trim_timeout;
|
|
|
|
} else if (card->ext_csd.erase_group_def & 1) {
|
mmc: add erase, secure erase, trim and secure trim operations
SD/MMC cards tend to support an erase operation. In addition, eMMC v4.4
cards can support secure erase, trim and secure trim operations that are
all variants of the basic erase command.
SD/MMC device attributes "erase_size" and "preferred_erase_size" have been
added.
"erase_size" is the minimum size, in bytes, of an erase operation. For
MMC, "erase_size" is the erase group size reported by the card. Note that
"erase_size" does not apply to trim or secure trim operations where the
minimum size is always one 512 byte sector. For SD, "erase_size" is 512
if the card is block-addressed, 0 otherwise.
SD/MMC cards can erase an arbitrarily large area up to and
including the whole card. When erasing a large area it may
be desirable to do it in smaller chunks for three reasons:
1. A single erase command will make all other I/O on the card
wait. This is not a problem if the whole card is being erased, but
erasing one partition will make I/O for another partition on the
same card wait for the duration of the erase - which could be a
several minutes.
2. To be able to inform the user of erase progress.
3. The erase timeout becomes too large to be very useful.
Because the erase timeout contains a margin which is multiplied by
the size of the erase area, the value can end up being several
minutes for large areas.
"erase_size" is not the most efficient unit to erase (especially for SD
where it is just one sector), hence "preferred_erase_size" provides a good
chunk size for erasing large areas.
For MMC, "preferred_erase_size" is the high-capacity erase size if a card
specifies one, otherwise it is based on the capacity of the card.
For SD, "preferred_erase_size" is the allocation unit size specified by
the card.
"preferred_erase_size" is in bytes.
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Cc: Kyungmin Park <kmpark@infradead.org>
Cc: Madhusudhan Chikkature <madhu.cr@ti.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ben Gardiner <bengardiner@nanometrics.ca>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 21:17:46 +00:00
|
|
|
/* 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) /
|
2011-06-23 10:40:27 +00:00
|
|
|
(mmc_host_clk_rate(card->host) / 1000);
|
mmc: add erase, secure erase, trim and secure trim operations
SD/MMC cards tend to support an erase operation. In addition, eMMC v4.4
cards can support secure erase, trim and secure trim operations that are
all variants of the basic erase command.
SD/MMC device attributes "erase_size" and "preferred_erase_size" have been
added.
"erase_size" is the minimum size, in bytes, of an erase operation. For
MMC, "erase_size" is the erase group size reported by the card. Note that
"erase_size" does not apply to trim or secure trim operations where the
minimum size is always one 512 byte sector. For SD, "erase_size" is 512
if the card is block-addressed, 0 otherwise.
SD/MMC cards can erase an arbitrarily large area up to and
including the whole card. When erasing a large area it may
be desirable to do it in smaller chunks for three reasons:
1. A single erase command will make all other I/O on the card
wait. This is not a problem if the whole card is being erased, but
erasing one partition will make I/O for another partition on the
same card wait for the duration of the erase - which could be a
several minutes.
2. To be able to inform the user of erase progress.
3. The erase timeout becomes too large to be very useful.
Because the erase timeout contains a margin which is multiplied by
the size of the erase area, the value can end up being several
minutes for large areas.
"erase_size" is not the most efficient unit to erase (especially for SD
where it is just one sector), hence "preferred_erase_size" provides a good
chunk size for erasing large areas.
For MMC, "preferred_erase_size" is the high-capacity erase size if a card
specifies one, otherwise it is based on the capacity of the card.
For SD, "preferred_erase_size" is the allocation unit size specified by
the card.
"preferred_erase_size" is in bytes.
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Cc: Kyungmin Park <kmpark@infradead.org>
Cc: Madhusudhan Chikkature <madhu.cr@ti.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ben Gardiner <bengardiner@nanometrics.ca>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 21:17:46 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
|
2011-04-11 21:13:41 +00:00
|
|
|
return erase_timeout;
|
mmc: add erase, secure erase, trim and secure trim operations
SD/MMC cards tend to support an erase operation. In addition, eMMC v4.4
cards can support secure erase, trim and secure trim operations that are
all variants of the basic erase command.
SD/MMC device attributes "erase_size" and "preferred_erase_size" have been
added.
"erase_size" is the minimum size, in bytes, of an erase operation. For
MMC, "erase_size" is the erase group size reported by the card. Note that
"erase_size" does not apply to trim or secure trim operations where the
minimum size is always one 512 byte sector. For SD, "erase_size" is 512
if the card is block-addressed, 0 otherwise.
SD/MMC cards can erase an arbitrarily large area up to and
including the whole card. When erasing a large area it may
be desirable to do it in smaller chunks for three reasons:
1. A single erase command will make all other I/O on the card
wait. This is not a problem if the whole card is being erased, but
erasing one partition will make I/O for another partition on the
same card wait for the duration of the erase - which could be a
several minutes.
2. To be able to inform the user of erase progress.
3. The erase timeout becomes too large to be very useful.
Because the erase timeout contains a margin which is multiplied by
the size of the erase area, the value can end up being several
minutes for large areas.
"erase_size" is not the most efficient unit to erase (especially for SD
where it is just one sector), hence "preferred_erase_size" provides a good
chunk size for erasing large areas.
For MMC, "preferred_erase_size" is the high-capacity erase size if a card
specifies one, otherwise it is based on the capacity of the card.
For SD, "preferred_erase_size" is the allocation unit size specified by
the card.
"preferred_erase_size" is in bytes.
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Cc: Kyungmin Park <kmpark@infradead.org>
Cc: Madhusudhan Chikkature <madhu.cr@ti.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ben Gardiner <bengardiner@nanometrics.ca>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 21:17:46 +00:00
|
|
|
}
|
|
|
|
|
2011-04-11 21:13:41 +00:00
|
|
|
static unsigned int mmc_sd_erase_timeout(struct mmc_card *card,
|
|
|
|
unsigned int arg,
|
|
|
|
unsigned int qty)
|
mmc: add erase, secure erase, trim and secure trim operations
SD/MMC cards tend to support an erase operation. In addition, eMMC v4.4
cards can support secure erase, trim and secure trim operations that are
all variants of the basic erase command.
SD/MMC device attributes "erase_size" and "preferred_erase_size" have been
added.
"erase_size" is the minimum size, in bytes, of an erase operation. For
MMC, "erase_size" is the erase group size reported by the card. Note that
"erase_size" does not apply to trim or secure trim operations where the
minimum size is always one 512 byte sector. For SD, "erase_size" is 512
if the card is block-addressed, 0 otherwise.
SD/MMC cards can erase an arbitrarily large area up to and
including the whole card. When erasing a large area it may
be desirable to do it in smaller chunks for three reasons:
1. A single erase command will make all other I/O on the card
wait. This is not a problem if the whole card is being erased, but
erasing one partition will make I/O for another partition on the
same card wait for the duration of the erase - which could be a
several minutes.
2. To be able to inform the user of erase progress.
3. The erase timeout becomes too large to be very useful.
Because the erase timeout contains a margin which is multiplied by
the size of the erase area, the value can end up being several
minutes for large areas.
"erase_size" is not the most efficient unit to erase (especially for SD
where it is just one sector), hence "preferred_erase_size" provides a good
chunk size for erasing large areas.
For MMC, "preferred_erase_size" is the high-capacity erase size if a card
specifies one, otherwise it is based on the capacity of the card.
For SD, "preferred_erase_size" is the allocation unit size specified by
the card.
"preferred_erase_size" is in bytes.
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Cc: Kyungmin Park <kmpark@infradead.org>
Cc: Madhusudhan Chikkature <madhu.cr@ti.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ben Gardiner <bengardiner@nanometrics.ca>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 21:17:46 +00:00
|
|
|
{
|
2011-04-11 21:13:41 +00:00
|
|
|
unsigned int erase_timeout;
|
|
|
|
|
mmc: add erase, secure erase, trim and secure trim operations
SD/MMC cards tend to support an erase operation. In addition, eMMC v4.4
cards can support secure erase, trim and secure trim operations that are
all variants of the basic erase command.
SD/MMC device attributes "erase_size" and "preferred_erase_size" have been
added.
"erase_size" is the minimum size, in bytes, of an erase operation. For
MMC, "erase_size" is the erase group size reported by the card. Note that
"erase_size" does not apply to trim or secure trim operations where the
minimum size is always one 512 byte sector. For SD, "erase_size" is 512
if the card is block-addressed, 0 otherwise.
SD/MMC cards can erase an arbitrarily large area up to and
including the whole card. When erasing a large area it may
be desirable to do it in smaller chunks for three reasons:
1. A single erase command will make all other I/O on the card
wait. This is not a problem if the whole card is being erased, but
erasing one partition will make I/O for another partition on the
same card wait for the duration of the erase - which could be a
several minutes.
2. To be able to inform the user of erase progress.
3. The erase timeout becomes too large to be very useful.
Because the erase timeout contains a margin which is multiplied by
the size of the erase area, the value can end up being several
minutes for large areas.
"erase_size" is not the most efficient unit to erase (especially for SD
where it is just one sector), hence "preferred_erase_size" provides a good
chunk size for erasing large areas.
For MMC, "preferred_erase_size" is the high-capacity erase size if a card
specifies one, otherwise it is based on the capacity of the card.
For SD, "preferred_erase_size" is the allocation unit size specified by
the card.
"preferred_erase_size" is in bytes.
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Cc: Kyungmin Park <kmpark@infradead.org>
Cc: Madhusudhan Chikkature <madhu.cr@ti.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ben Gardiner <bengardiner@nanometrics.ca>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 21:17:46 +00:00
|
|
|
if (card->ssr.erase_timeout) {
|
|
|
|
/* Erase timeout specified in SD Status Register (SSR) */
|
2011-04-11 21:13:41 +00:00
|
|
|
erase_timeout = card->ssr.erase_timeout * qty +
|
|
|
|
card->ssr.erase_offset;
|
mmc: add erase, secure erase, trim and secure trim operations
SD/MMC cards tend to support an erase operation. In addition, eMMC v4.4
cards can support secure erase, trim and secure trim operations that are
all variants of the basic erase command.
SD/MMC device attributes "erase_size" and "preferred_erase_size" have been
added.
"erase_size" is the minimum size, in bytes, of an erase operation. For
MMC, "erase_size" is the erase group size reported by the card. Note that
"erase_size" does not apply to trim or secure trim operations where the
minimum size is always one 512 byte sector. For SD, "erase_size" is 512
if the card is block-addressed, 0 otherwise.
SD/MMC cards can erase an arbitrarily large area up to and
including the whole card. When erasing a large area it may
be desirable to do it in smaller chunks for three reasons:
1. A single erase command will make all other I/O on the card
wait. This is not a problem if the whole card is being erased, but
erasing one partition will make I/O for another partition on the
same card wait for the duration of the erase - which could be a
several minutes.
2. To be able to inform the user of erase progress.
3. The erase timeout becomes too large to be very useful.
Because the erase timeout contains a margin which is multiplied by
the size of the erase area, the value can end up being several
minutes for large areas.
"erase_size" is not the most efficient unit to erase (especially for SD
where it is just one sector), hence "preferred_erase_size" provides a good
chunk size for erasing large areas.
For MMC, "preferred_erase_size" is the high-capacity erase size if a card
specifies one, otherwise it is based on the capacity of the card.
For SD, "preferred_erase_size" is the allocation unit size specified by
the card.
"preferred_erase_size" is in bytes.
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Cc: Kyungmin Park <kmpark@infradead.org>
Cc: Madhusudhan Chikkature <madhu.cr@ti.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ben Gardiner <bengardiner@nanometrics.ca>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 21:17:46 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Erase timeout not specified in SD Status Register (SSR) so
|
|
|
|
* use 250ms per write block.
|
|
|
|
*/
|
2011-04-11 21:13:41 +00:00
|
|
|
erase_timeout = 250 * qty;
|
mmc: add erase, secure erase, trim and secure trim operations
SD/MMC cards tend to support an erase operation. In addition, eMMC v4.4
cards can support secure erase, trim and secure trim operations that are
all variants of the basic erase command.
SD/MMC device attributes "erase_size" and "preferred_erase_size" have been
added.
"erase_size" is the minimum size, in bytes, of an erase operation. For
MMC, "erase_size" is the erase group size reported by the card. Note that
"erase_size" does not apply to trim or secure trim operations where the
minimum size is always one 512 byte sector. For SD, "erase_size" is 512
if the card is block-addressed, 0 otherwise.
SD/MMC cards can erase an arbitrarily large area up to and
including the whole card. When erasing a large area it may
be desirable to do it in smaller chunks for three reasons:
1. A single erase command will make all other I/O on the card
wait. This is not a problem if the whole card is being erased, but
erasing one partition will make I/O for another partition on the
same card wait for the duration of the erase - which could be a
several minutes.
2. To be able to inform the user of erase progress.
3. The erase timeout becomes too large to be very useful.
Because the erase timeout contains a margin which is multiplied by
the size of the erase area, the value can end up being several
minutes for large areas.
"erase_size" is not the most efficient unit to erase (especially for SD
where it is just one sector), hence "preferred_erase_size" provides a good
chunk size for erasing large areas.
For MMC, "preferred_erase_size" is the high-capacity erase size if a card
specifies one, otherwise it is based on the capacity of the card.
For SD, "preferred_erase_size" is the allocation unit size specified by
the card.
"preferred_erase_size" is in bytes.
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Cc: Kyungmin Park <kmpark@infradead.org>
Cc: Madhusudhan Chikkature <madhu.cr@ti.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ben Gardiner <bengardiner@nanometrics.ca>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 21:17:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Must not be less than 1 second */
|
2011-04-11 21:13:41 +00:00
|
|
|
if (erase_timeout < 1000)
|
|
|
|
erase_timeout = 1000;
|
|
|
|
|
|
|
|
return erase_timeout;
|
mmc: add erase, secure erase, trim and secure trim operations
SD/MMC cards tend to support an erase operation. In addition, eMMC v4.4
cards can support secure erase, trim and secure trim operations that are
all variants of the basic erase command.
SD/MMC device attributes "erase_size" and "preferred_erase_size" have been
added.
"erase_size" is the minimum size, in bytes, of an erase operation. For
MMC, "erase_size" is the erase group size reported by the card. Note that
"erase_size" does not apply to trim or secure trim operations where the
minimum size is always one 512 byte sector. For SD, "erase_size" is 512
if the card is block-addressed, 0 otherwise.
SD/MMC cards can erase an arbitrarily large area up to and
including the whole card. When erasing a large area it may
be desirable to do it in smaller chunks for three reasons:
1. A single erase command will make all other I/O on the card
wait. This is not a problem if the whole card is being erased, but
erasing one partition will make I/O for another partition on the
same card wait for the duration of the erase - which could be a
several minutes.
2. To be able to inform the user of erase progress.
3. The erase timeout becomes too large to be very useful.
Because the erase timeout contains a margin which is multiplied by
the size of the erase area, the value can end up being several
minutes for large areas.
"erase_size" is not the most efficient unit to erase (especially for SD
where it is just one sector), hence "preferred_erase_size" provides a good
chunk size for erasing large areas.
For MMC, "preferred_erase_size" is the high-capacity erase size if a card
specifies one, otherwise it is based on the capacity of the card.
For SD, "preferred_erase_size" is the allocation unit size specified by
the card.
"preferred_erase_size" is in bytes.
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Cc: Kyungmin Park <kmpark@infradead.org>
Cc: Madhusudhan Chikkature <madhu.cr@ti.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ben Gardiner <bengardiner@nanometrics.ca>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 21:17:46 +00:00
|
|
|
}
|
|
|
|
|
2011-04-11 21:13:41 +00:00
|
|
|
static unsigned int mmc_erase_timeout(struct mmc_card *card,
|
|
|
|
unsigned int arg,
|
|
|
|
unsigned int qty)
|
mmc: add erase, secure erase, trim and secure trim operations
SD/MMC cards tend to support an erase operation. In addition, eMMC v4.4
cards can support secure erase, trim and secure trim operations that are
all variants of the basic erase command.
SD/MMC device attributes "erase_size" and "preferred_erase_size" have been
added.
"erase_size" is the minimum size, in bytes, of an erase operation. For
MMC, "erase_size" is the erase group size reported by the card. Note that
"erase_size" does not apply to trim or secure trim operations where the
minimum size is always one 512 byte sector. For SD, "erase_size" is 512
if the card is block-addressed, 0 otherwise.
SD/MMC cards can erase an arbitrarily large area up to and
including the whole card. When erasing a large area it may
be desirable to do it in smaller chunks for three reasons:
1. A single erase command will make all other I/O on the card
wait. This is not a problem if the whole card is being erased, but
erasing one partition will make I/O for another partition on the
same card wait for the duration of the erase - which could be a
several minutes.
2. To be able to inform the user of erase progress.
3. The erase timeout becomes too large to be very useful.
Because the erase timeout contains a margin which is multiplied by
the size of the erase area, the value can end up being several
minutes for large areas.
"erase_size" is not the most efficient unit to erase (especially for SD
where it is just one sector), hence "preferred_erase_size" provides a good
chunk size for erasing large areas.
For MMC, "preferred_erase_size" is the high-capacity erase size if a card
specifies one, otherwise it is based on the capacity of the card.
For SD, "preferred_erase_size" is the allocation unit size specified by
the card.
"preferred_erase_size" is in bytes.
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Cc: Kyungmin Park <kmpark@infradead.org>
Cc: Madhusudhan Chikkature <madhu.cr@ti.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ben Gardiner <bengardiner@nanometrics.ca>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 21:17:46 +00:00
|
|
|
{
|
|
|
|
if (mmc_card_sd(card))
|
2011-04-11 21:13:41 +00:00
|
|
|
return mmc_sd_erase_timeout(card, arg, qty);
|
mmc: add erase, secure erase, trim and secure trim operations
SD/MMC cards tend to support an erase operation. In addition, eMMC v4.4
cards can support secure erase, trim and secure trim operations that are
all variants of the basic erase command.
SD/MMC device attributes "erase_size" and "preferred_erase_size" have been
added.
"erase_size" is the minimum size, in bytes, of an erase operation. For
MMC, "erase_size" is the erase group size reported by the card. Note that
"erase_size" does not apply to trim or secure trim operations where the
minimum size is always one 512 byte sector. For SD, "erase_size" is 512
if the card is block-addressed, 0 otherwise.
SD/MMC cards can erase an arbitrarily large area up to and
including the whole card. When erasing a large area it may
be desirable to do it in smaller chunks for three reasons:
1. A single erase command will make all other I/O on the card
wait. This is not a problem if the whole card is being erased, but
erasing one partition will make I/O for another partition on the
same card wait for the duration of the erase - which could be a
several minutes.
2. To be able to inform the user of erase progress.
3. The erase timeout becomes too large to be very useful.
Because the erase timeout contains a margin which is multiplied by
the size of the erase area, the value can end up being several
minutes for large areas.
"erase_size" is not the most efficient unit to erase (especially for SD
where it is just one sector), hence "preferred_erase_size" provides a good
chunk size for erasing large areas.
For MMC, "preferred_erase_size" is the high-capacity erase size if a card
specifies one, otherwise it is based on the capacity of the card.
For SD, "preferred_erase_size" is the allocation unit size specified by
the card.
"preferred_erase_size" is in bytes.
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Cc: Kyungmin Park <kmpark@infradead.org>
Cc: Madhusudhan Chikkature <madhu.cr@ti.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ben Gardiner <bengardiner@nanometrics.ca>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 21:17:46 +00:00
|
|
|
else
|
2011-04-11 21:13:41 +00:00
|
|
|
return mmc_mmc_erase_timeout(card, arg, qty);
|
mmc: add erase, secure erase, trim and secure trim operations
SD/MMC cards tend to support an erase operation. In addition, eMMC v4.4
cards can support secure erase, trim and secure trim operations that are
all variants of the basic erase command.
SD/MMC device attributes "erase_size" and "preferred_erase_size" have been
added.
"erase_size" is the minimum size, in bytes, of an erase operation. For
MMC, "erase_size" is the erase group size reported by the card. Note that
"erase_size" does not apply to trim or secure trim operations where the
minimum size is always one 512 byte sector. For SD, "erase_size" is 512
if the card is block-addressed, 0 otherwise.
SD/MMC cards can erase an arbitrarily large area up to and
including the whole card. When erasing a large area it may
be desirable to do it in smaller chunks for three reasons:
1. A single erase command will make all other I/O on the card
wait. This is not a problem if the whole card is being erased, but
erasing one partition will make I/O for another partition on the
same card wait for the duration of the erase - which could be a
several minutes.
2. To be able to inform the user of erase progress.
3. The erase timeout becomes too large to be very useful.
Because the erase timeout contains a margin which is multiplied by
the size of the erase area, the value can end up being several
minutes for large areas.
"erase_size" is not the most efficient unit to erase (especially for SD
where it is just one sector), hence "preferred_erase_size" provides a good
chunk size for erasing large areas.
For MMC, "preferred_erase_size" is the high-capacity erase size if a card
specifies one, otherwise it is based on the capacity of the card.
For SD, "preferred_erase_size" is the allocation unit size specified by
the card.
"preferred_erase_size" is in bytes.
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Cc: Kyungmin Park <kmpark@infradead.org>
Cc: Madhusudhan Chikkature <madhu.cr@ti.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ben Gardiner <bengardiner@nanometrics.ca>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 21:17:46 +00:00
|
|
|
}
|
|
|
|
|
2015-04-23 04:30:27 +00:00
|
|
|
static u32 mmc_get_erase_qty(struct mmc_card *card, u32 from, u32 to)
|
mmc: add erase, secure erase, trim and secure trim operations
SD/MMC cards tend to support an erase operation. In addition, eMMC v4.4
cards can support secure erase, trim and secure trim operations that are
all variants of the basic erase command.
SD/MMC device attributes "erase_size" and "preferred_erase_size" have been
added.
"erase_size" is the minimum size, in bytes, of an erase operation. For
MMC, "erase_size" is the erase group size reported by the card. Note that
"erase_size" does not apply to trim or secure trim operations where the
minimum size is always one 512 byte sector. For SD, "erase_size" is 512
if the card is block-addressed, 0 otherwise.
SD/MMC cards can erase an arbitrarily large area up to and
including the whole card. When erasing a large area it may
be desirable to do it in smaller chunks for three reasons:
1. A single erase command will make all other I/O on the card
wait. This is not a problem if the whole card is being erased, but
erasing one partition will make I/O for another partition on the
same card wait for the duration of the erase - which could be a
several minutes.
2. To be able to inform the user of erase progress.
3. The erase timeout becomes too large to be very useful.
Because the erase timeout contains a margin which is multiplied by
the size of the erase area, the value can end up being several
minutes for large areas.
"erase_size" is not the most efficient unit to erase (especially for SD
where it is just one sector), hence "preferred_erase_size" provides a good
chunk size for erasing large areas.
For MMC, "preferred_erase_size" is the high-capacity erase size if a card
specifies one, otherwise it is based on the capacity of the card.
For SD, "preferred_erase_size" is the allocation unit size specified by
the card.
"preferred_erase_size" is in bytes.
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Cc: Kyungmin Park <kmpark@infradead.org>
Cc: Madhusudhan Chikkature <madhu.cr@ti.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ben Gardiner <bengardiner@nanometrics.ca>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 21:17:46 +00:00
|
|
|
{
|
2015-04-23 04:30:27 +00:00
|
|
|
u32 qty = 0;
|
mmc: add erase, secure erase, trim and secure trim operations
SD/MMC cards tend to support an erase operation. In addition, eMMC v4.4
cards can support secure erase, trim and secure trim operations that are
all variants of the basic erase command.
SD/MMC device attributes "erase_size" and "preferred_erase_size" have been
added.
"erase_size" is the minimum size, in bytes, of an erase operation. For
MMC, "erase_size" is the erase group size reported by the card. Note that
"erase_size" does not apply to trim or secure trim operations where the
minimum size is always one 512 byte sector. For SD, "erase_size" is 512
if the card is block-addressed, 0 otherwise.
SD/MMC cards can erase an arbitrarily large area up to and
including the whole card. When erasing a large area it may
be desirable to do it in smaller chunks for three reasons:
1. A single erase command will make all other I/O on the card
wait. This is not a problem if the whole card is being erased, but
erasing one partition will make I/O for another partition on the
same card wait for the duration of the erase - which could be a
several minutes.
2. To be able to inform the user of erase progress.
3. The erase timeout becomes too large to be very useful.
Because the erase timeout contains a margin which is multiplied by
the size of the erase area, the value can end up being several
minutes for large areas.
"erase_size" is not the most efficient unit to erase (especially for SD
where it is just one sector), hence "preferred_erase_size" provides a good
chunk size for erasing large areas.
For MMC, "preferred_erase_size" is the high-capacity erase size if a card
specifies one, otherwise it is based on the capacity of the card.
For SD, "preferred_erase_size" is the allocation unit size specified by
the card.
"preferred_erase_size" is in bytes.
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Cc: Kyungmin Park <kmpark@infradead.org>
Cc: Madhusudhan Chikkature <madhu.cr@ti.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ben Gardiner <bengardiner@nanometrics.ca>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 21:17:46 +00:00
|
|
|
/*
|
|
|
|
* 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;
|
2015-04-23 04:30:27 +00:00
|
|
|
return qty;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int mmc_cmdq_send_erase_cmd(struct mmc_cmdq_req *cmdq_req,
|
|
|
|
struct mmc_card *card, u32 opcode, u32 arg, u32 qty)
|
|
|
|
{
|
|
|
|
struct mmc_command *cmd = cmdq_req->mrq.cmd;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
memset(cmd, 0, sizeof(struct mmc_command));
|
|
|
|
|
|
|
|
cmd->opcode = opcode;
|
|
|
|
cmd->arg = arg;
|
|
|
|
if (cmd->opcode == MMC_ERASE) {
|
|
|
|
cmd->flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC;
|
|
|
|
cmd->cmd_timeout_ms = mmc_erase_timeout(card, arg, qty);
|
|
|
|
} else {
|
|
|
|
cmd->flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = mmc_cmdq_wait_for_dcmd(card->host, cmdq_req);
|
|
|
|
if (err) {
|
|
|
|
pr_err("mmc_erase: group start error %d, status %#x\n",
|
|
|
|
err, cmd->resp[0]);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int mmc_cmdq_do_erase(struct mmc_cmdq_req *cmdq_req,
|
|
|
|
struct mmc_card *card, unsigned int from,
|
|
|
|
unsigned int to, unsigned int arg)
|
|
|
|
{
|
|
|
|
struct mmc_command *cmd = cmdq_req->mrq.cmd;
|
|
|
|
unsigned int qty = 0;
|
|
|
|
unsigned long timeout;
|
|
|
|
unsigned int fr, nr;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
fr = from;
|
|
|
|
nr = to - from + 1;
|
|
|
|
trace_mmc_blk_erase_start(arg, fr, nr);
|
|
|
|
|
|
|
|
qty = mmc_get_erase_qty(card, from, to);
|
|
|
|
|
|
|
|
if (!mmc_card_blockaddr(card)) {
|
|
|
|
from <<= 9;
|
|
|
|
to <<= 9;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = mmc_cmdq_send_erase_cmd(cmdq_req, card, MMC_ERASE_GROUP_START,
|
|
|
|
from, qty);
|
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
err = mmc_cmdq_send_erase_cmd(cmdq_req, card, MMC_ERASE_GROUP_END,
|
|
|
|
to, qty);
|
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
err = mmc_cmdq_send_erase_cmd(cmdq_req, card, MMC_ERASE,
|
|
|
|
arg, qty);
|
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
timeout = jiffies + msecs_to_jiffies(MMC_CORE_TIMEOUT_MS);
|
|
|
|
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_cmdq_wait_for_dcmd(card->host, cmdq_req);
|
|
|
|
if (err || (cmd->resp[0] & 0xFDF92000)) {
|
|
|
|
pr_err("error %d requesting status %#x\n",
|
|
|
|
err, cmd->resp[0]);
|
|
|
|
err = -EIO;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
/* Timeout if the device never becomes ready for data and
|
|
|
|
* never leaves the program state.
|
|
|
|
*/
|
|
|
|
if (time_after(jiffies, timeout)) {
|
|
|
|
pr_err("%s: Card stuck in programming state! %s\n",
|
|
|
|
mmc_hostname(card->host), __func__);
|
|
|
|
err = -EIO;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
} while (!(cmd->resp[0] & R1_READY_FOR_DATA) ||
|
|
|
|
(R1_CURRENT_STATE(cmd->resp[0]) == R1_STATE_PRG));
|
|
|
|
out:
|
|
|
|
trace_mmc_blk_erase_end(arg, fr, nr);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
unsigned long timeout;
|
|
|
|
unsigned int fr, nr;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
fr = from;
|
|
|
|
nr = to - from + 1;
|
|
|
|
trace_mmc_blk_erase_start(arg, fr, nr);
|
|
|
|
|
|
|
|
qty = mmc_get_erase_qty(card, from, to);
|
mmc: add erase, secure erase, trim and secure trim operations
SD/MMC cards tend to support an erase operation. In addition, eMMC v4.4
cards can support secure erase, trim and secure trim operations that are
all variants of the basic erase command.
SD/MMC device attributes "erase_size" and "preferred_erase_size" have been
added.
"erase_size" is the minimum size, in bytes, of an erase operation. For
MMC, "erase_size" is the erase group size reported by the card. Note that
"erase_size" does not apply to trim or secure trim operations where the
minimum size is always one 512 byte sector. For SD, "erase_size" is 512
if the card is block-addressed, 0 otherwise.
SD/MMC cards can erase an arbitrarily large area up to and
including the whole card. When erasing a large area it may
be desirable to do it in smaller chunks for three reasons:
1. A single erase command will make all other I/O on the card
wait. This is not a problem if the whole card is being erased, but
erasing one partition will make I/O for another partition on the
same card wait for the duration of the erase - which could be a
several minutes.
2. To be able to inform the user of erase progress.
3. The erase timeout becomes too large to be very useful.
Because the erase timeout contains a margin which is multiplied by
the size of the erase area, the value can end up being several
minutes for large areas.
"erase_size" is not the most efficient unit to erase (especially for SD
where it is just one sector), hence "preferred_erase_size" provides a good
chunk size for erasing large areas.
For MMC, "preferred_erase_size" is the high-capacity erase size if a card
specifies one, otherwise it is based on the capacity of the card.
For SD, "preferred_erase_size" is the allocation unit size specified by
the card.
"preferred_erase_size" is in bytes.
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Cc: Kyungmin Park <kmpark@infradead.org>
Cc: Madhusudhan Chikkature <madhu.cr@ti.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ben Gardiner <bengardiner@nanometrics.ca>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 21:17:46 +00:00
|
|
|
|
|
|
|
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) {
|
2011-10-11 06:14:09 +00:00
|
|
|
pr_err("mmc_erase: group start error %d, "
|
mmc: add erase, secure erase, trim and secure trim operations
SD/MMC cards tend to support an erase operation. In addition, eMMC v4.4
cards can support secure erase, trim and secure trim operations that are
all variants of the basic erase command.
SD/MMC device attributes "erase_size" and "preferred_erase_size" have been
added.
"erase_size" is the minimum size, in bytes, of an erase operation. For
MMC, "erase_size" is the erase group size reported by the card. Note that
"erase_size" does not apply to trim or secure trim operations where the
minimum size is always one 512 byte sector. For SD, "erase_size" is 512
if the card is block-addressed, 0 otherwise.
SD/MMC cards can erase an arbitrarily large area up to and
including the whole card. When erasing a large area it may
be desirable to do it in smaller chunks for three reasons:
1. A single erase command will make all other I/O on the card
wait. This is not a problem if the whole card is being erased, but
erasing one partition will make I/O for another partition on the
same card wait for the duration of the erase - which could be a
several minutes.
2. To be able to inform the user of erase progress.
3. The erase timeout becomes too large to be very useful.
Because the erase timeout contains a margin which is multiplied by
the size of the erase area, the value can end up being several
minutes for large areas.
"erase_size" is not the most efficient unit to erase (especially for SD
where it is just one sector), hence "preferred_erase_size" provides a good
chunk size for erasing large areas.
For MMC, "preferred_erase_size" is the high-capacity erase size if a card
specifies one, otherwise it is based on the capacity of the card.
For SD, "preferred_erase_size" is the allocation unit size specified by
the card.
"preferred_erase_size" is in bytes.
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Cc: Kyungmin Park <kmpark@infradead.org>
Cc: Madhusudhan Chikkature <madhu.cr@ti.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ben Gardiner <bengardiner@nanometrics.ca>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 21:17:46 +00:00
|
|
|
"status %#x\n", err, cmd.resp[0]);
|
2011-08-29 13:42:15 +00:00
|
|
|
err = -EIO;
|
mmc: add erase, secure erase, trim and secure trim operations
SD/MMC cards tend to support an erase operation. In addition, eMMC v4.4
cards can support secure erase, trim and secure trim operations that are
all variants of the basic erase command.
SD/MMC device attributes "erase_size" and "preferred_erase_size" have been
added.
"erase_size" is the minimum size, in bytes, of an erase operation. For
MMC, "erase_size" is the erase group size reported by the card. Note that
"erase_size" does not apply to trim or secure trim operations where the
minimum size is always one 512 byte sector. For SD, "erase_size" is 512
if the card is block-addressed, 0 otherwise.
SD/MMC cards can erase an arbitrarily large area up to and
including the whole card. When erasing a large area it may
be desirable to do it in smaller chunks for three reasons:
1. A single erase command will make all other I/O on the card
wait. This is not a problem if the whole card is being erased, but
erasing one partition will make I/O for another partition on the
same card wait for the duration of the erase - which could be a
several minutes.
2. To be able to inform the user of erase progress.
3. The erase timeout becomes too large to be very useful.
Because the erase timeout contains a margin which is multiplied by
the size of the erase area, the value can end up being several
minutes for large areas.
"erase_size" is not the most efficient unit to erase (especially for SD
where it is just one sector), hence "preferred_erase_size" provides a good
chunk size for erasing large areas.
For MMC, "preferred_erase_size" is the high-capacity erase size if a card
specifies one, otherwise it is based on the capacity of the card.
For SD, "preferred_erase_size" is the allocation unit size specified by
the card.
"preferred_erase_size" is in bytes.
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Cc: Kyungmin Park <kmpark@infradead.org>
Cc: Madhusudhan Chikkature <madhu.cr@ti.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ben Gardiner <bengardiner@nanometrics.ca>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 21:17:46 +00:00
|
|
|
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) {
|
2011-10-11 06:14:09 +00:00
|
|
|
pr_err("mmc_erase: group end error %d, status %#x\n",
|
mmc: add erase, secure erase, trim and secure trim operations
SD/MMC cards tend to support an erase operation. In addition, eMMC v4.4
cards can support secure erase, trim and secure trim operations that are
all variants of the basic erase command.
SD/MMC device attributes "erase_size" and "preferred_erase_size" have been
added.
"erase_size" is the minimum size, in bytes, of an erase operation. For
MMC, "erase_size" is the erase group size reported by the card. Note that
"erase_size" does not apply to trim or secure trim operations where the
minimum size is always one 512 byte sector. For SD, "erase_size" is 512
if the card is block-addressed, 0 otherwise.
SD/MMC cards can erase an arbitrarily large area up to and
including the whole card. When erasing a large area it may
be desirable to do it in smaller chunks for three reasons:
1. A single erase command will make all other I/O on the card
wait. This is not a problem if the whole card is being erased, but
erasing one partition will make I/O for another partition on the
same card wait for the duration of the erase - which could be a
several minutes.
2. To be able to inform the user of erase progress.
3. The erase timeout becomes too large to be very useful.
Because the erase timeout contains a margin which is multiplied by
the size of the erase area, the value can end up being several
minutes for large areas.
"erase_size" is not the most efficient unit to erase (especially for SD
where it is just one sector), hence "preferred_erase_size" provides a good
chunk size for erasing large areas.
For MMC, "preferred_erase_size" is the high-capacity erase size if a card
specifies one, otherwise it is based on the capacity of the card.
For SD, "preferred_erase_size" is the allocation unit size specified by
the card.
"preferred_erase_size" is in bytes.
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Cc: Kyungmin Park <kmpark@infradead.org>
Cc: Madhusudhan Chikkature <madhu.cr@ti.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ben Gardiner <bengardiner@nanometrics.ca>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 21:17:46 +00:00
|
|
|
err, cmd.resp[0]);
|
2011-08-29 13:42:15 +00:00
|
|
|
err = -EIO;
|
mmc: add erase, secure erase, trim and secure trim operations
SD/MMC cards tend to support an erase operation. In addition, eMMC v4.4
cards can support secure erase, trim and secure trim operations that are
all variants of the basic erase command.
SD/MMC device attributes "erase_size" and "preferred_erase_size" have been
added.
"erase_size" is the minimum size, in bytes, of an erase operation. For
MMC, "erase_size" is the erase group size reported by the card. Note that
"erase_size" does not apply to trim or secure trim operations where the
minimum size is always one 512 byte sector. For SD, "erase_size" is 512
if the card is block-addressed, 0 otherwise.
SD/MMC cards can erase an arbitrarily large area up to and
including the whole card. When erasing a large area it may
be desirable to do it in smaller chunks for three reasons:
1. A single erase command will make all other I/O on the card
wait. This is not a problem if the whole card is being erased, but
erasing one partition will make I/O for another partition on the
same card wait for the duration of the erase - which could be a
several minutes.
2. To be able to inform the user of erase progress.
3. The erase timeout becomes too large to be very useful.
Because the erase timeout contains a margin which is multiplied by
the size of the erase area, the value can end up being several
minutes for large areas.
"erase_size" is not the most efficient unit to erase (especially for SD
where it is just one sector), hence "preferred_erase_size" provides a good
chunk size for erasing large areas.
For MMC, "preferred_erase_size" is the high-capacity erase size if a card
specifies one, otherwise it is based on the capacity of the card.
For SD, "preferred_erase_size" is the allocation unit size specified by
the card.
"preferred_erase_size" is in bytes.
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Cc: Kyungmin Park <kmpark@infradead.org>
Cc: Madhusudhan Chikkature <madhu.cr@ti.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ben Gardiner <bengardiner@nanometrics.ca>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 21:17:46 +00:00
|
|
|
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;
|
2011-04-11 21:13:41 +00:00
|
|
|
cmd.cmd_timeout_ms = mmc_erase_timeout(card, arg, qty);
|
mmc: add erase, secure erase, trim and secure trim operations
SD/MMC cards tend to support an erase operation. In addition, eMMC v4.4
cards can support secure erase, trim and secure trim operations that are
all variants of the basic erase command.
SD/MMC device attributes "erase_size" and "preferred_erase_size" have been
added.
"erase_size" is the minimum size, in bytes, of an erase operation. For
MMC, "erase_size" is the erase group size reported by the card. Note that
"erase_size" does not apply to trim or secure trim operations where the
minimum size is always one 512 byte sector. For SD, "erase_size" is 512
if the card is block-addressed, 0 otherwise.
SD/MMC cards can erase an arbitrarily large area up to and
including the whole card. When erasing a large area it may
be desirable to do it in smaller chunks for three reasons:
1. A single erase command will make all other I/O on the card
wait. This is not a problem if the whole card is being erased, but
erasing one partition will make I/O for another partition on the
same card wait for the duration of the erase - which could be a
several minutes.
2. To be able to inform the user of erase progress.
3. The erase timeout becomes too large to be very useful.
Because the erase timeout contains a margin which is multiplied by
the size of the erase area, the value can end up being several
minutes for large areas.
"erase_size" is not the most efficient unit to erase (especially for SD
where it is just one sector), hence "preferred_erase_size" provides a good
chunk size for erasing large areas.
For MMC, "preferred_erase_size" is the high-capacity erase size if a card
specifies one, otherwise it is based on the capacity of the card.
For SD, "preferred_erase_size" is the allocation unit size specified by
the card.
"preferred_erase_size" is in bytes.
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Cc: Kyungmin Park <kmpark@infradead.org>
Cc: Madhusudhan Chikkature <madhu.cr@ti.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ben Gardiner <bengardiner@nanometrics.ca>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 21:17:46 +00:00
|
|
|
err = mmc_wait_for_cmd(card->host, &cmd, 0);
|
|
|
|
if (err) {
|
2011-10-11 06:14:09 +00:00
|
|
|
pr_err("mmc_erase: erase error %d, status %#x\n",
|
mmc: add erase, secure erase, trim and secure trim operations
SD/MMC cards tend to support an erase operation. In addition, eMMC v4.4
cards can support secure erase, trim and secure trim operations that are
all variants of the basic erase command.
SD/MMC device attributes "erase_size" and "preferred_erase_size" have been
added.
"erase_size" is the minimum size, in bytes, of an erase operation. For
MMC, "erase_size" is the erase group size reported by the card. Note that
"erase_size" does not apply to trim or secure trim operations where the
minimum size is always one 512 byte sector. For SD, "erase_size" is 512
if the card is block-addressed, 0 otherwise.
SD/MMC cards can erase an arbitrarily large area up to and
including the whole card. When erasing a large area it may
be desirable to do it in smaller chunks for three reasons:
1. A single erase command will make all other I/O on the card
wait. This is not a problem if the whole card is being erased, but
erasing one partition will make I/O for another partition on the
same card wait for the duration of the erase - which could be a
several minutes.
2. To be able to inform the user of erase progress.
3. The erase timeout becomes too large to be very useful.
Because the erase timeout contains a margin which is multiplied by
the size of the erase area, the value can end up being several
minutes for large areas.
"erase_size" is not the most efficient unit to erase (especially for SD
where it is just one sector), hence "preferred_erase_size" provides a good
chunk size for erasing large areas.
For MMC, "preferred_erase_size" is the high-capacity erase size if a card
specifies one, otherwise it is based on the capacity of the card.
For SD, "preferred_erase_size" is the allocation unit size specified by
the card.
"preferred_erase_size" is in bytes.
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Cc: Kyungmin Park <kmpark@infradead.org>
Cc: Madhusudhan Chikkature <madhu.cr@ti.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ben Gardiner <bengardiner@nanometrics.ca>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 21:17:46 +00:00
|
|
|
err, cmd.resp[0]);
|
|
|
|
err = -EIO;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mmc_host_is_spi(card->host))
|
|
|
|
goto out;
|
|
|
|
|
2012-11-16 15:31:41 +00:00
|
|
|
timeout = jiffies + msecs_to_jiffies(MMC_CORE_TIMEOUT_MS);
|
mmc: add erase, secure erase, trim and secure trim operations
SD/MMC cards tend to support an erase operation. In addition, eMMC v4.4
cards can support secure erase, trim and secure trim operations that are
all variants of the basic erase command.
SD/MMC device attributes "erase_size" and "preferred_erase_size" have been
added.
"erase_size" is the minimum size, in bytes, of an erase operation. For
MMC, "erase_size" is the erase group size reported by the card. Note that
"erase_size" does not apply to trim or secure trim operations where the
minimum size is always one 512 byte sector. For SD, "erase_size" is 512
if the card is block-addressed, 0 otherwise.
SD/MMC cards can erase an arbitrarily large area up to and
including the whole card. When erasing a large area it may
be desirable to do it in smaller chunks for three reasons:
1. A single erase command will make all other I/O on the card
wait. This is not a problem if the whole card is being erased, but
erasing one partition will make I/O for another partition on the
same card wait for the duration of the erase - which could be a
several minutes.
2. To be able to inform the user of erase progress.
3. The erase timeout becomes too large to be very useful.
Because the erase timeout contains a margin which is multiplied by
the size of the erase area, the value can end up being several
minutes for large areas.
"erase_size" is not the most efficient unit to erase (especially for SD
where it is just one sector), hence "preferred_erase_size" provides a good
chunk size for erasing large areas.
For MMC, "preferred_erase_size" is the high-capacity erase size if a card
specifies one, otherwise it is based on the capacity of the card.
For SD, "preferred_erase_size" is the allocation unit size specified by
the card.
"preferred_erase_size" is in bytes.
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Cc: Kyungmin Park <kmpark@infradead.org>
Cc: Madhusudhan Chikkature <madhu.cr@ti.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ben Gardiner <bengardiner@nanometrics.ca>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 21:17:46 +00:00
|
|
|
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)) {
|
2011-10-11 06:14:09 +00:00
|
|
|
pr_err("error %d requesting status %#x\n",
|
mmc: add erase, secure erase, trim and secure trim operations
SD/MMC cards tend to support an erase operation. In addition, eMMC v4.4
cards can support secure erase, trim and secure trim operations that are
all variants of the basic erase command.
SD/MMC device attributes "erase_size" and "preferred_erase_size" have been
added.
"erase_size" is the minimum size, in bytes, of an erase operation. For
MMC, "erase_size" is the erase group size reported by the card. Note that
"erase_size" does not apply to trim or secure trim operations where the
minimum size is always one 512 byte sector. For SD, "erase_size" is 512
if the card is block-addressed, 0 otherwise.
SD/MMC cards can erase an arbitrarily large area up to and
including the whole card. When erasing a large area it may
be desirable to do it in smaller chunks for three reasons:
1. A single erase command will make all other I/O on the card
wait. This is not a problem if the whole card is being erased, but
erasing one partition will make I/O for another partition on the
same card wait for the duration of the erase - which could be a
several minutes.
2. To be able to inform the user of erase progress.
3. The erase timeout becomes too large to be very useful.
Because the erase timeout contains a margin which is multiplied by
the size of the erase area, the value can end up being several
minutes for large areas.
"erase_size" is not the most efficient unit to erase (especially for SD
where it is just one sector), hence "preferred_erase_size" provides a good
chunk size for erasing large areas.
For MMC, "preferred_erase_size" is the high-capacity erase size if a card
specifies one, otherwise it is based on the capacity of the card.
For SD, "preferred_erase_size" is the allocation unit size specified by
the card.
"preferred_erase_size" is in bytes.
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Cc: Kyungmin Park <kmpark@infradead.org>
Cc: Madhusudhan Chikkature <madhu.cr@ti.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ben Gardiner <bengardiner@nanometrics.ca>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 21:17:46 +00:00
|
|
|
err, cmd.resp[0]);
|
|
|
|
err = -EIO;
|
|
|
|
goto out;
|
|
|
|
}
|
2012-11-16 15:31:41 +00:00
|
|
|
|
|
|
|
/* Timeout if the device never becomes ready for data and
|
|
|
|
* never leaves the program state.
|
|
|
|
*/
|
|
|
|
if (time_after(jiffies, timeout)) {
|
|
|
|
pr_err("%s: Card stuck in programming state! %s\n",
|
|
|
|
mmc_hostname(card->host), __func__);
|
|
|
|
err = -EIO;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
mmc: add erase, secure erase, trim and secure trim operations
SD/MMC cards tend to support an erase operation. In addition, eMMC v4.4
cards can support secure erase, trim and secure trim operations that are
all variants of the basic erase command.
SD/MMC device attributes "erase_size" and "preferred_erase_size" have been
added.
"erase_size" is the minimum size, in bytes, of an erase operation. For
MMC, "erase_size" is the erase group size reported by the card. Note that
"erase_size" does not apply to trim or secure trim operations where the
minimum size is always one 512 byte sector. For SD, "erase_size" is 512
if the card is block-addressed, 0 otherwise.
SD/MMC cards can erase an arbitrarily large area up to and
including the whole card. When erasing a large area it may
be desirable to do it in smaller chunks for three reasons:
1. A single erase command will make all other I/O on the card
wait. This is not a problem if the whole card is being erased, but
erasing one partition will make I/O for another partition on the
same card wait for the duration of the erase - which could be a
several minutes.
2. To be able to inform the user of erase progress.
3. The erase timeout becomes too large to be very useful.
Because the erase timeout contains a margin which is multiplied by
the size of the erase area, the value can end up being several
minutes for large areas.
"erase_size" is not the most efficient unit to erase (especially for SD
where it is just one sector), hence "preferred_erase_size" provides a good
chunk size for erasing large areas.
For MMC, "preferred_erase_size" is the high-capacity erase size if a card
specifies one, otherwise it is based on the capacity of the card.
For SD, "preferred_erase_size" is the allocation unit size specified by
the card.
"preferred_erase_size" is in bytes.
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Cc: Kyungmin Park <kmpark@infradead.org>
Cc: Madhusudhan Chikkature <madhu.cr@ti.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ben Gardiner <bengardiner@nanometrics.ca>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 21:17:46 +00:00
|
|
|
} while (!(cmd.resp[0] & R1_READY_FOR_DATA) ||
|
2012-11-16 15:31:41 +00:00
|
|
|
(R1_CURRENT_STATE(cmd.resp[0]) == R1_STATE_PRG));
|
mmc: add erase, secure erase, trim and secure trim operations
SD/MMC cards tend to support an erase operation. In addition, eMMC v4.4
cards can support secure erase, trim and secure trim operations that are
all variants of the basic erase command.
SD/MMC device attributes "erase_size" and "preferred_erase_size" have been
added.
"erase_size" is the minimum size, in bytes, of an erase operation. For
MMC, "erase_size" is the erase group size reported by the card. Note that
"erase_size" does not apply to trim or secure trim operations where the
minimum size is always one 512 byte sector. For SD, "erase_size" is 512
if the card is block-addressed, 0 otherwise.
SD/MMC cards can erase an arbitrarily large area up to and
including the whole card. When erasing a large area it may
be desirable to do it in smaller chunks for three reasons:
1. A single erase command will make all other I/O on the card
wait. This is not a problem if the whole card is being erased, but
erasing one partition will make I/O for another partition on the
same card wait for the duration of the erase - which could be a
several minutes.
2. To be able to inform the user of erase progress.
3. The erase timeout becomes too large to be very useful.
Because the erase timeout contains a margin which is multiplied by
the size of the erase area, the value can end up being several
minutes for large areas.
"erase_size" is not the most efficient unit to erase (especially for SD
where it is just one sector), hence "preferred_erase_size" provides a good
chunk size for erasing large areas.
For MMC, "preferred_erase_size" is the high-capacity erase size if a card
specifies one, otherwise it is based on the capacity of the card.
For SD, "preferred_erase_size" is the allocation unit size specified by
the card.
"preferred_erase_size" is in bytes.
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Cc: Kyungmin Park <kmpark@infradead.org>
Cc: Madhusudhan Chikkature <madhu.cr@ti.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ben Gardiner <bengardiner@nanometrics.ca>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 21:17:46 +00:00
|
|
|
out:
|
2013-05-16 03:13:13 +00:00
|
|
|
|
|
|
|
trace_mmc_blk_erase_end(arg, fr, nr);
|
mmc: add erase, secure erase, trim and secure trim operations
SD/MMC cards tend to support an erase operation. In addition, eMMC v4.4
cards can support secure erase, trim and secure trim operations that are
all variants of the basic erase command.
SD/MMC device attributes "erase_size" and "preferred_erase_size" have been
added.
"erase_size" is the minimum size, in bytes, of an erase operation. For
MMC, "erase_size" is the erase group size reported by the card. Note that
"erase_size" does not apply to trim or secure trim operations where the
minimum size is always one 512 byte sector. For SD, "erase_size" is 512
if the card is block-addressed, 0 otherwise.
SD/MMC cards can erase an arbitrarily large area up to and
including the whole card. When erasing a large area it may
be desirable to do it in smaller chunks for three reasons:
1. A single erase command will make all other I/O on the card
wait. This is not a problem if the whole card is being erased, but
erasing one partition will make I/O for another partition on the
same card wait for the duration of the erase - which could be a
several minutes.
2. To be able to inform the user of erase progress.
3. The erase timeout becomes too large to be very useful.
Because the erase timeout contains a margin which is multiplied by
the size of the erase area, the value can end up being several
minutes for large areas.
"erase_size" is not the most efficient unit to erase (especially for SD
where it is just one sector), hence "preferred_erase_size" provides a good
chunk size for erasing large areas.
For MMC, "preferred_erase_size" is the high-capacity erase size if a card
specifies one, otherwise it is based on the capacity of the card.
For SD, "preferred_erase_size" is the allocation unit size specified by
the card.
"preferred_erase_size" is in bytes.
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Cc: Kyungmin Park <kmpark@infradead.org>
Cc: Madhusudhan Chikkature <madhu.cr@ti.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ben Gardiner <bengardiner@nanometrics.ca>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 21:17:46 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2015-04-23 04:30:27 +00:00
|
|
|
int mmc_erase_sanity_check(struct mmc_card *card, unsigned int from,
|
|
|
|
unsigned int nr, unsigned int arg)
|
mmc: add erase, secure erase, trim and secure trim operations
SD/MMC cards tend to support an erase operation. In addition, eMMC v4.4
cards can support secure erase, trim and secure trim operations that are
all variants of the basic erase command.
SD/MMC device attributes "erase_size" and "preferred_erase_size" have been
added.
"erase_size" is the minimum size, in bytes, of an erase operation. For
MMC, "erase_size" is the erase group size reported by the card. Note that
"erase_size" does not apply to trim or secure trim operations where the
minimum size is always one 512 byte sector. For SD, "erase_size" is 512
if the card is block-addressed, 0 otherwise.
SD/MMC cards can erase an arbitrarily large area up to and
including the whole card. When erasing a large area it may
be desirable to do it in smaller chunks for three reasons:
1. A single erase command will make all other I/O on the card
wait. This is not a problem if the whole card is being erased, but
erasing one partition will make I/O for another partition on the
same card wait for the duration of the erase - which could be a
several minutes.
2. To be able to inform the user of erase progress.
3. The erase timeout becomes too large to be very useful.
Because the erase timeout contains a margin which is multiplied by
the size of the erase area, the value can end up being several
minutes for large areas.
"erase_size" is not the most efficient unit to erase (especially for SD
where it is just one sector), hence "preferred_erase_size" provides a good
chunk size for erasing large areas.
For MMC, "preferred_erase_size" is the high-capacity erase size if a card
specifies one, otherwise it is based on the capacity of the card.
For SD, "preferred_erase_size" is the allocation unit size specified by
the card.
"preferred_erase_size" is in bytes.
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Cc: Kyungmin Park <kmpark@infradead.org>
Cc: Madhusudhan Chikkature <madhu.cr@ti.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ben Gardiner <bengardiner@nanometrics.ca>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 21:17:46 +00:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
2015-04-23 04:30:27 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int mmc_cmdq_erase(struct mmc_cmdq_req *cmdq_req,
|
|
|
|
struct mmc_card *card, unsigned int from, unsigned int nr,
|
|
|
|
unsigned int arg)
|
|
|
|
{
|
|
|
|
unsigned int rem, to = from + nr;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = mmc_erase_sanity_check(card, from, nr, arg);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
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_cmdq_do_erase(cmdq_req, card, from, to, arg);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mmc_cmdq_erase);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = mmc_erase_sanity_check(card, from, nr, arg);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
mmc: add erase, secure erase, trim and secure trim operations
SD/MMC cards tend to support an erase operation. In addition, eMMC v4.4
cards can support secure erase, trim and secure trim operations that are
all variants of the basic erase command.
SD/MMC device attributes "erase_size" and "preferred_erase_size" have been
added.
"erase_size" is the minimum size, in bytes, of an erase operation. For
MMC, "erase_size" is the erase group size reported by the card. Note that
"erase_size" does not apply to trim or secure trim operations where the
minimum size is always one 512 byte sector. For SD, "erase_size" is 512
if the card is block-addressed, 0 otherwise.
SD/MMC cards can erase an arbitrarily large area up to and
including the whole card. When erasing a large area it may
be desirable to do it in smaller chunks for three reasons:
1. A single erase command will make all other I/O on the card
wait. This is not a problem if the whole card is being erased, but
erasing one partition will make I/O for another partition on the
same card wait for the duration of the erase - which could be a
several minutes.
2. To be able to inform the user of erase progress.
3. The erase timeout becomes too large to be very useful.
Because the erase timeout contains a margin which is multiplied by
the size of the erase area, the value can end up being several
minutes for large areas.
"erase_size" is not the most efficient unit to erase (especially for SD
where it is just one sector), hence "preferred_erase_size" provides a good
chunk size for erasing large areas.
For MMC, "preferred_erase_size" is the high-capacity erase size if a card
specifies one, otherwise it is based on the capacity of the card.
For SD, "preferred_erase_size" is the allocation unit size specified by
the card.
"preferred_erase_size" is in bytes.
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Cc: Kyungmin Park <kmpark@infradead.org>
Cc: Madhusudhan Chikkature <madhu.cr@ti.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ben Gardiner <bengardiner@nanometrics.ca>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 21:17:46 +00:00
|
|
|
|
|
|
|
if (arg == MMC_ERASE_ARG) {
|
|
|
|
rem = from % card->erase_size;
|
|
|
|
if (rem) {
|
|
|
|
rem = card->erase_size - rem;
|
|
|
|
from += rem;
|
|
|
|
if (nr > rem)
|
|
|
|
nr -= rem;
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
rem = nr % card->erase_size;
|
|
|
|
if (rem)
|
|
|
|
nr -= rem;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (nr == 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
to = from + nr;
|
|
|
|
|
|
|
|
if (to <= from)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/* 'from' and 'to' are inclusive */
|
|
|
|
to -= 1;
|
|
|
|
|
|
|
|
return mmc_do_erase(card, from, to, arg);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mmc_erase);
|
|
|
|
|
|
|
|
int mmc_can_erase(struct mmc_card *card)
|
|
|
|
{
|
|
|
|
if ((card->host->caps & MMC_CAP_ERASE) &&
|
|
|
|
(card->csd.cmdclass & CCC_ERASE) && card->erase_size)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mmc_can_erase);
|
|
|
|
|
|
|
|
int mmc_can_trim(struct mmc_card *card)
|
|
|
|
{
|
|
|
|
if (card->ext_csd.sec_feature_support & EXT_CSD_SEC_GB_CL_EN)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mmc_can_trim);
|
|
|
|
|
2011-10-18 00:34:04 +00:00
|
|
|
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);
|
|
|
|
|
2011-10-14 05:15:48 +00:00
|
|
|
int mmc_can_sanitize(struct mmc_card *card)
|
|
|
|
{
|
2012-04-05 11:45:48 +00:00
|
|
|
if (!mmc_can_trim(card) && !mmc_can_erase(card))
|
|
|
|
return 0;
|
2017-04-18 01:29:57 +00:00
|
|
|
if ((card->ext_csd.sec_feature_support & EXT_CSD_SEC_SANITIZE)
|
|
|
|
&& (card->host->caps2 & MMC_CAP2_SANITIZE))
|
2011-10-14 05:15:48 +00:00
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mmc_can_sanitize);
|
|
|
|
|
mmc: add erase, secure erase, trim and secure trim operations
SD/MMC cards tend to support an erase operation. In addition, eMMC v4.4
cards can support secure erase, trim and secure trim operations that are
all variants of the basic erase command.
SD/MMC device attributes "erase_size" and "preferred_erase_size" have been
added.
"erase_size" is the minimum size, in bytes, of an erase operation. For
MMC, "erase_size" is the erase group size reported by the card. Note that
"erase_size" does not apply to trim or secure trim operations where the
minimum size is always one 512 byte sector. For SD, "erase_size" is 512
if the card is block-addressed, 0 otherwise.
SD/MMC cards can erase an arbitrarily large area up to and
including the whole card. When erasing a large area it may
be desirable to do it in smaller chunks for three reasons:
1. A single erase command will make all other I/O on the card
wait. This is not a problem if the whole card is being erased, but
erasing one partition will make I/O for another partition on the
same card wait for the duration of the erase - which could be a
several minutes.
2. To be able to inform the user of erase progress.
3. The erase timeout becomes too large to be very useful.
Because the erase timeout contains a margin which is multiplied by
the size of the erase area, the value can end up being several
minutes for large areas.
"erase_size" is not the most efficient unit to erase (especially for SD
where it is just one sector), hence "preferred_erase_size" provides a good
chunk size for erasing large areas.
For MMC, "preferred_erase_size" is the high-capacity erase size if a card
specifies one, otherwise it is based on the capacity of the card.
For SD, "preferred_erase_size" is the allocation unit size specified by
the card.
"preferred_erase_size" is in bytes.
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Cc: Kyungmin Park <kmpark@infradead.org>
Cc: Madhusudhan Chikkature <madhu.cr@ti.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ben Gardiner <bengardiner@nanometrics.ca>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 21:17:46 +00:00
|
|
|
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);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-06-28 14:16:02 +00:00
|
|
|
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);
|
|
|
|
|
2010-08-24 10:20:26 +00:00
|
|
|
int mmc_set_blocklen(struct mmc_card *card, unsigned int blocklen)
|
|
|
|
{
|
2011-04-14 03:40:30 +00:00
|
|
|
struct mmc_command cmd = {0};
|
2010-08-24 10:20:26 +00:00
|
|
|
|
|
|
|
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);
|
|
|
|
|
2012-08-06 15:12:30 +00:00
|
|
|
int mmc_set_blockcount(struct mmc_card *card, unsigned int blockcount,
|
|
|
|
bool is_rel_write)
|
|
|
|
{
|
|
|
|
struct mmc_command cmd = {0};
|
|
|
|
|
|
|
|
cmd.opcode = MMC_SET_BLOCK_COUNT;
|
|
|
|
cmd.arg = blockcount & 0x0000FFFF;
|
|
|
|
if (is_rel_write)
|
|
|
|
cmd.arg |= 1 << 31;
|
|
|
|
cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;
|
|
|
|
return mmc_wait_for_cmd(card->host, &cmd, 5);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mmc_set_blockcount);
|
|
|
|
|
2011-08-29 13:42:11 +00:00
|
|
|
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;
|
|
|
|
|
2012-07-16 10:45:03 +00:00
|
|
|
if (mmc_card_sdio(card))
|
2011-08-29 13:42:11 +00:00
|
|
|
return 0;
|
2012-07-16 10:45:03 +00:00
|
|
|
|
2013-06-12 12:27:07 +00:00
|
|
|
if (mmc_card_mmc(card) && (card->host->caps & MMC_CAP_HW_RESET)) {
|
2012-07-16 10:45:03 +00:00
|
|
|
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;
|
|
|
|
}
|
2011-08-29 13:42:11 +00:00
|
|
|
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;
|
2015-09-28 10:25:01 +00:00
|
|
|
int ret;
|
2011-08-29 13:42:11 +00:00
|
|
|
|
|
|
|
if (!host->bus_ops->power_restore)
|
|
|
|
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);
|
|
|
|
|
2013-06-12 12:27:07 +00:00
|
|
|
if (mmc_card_mmc(card) && host->ops->hw_reset)
|
2013-02-12 07:51:13 +00:00
|
|
|
host->ops->hw_reset(host);
|
2013-06-12 12:27:07 +00:00
|
|
|
else
|
|
|
|
mmc_power_cycle(host);
|
2011-08-29 13:42:11 +00:00
|
|
|
|
|
|
|
/* 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);
|
2015-09-28 10:25:01 +00:00
|
|
|
mmc_claim_host(host);
|
|
|
|
ret = host->bus_ops->power_restore(host);
|
|
|
|
mmc_release_host(host);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* mmc_cmdq_hw_reset: Helper API for doing
|
|
|
|
* reset_all of host and reinitializing card.
|
|
|
|
* This must be called with mmc_claim_host
|
|
|
|
* acquired by the caller.
|
|
|
|
*/
|
|
|
|
int mmc_cmdq_hw_reset(struct mmc_host *host)
|
|
|
|
{
|
|
|
|
if (!host->bus_ops->power_restore)
|
|
|
|
return -EOPNOTSUPP;
|
2011-08-29 13:42:11 +00:00
|
|
|
|
2015-09-28 10:25:01 +00:00
|
|
|
mmc_power_cycle(host);
|
|
|
|
mmc_select_voltage(host, host->ocr);
|
2011-08-29 13:42:11 +00:00
|
|
|
return host->bus_ops->power_restore(host);
|
|
|
|
}
|
2015-09-28 10:25:01 +00:00
|
|
|
EXPORT_SYMBOL(mmc_cmdq_hw_reset);
|
2011-08-29 13:42:11 +00:00
|
|
|
|
|
|
|
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);
|
|
|
|
|
2012-10-11 11:47:03 +00:00
|
|
|
/**
|
|
|
|
* mmc_reset_clk_scale_stats() - reset clock scaling statistics
|
|
|
|
* @host: pointer to mmc host structure
|
|
|
|
*/
|
|
|
|
void mmc_reset_clk_scale_stats(struct mmc_host *host)
|
|
|
|
{
|
2015-06-01 18:11:22 +00:00
|
|
|
if (!host->clk_scaling.enable)
|
|
|
|
return;
|
|
|
|
|
2012-10-11 11:47:03 +00:00
|
|
|
host->clk_scaling.busy_time_us = 0;
|
|
|
|
host->clk_scaling.window_time = jiffies;
|
2015-06-01 14:23:42 +00:00
|
|
|
host->clk_scaling.cq_is_busy_started = false;
|
2012-10-11 11:47:03 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(mmc_reset_clk_scale_stats);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* mmc_get_max_frequency() - get max. frequency supported
|
|
|
|
* @host: pointer to mmc host structure
|
|
|
|
*
|
|
|
|
* Returns max. frequency supported by card/host. If the
|
|
|
|
* timing mode is SDR50/SDR104/HS200/DDR50 return appropriate
|
|
|
|
* max. frequency in these modes else, use the current frequency.
|
|
|
|
* Also, allow host drivers to overwrite the frequency in case
|
|
|
|
* they support "get_max_frequency" host ops.
|
|
|
|
*/
|
|
|
|
unsigned long mmc_get_max_frequency(struct mmc_host *host)
|
|
|
|
{
|
|
|
|
unsigned long freq;
|
2013-10-01 10:33:16 +00:00
|
|
|
unsigned char timing;
|
2012-10-11 11:47:03 +00:00
|
|
|
|
|
|
|
if (host->ops && host->ops->get_max_frequency) {
|
|
|
|
freq = host->ops->get_max_frequency(host);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2013-10-01 10:33:16 +00:00
|
|
|
if (mmc_card_hs400(host->card))
|
|
|
|
timing = MMC_TIMING_MMC_HS400;
|
|
|
|
else
|
|
|
|
timing = host->ios.timing;
|
|
|
|
|
|
|
|
switch (timing) {
|
2012-10-11 11:47:03 +00:00
|
|
|
case MMC_TIMING_UHS_SDR50:
|
|
|
|
freq = UHS_SDR50_MAX_DTR;
|
|
|
|
break;
|
|
|
|
case MMC_TIMING_UHS_SDR104:
|
|
|
|
freq = UHS_SDR104_MAX_DTR;
|
|
|
|
break;
|
|
|
|
case MMC_TIMING_MMC_HS200:
|
|
|
|
freq = MMC_HS200_MAX_DTR;
|
|
|
|
break;
|
|
|
|
case MMC_TIMING_UHS_DDR50:
|
|
|
|
freq = UHS_DDR50_MAX_DTR;
|
|
|
|
break;
|
2013-10-01 10:33:16 +00:00
|
|
|
case MMC_TIMING_MMC_HS400:
|
|
|
|
freq = MMC_HS400_MAX_DTR;
|
|
|
|
break;
|
2012-10-11 11:47:03 +00:00
|
|
|
default:
|
|
|
|
mmc_host_clk_hold(host);
|
|
|
|
freq = host->ios.clock;
|
|
|
|
mmc_host_clk_release(host);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
return freq;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(mmc_get_max_frequency);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* mmc_get_min_frequency() - get min. frequency supported
|
|
|
|
* @host: pointer to mmc host structure
|
|
|
|
*
|
|
|
|
* Returns min. frequency supported by card/host which doesn't impair
|
|
|
|
* performance for most usecases. If the timing mode is SDR50/SDR104/HS200
|
|
|
|
* return 50MHz value. If timing mode is DDR50 return 25MHz so that
|
|
|
|
* throughput would be equivalent to SDR50/SDR104 in 50MHz. Also, allow
|
|
|
|
* host drivers to overwrite the frequency in case they support
|
|
|
|
* "get_min_frequency" host ops.
|
|
|
|
*/
|
|
|
|
static unsigned long mmc_get_min_frequency(struct mmc_host *host)
|
|
|
|
{
|
|
|
|
unsigned long freq;
|
|
|
|
|
|
|
|
if (host->ops && host->ops->get_min_frequency) {
|
|
|
|
freq = host->ops->get_min_frequency(host);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (host->ios.timing) {
|
|
|
|
case MMC_TIMING_UHS_SDR50:
|
|
|
|
case MMC_TIMING_UHS_SDR104:
|
|
|
|
freq = UHS_SDR25_MAX_DTR;
|
|
|
|
break;
|
|
|
|
case MMC_TIMING_MMC_HS200:
|
|
|
|
freq = MMC_HIGH_52_MAX_DTR;
|
|
|
|
break;
|
2013-10-01 10:33:16 +00:00
|
|
|
case MMC_TIMING_MMC_HS400:
|
|
|
|
freq = MMC_HIGH_52_MAX_DTR;
|
|
|
|
break;
|
2012-10-11 11:47:03 +00:00
|
|
|
case MMC_TIMING_UHS_DDR50:
|
|
|
|
freq = UHS_DDR50_MAX_DTR / 2;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
mmc_host_clk_hold(host);
|
|
|
|
freq = host->ios.clock;
|
|
|
|
mmc_host_clk_release(host);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
return freq;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Scale down clocks to minimum frequency supported.
|
|
|
|
* The delayed work re-arms itself in case it cannot
|
|
|
|
* claim the host.
|
|
|
|
*/
|
|
|
|
static void mmc_clk_scale_work(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct mmc_host *host = container_of(work, struct mmc_host,
|
|
|
|
clk_scaling.work.work);
|
|
|
|
|
|
|
|
if (!host->card || !host->bus_ops ||
|
|
|
|
!host->bus_ops->change_bus_speed ||
|
|
|
|
!host->clk_scaling.enable || !host->ios.clock)
|
2013-02-11 10:01:35 +00:00
|
|
|
return;
|
2012-10-11 11:47:03 +00:00
|
|
|
|
2013-02-11 10:01:35 +00:00
|
|
|
mmc_rpm_hold(host, &host->card->dev);
|
2012-10-11 11:47:03 +00:00
|
|
|
if (!mmc_try_claim_host(host)) {
|
|
|
|
/* retry after a timer tick */
|
|
|
|
queue_delayed_work(system_nrt_wq, &host->clk_scaling.work, 1);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
mmc_clk_scaling(host, true);
|
|
|
|
mmc_release_host(host);
|
|
|
|
out:
|
2013-02-11 10:01:35 +00:00
|
|
|
mmc_rpm_release(host, &host->card->dev);
|
2012-10-11 11:47:03 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-03-20 09:20:47 +00:00
|
|
|
static bool mmc_is_vaild_state_for_clk_scaling(struct mmc_host *host,
|
|
|
|
enum mmc_load state)
|
2013-02-01 11:44:33 +00:00
|
|
|
{
|
|
|
|
struct mmc_card *card = host->card;
|
|
|
|
u32 status;
|
|
|
|
bool ret = false;
|
|
|
|
|
mmc: core: Bypass clock scaling while accessing RPMB partition
According to eMMC specification, only commands of classes 0, 2, 4
are admitted while accessing RPMB partition. Still usage of any
other command other than CMD0, CMD6, CMD8, CMD12, CMD13, CMD15,
CMD18, CMD23, CMD25 is illegal.
If the MMC clock scaling algorithm decides to switch the clocks
while accessing RPMB partition it might need to send tuning
command (CMD21) which is illegal.
Since RPMB accesses are short and doesn't depend on throughput
bypass clock scaling while the current partion mode is RPMB.
The clock scaling statistics still take into account the duration
of access and hence able to respond quickly on the transfers made
after partition switch.
Change-Id: I422f2e6acb33ab97105944e3f7f90c3afb37ef47
Signed-off-by: Sujit Reddy Thumma <sthumma@codeaurora.org>
2013-04-02 11:11:04 +00:00
|
|
|
/*
|
|
|
|
* If the current partition type is RPMB, clock switching may not
|
|
|
|
* work properly as sending tuning command (CMD21) is illegal in
|
|
|
|
* this mode.
|
|
|
|
*/
|
|
|
|
if (!card || (mmc_card_mmc(card) &&
|
2014-04-21 07:26:21 +00:00
|
|
|
card->part_curr == EXT_CSD_PART_CONFIG_ACC_RPMB)
|
2015-03-20 09:20:47 +00:00
|
|
|
|| (state != MMC_LOAD_LOW &&
|
|
|
|
host->clk_scaling.invalid_state))
|
2013-02-01 11:44:33 +00:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (mmc_send_status(card, &status)) {
|
|
|
|
pr_err("%s: Get card status fail\n", mmc_hostname(card->host));
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (R1_CURRENT_STATE(status)) {
|
|
|
|
case R1_STATE_TRAN:
|
|
|
|
ret = true;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
2012-10-11 11:47:03 +00:00
|
|
|
|
2013-04-25 07:09:40 +00:00
|
|
|
static int mmc_clk_update_freq(struct mmc_host *host,
|
|
|
|
unsigned long freq, enum mmc_load state)
|
|
|
|
{
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
if (host->ops->notify_load) {
|
|
|
|
err = host->ops->notify_load(host, state);
|
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (freq != host->clk_scaling.curr_freq) {
|
2015-03-20 09:20:47 +00:00
|
|
|
if (!mmc_is_vaild_state_for_clk_scaling(host, state)) {
|
2013-04-25 07:09:40 +00:00
|
|
|
err = -EAGAIN;
|
2015-06-01 14:23:42 +00:00
|
|
|
pr_debug("%s: %s: invalid state_for_clk_scaling\n",
|
|
|
|
mmc_hostname(host), __func__);
|
2013-04-25 07:09:40 +00:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = host->bus_ops->change_bus_speed(host, &freq);
|
|
|
|
if (!err)
|
|
|
|
host->clk_scaling.curr_freq = freq;
|
|
|
|
else
|
|
|
|
pr_err("%s: %s: failed (%d) at freq=%lu\n",
|
|
|
|
mmc_hostname(host), __func__, err, freq);
|
|
|
|
}
|
|
|
|
error:
|
|
|
|
if (err) {
|
|
|
|
/* restore previous state */
|
|
|
|
if (host->ops->notify_load)
|
|
|
|
host->ops->notify_load(host, host->clk_scaling.state);
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2015-06-19 15:07:56 +00:00
|
|
|
int mmc_cmdq_halt_on_empty_queue(struct mmc_host *host)
|
2015-06-01 14:23:42 +00:00
|
|
|
{
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
while (host->cmdq_ctx.active_reqs) {
|
|
|
|
err = wait_io_event_interruptible(host->cmdq_ctx.queue_empty_wq,
|
|
|
|
(!host->cmdq_ctx.active_reqs));
|
|
|
|
if (host->cmdq_ctx.active_reqs)
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = mmc_cmdq_halt(host, true);
|
|
|
|
if (err) {
|
|
|
|
pr_err("%s: %s: mmc_cmdq_halt failed (%d)\n",
|
|
|
|
mmc_hostname(host), __func__, err);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
return err;
|
|
|
|
}
|
2015-06-19 15:07:56 +00:00
|
|
|
EXPORT_SYMBOL(mmc_cmdq_halt_on_empty_queue);
|
2015-06-01 14:23:42 +00:00
|
|
|
|
2012-10-11 11:47:03 +00:00
|
|
|
/**
|
|
|
|
* mmc_clk_scaling() - clock scaling decision algorithm
|
|
|
|
* @host: pointer to mmc host structure
|
|
|
|
* @from_wq: variable that specifies the context in which
|
|
|
|
* mmc_clk_scaling() is called.
|
|
|
|
*
|
|
|
|
* Calculate load percentage based on host busy time
|
|
|
|
* and total sampling interval and decide clock scaling
|
|
|
|
* based on scale up/down thresholds.
|
|
|
|
* If load is greater than up threshold increase the
|
|
|
|
* frequency to maximum as supported by host. Else,
|
|
|
|
* if load is less than down threshold, scale down the
|
|
|
|
* frequency to minimum supported by the host. Otherwise,
|
|
|
|
* retain current frequency and do nothing.
|
|
|
|
*/
|
2015-06-01 14:23:42 +00:00
|
|
|
void mmc_clk_scaling(struct mmc_host *host, bool from_wq)
|
2012-10-11 11:47:03 +00:00
|
|
|
{
|
|
|
|
int err = 0;
|
2017-04-18 01:29:57 +00:00
|
|
|
struct mmc_card *card;
|
2012-10-11 11:47:03 +00:00
|
|
|
unsigned long total_time_ms = 0;
|
|
|
|
unsigned long busy_time_ms = 0;
|
|
|
|
unsigned long freq;
|
2017-04-18 01:29:57 +00:00
|
|
|
unsigned int up_threshold;
|
|
|
|
unsigned int down_threshold;
|
2012-10-11 11:47:03 +00:00
|
|
|
bool queue_scale_down_work = false;
|
2013-04-25 07:09:40 +00:00
|
|
|
enum mmc_load state;
|
2015-06-01 14:23:42 +00:00
|
|
|
bool cmdq_mode;
|
2012-10-11 11:47:03 +00:00
|
|
|
|
2015-06-01 14:23:42 +00:00
|
|
|
if (!host) {
|
|
|
|
pr_err("%s: invalid host\n", __func__);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
card = host->card;
|
2017-04-18 01:29:57 +00:00
|
|
|
up_threshold = host->clk_scaling.up_threshold;
|
|
|
|
down_threshold = host->clk_scaling.down_threshold;
|
|
|
|
|
2012-10-11 11:47:03 +00:00
|
|
|
if (!card || !host->bus_ops || !host->bus_ops->change_bus_speed) {
|
|
|
|
pr_err("%s: %s: invalid entry\n", mmc_hostname(host), __func__);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2015-06-01 14:23:42 +00:00
|
|
|
cmdq_mode = !!mmc_card_cmdq(card);
|
|
|
|
|
2012-10-11 11:47:03 +00:00
|
|
|
/* Check if the clocks are already gated. */
|
|
|
|
if (!host->ios.clock)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (time_is_after_jiffies(host->clk_scaling.window_time +
|
|
|
|
msecs_to_jiffies(host->clk_scaling.polling_delay_ms)))
|
|
|
|
goto out;
|
|
|
|
|
2015-06-01 14:23:42 +00:00
|
|
|
if (cmdq_mode)
|
|
|
|
spin_lock_bh(&host->clk_scaling.lock);
|
|
|
|
if (host->clk_scaling.busy_time_us == 0) {
|
|
|
|
if (cmdq_mode)
|
|
|
|
spin_unlock_bh(&host->clk_scaling.lock);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2012-10-11 11:47:03 +00:00
|
|
|
/* handle time wrap */
|
|
|
|
total_time_ms = jiffies_to_msecs((long)jiffies -
|
|
|
|
(long)host->clk_scaling.window_time);
|
|
|
|
|
|
|
|
/* Check if we re-enter during clock switching */
|
2015-06-01 14:23:42 +00:00
|
|
|
if (unlikely(host->clk_scaling.in_progress)) {
|
|
|
|
if (cmdq_mode)
|
|
|
|
spin_unlock_bh(&host->clk_scaling.lock);
|
2012-10-11 11:47:03 +00:00
|
|
|
goto out;
|
2015-06-01 14:23:42 +00:00
|
|
|
}
|
2012-10-11 11:47:03 +00:00
|
|
|
|
|
|
|
host->clk_scaling.in_progress = true;
|
|
|
|
|
|
|
|
busy_time_ms = host->clk_scaling.busy_time_us / USEC_PER_MSEC;
|
|
|
|
|
2015-06-01 14:23:42 +00:00
|
|
|
if (cmdq_mode)
|
|
|
|
spin_unlock_bh(&host->clk_scaling.lock);
|
|
|
|
|
2012-10-11 11:47:03 +00:00
|
|
|
freq = host->clk_scaling.curr_freq;
|
2013-04-25 07:09:40 +00:00
|
|
|
state = host->clk_scaling.state;
|
2012-10-11 11:47:03 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Note that the max. and min. frequency should be based
|
|
|
|
* on the timing modes that the card and host handshake
|
|
|
|
* during initialization.
|
|
|
|
*/
|
|
|
|
if ((busy_time_ms * 100 > total_time_ms * up_threshold)) {
|
|
|
|
freq = mmc_get_max_frequency(host);
|
2013-04-25 07:09:40 +00:00
|
|
|
state = MMC_LOAD_HIGH;
|
2012-10-11 11:47:03 +00:00
|
|
|
} else if ((busy_time_ms * 100 < total_time_ms * down_threshold)) {
|
2015-06-01 14:23:42 +00:00
|
|
|
if (!from_wq && !cmdq_mode)
|
2012-10-11 11:47:03 +00:00
|
|
|
queue_scale_down_work = true;
|
|
|
|
freq = mmc_get_min_frequency(host);
|
2013-04-25 07:09:40 +00:00
|
|
|
state = MMC_LOAD_LOW;
|
2012-10-11 11:47:03 +00:00
|
|
|
}
|
|
|
|
|
2013-04-25 07:09:40 +00:00
|
|
|
if (state != host->clk_scaling.state) {
|
2012-10-11 11:47:03 +00:00
|
|
|
if (!queue_scale_down_work) {
|
|
|
|
if (!from_wq)
|
|
|
|
cancel_delayed_work_sync(
|
|
|
|
&host->clk_scaling.work);
|
2015-06-01 14:23:42 +00:00
|
|
|
|
|
|
|
if (cmdq_mode) {
|
|
|
|
err = mmc_cmdq_halt_on_empty_queue(host);
|
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
pr_debug("%s: %s: scale, freq %ld, busy_time_ms=%ld\n",
|
|
|
|
mmc_hostname(host), __func__, freq,
|
|
|
|
busy_time_ms);
|
2013-04-25 07:09:40 +00:00
|
|
|
err = mmc_clk_update_freq(host, freq, state);
|
2015-06-01 14:23:42 +00:00
|
|
|
|
|
|
|
if (cmdq_mode) {
|
|
|
|
if (mmc_cmdq_halt(host, false))
|
|
|
|
pr_err("%s: %s: cmdq unhalt failed\n",
|
|
|
|
mmc_hostname(host), __func__);
|
|
|
|
}
|
2012-10-11 11:47:03 +00:00
|
|
|
if (!err)
|
2013-04-25 07:09:40 +00:00
|
|
|
host->clk_scaling.state = state;
|
|
|
|
else if (err == -EAGAIN)
|
|
|
|
goto no_reset_stats;
|
2012-10-11 11:47:03 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* We hold claim host while queueing the scale down
|
|
|
|
* work, so delay atleast one timer tick to release
|
|
|
|
* host and re-claim while scaling down the clocks.
|
|
|
|
*/
|
|
|
|
queue_delayed_work(system_nrt_wq,
|
|
|
|
&host->clk_scaling.work, 1);
|
2013-04-25 07:09:40 +00:00
|
|
|
goto no_reset_stats;
|
2012-10-11 11:47:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
mmc_reset_clk_scale_stats(host);
|
2013-04-25 07:09:40 +00:00
|
|
|
no_reset_stats:
|
2012-10-11 11:47:03 +00:00
|
|
|
host->clk_scaling.in_progress = false;
|
|
|
|
out:
|
|
|
|
return;
|
|
|
|
}
|
2015-06-01 14:23:42 +00:00
|
|
|
EXPORT_SYMBOL(mmc_clk_scaling);
|
2012-10-11 11:47:03 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* mmc_disable_clk_scaling() - Disable clock scaling
|
|
|
|
* @host: pointer to mmc host structure
|
|
|
|
*
|
|
|
|
* Disables clock scaling temporarily by setting enable
|
|
|
|
* property to false. To disable completely, one also
|
|
|
|
* need to set 'initialized' variable to false.
|
|
|
|
*/
|
|
|
|
void mmc_disable_clk_scaling(struct mmc_host *host)
|
|
|
|
{
|
2015-06-03 09:04:35 +00:00
|
|
|
if (host->clk_scaling.enable &&
|
|
|
|
host->card && !mmc_card_cmdq(host->card))
|
|
|
|
cancel_delayed_work_sync(&host->clk_scaling.work);
|
|
|
|
|
2014-11-18 10:10:54 +00:00
|
|
|
if (host->ops->notify_load)
|
|
|
|
host->ops->notify_load(host, MMC_LOAD_LOW);
|
2012-10-11 11:47:03 +00:00
|
|
|
host->clk_scaling.enable = false;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(mmc_disable_clk_scaling);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* mmc_can_scale_clk() - Check if clock scaling is initialized
|
|
|
|
* @host: pointer to mmc host structure
|
|
|
|
*/
|
|
|
|
bool mmc_can_scale_clk(struct mmc_host *host)
|
|
|
|
{
|
|
|
|
return host->clk_scaling.initialized;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(mmc_can_scale_clk);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* mmc_init_clk_scaling() - Initialize clock scaling
|
|
|
|
* @host: pointer to mmc host structure
|
|
|
|
*
|
|
|
|
* Initialize clock scaling for supported hosts.
|
|
|
|
* It is assumed that the caller ensure clock is
|
|
|
|
* running at maximum possible frequency before
|
|
|
|
* calling this function.
|
|
|
|
*/
|
|
|
|
void mmc_init_clk_scaling(struct mmc_host *host)
|
|
|
|
{
|
|
|
|
if (!host->card || !(host->caps2 & MMC_CAP2_CLK_SCALE))
|
|
|
|
return;
|
|
|
|
|
|
|
|
INIT_DELAYED_WORK(&host->clk_scaling.work, mmc_clk_scale_work);
|
|
|
|
host->clk_scaling.curr_freq = mmc_get_max_frequency(host);
|
2013-04-25 07:09:40 +00:00
|
|
|
if (host->ops->notify_load)
|
2014-11-18 10:10:54 +00:00
|
|
|
host->ops->notify_load(host, MMC_LOAD_INIT);
|
|
|
|
host->clk_scaling.state = MMC_LOAD_INIT;
|
2012-10-11 11:47:03 +00:00
|
|
|
mmc_reset_clk_scale_stats(host);
|
|
|
|
host->clk_scaling.enable = true;
|
|
|
|
host->clk_scaling.initialized = true;
|
2015-06-01 14:23:42 +00:00
|
|
|
spin_lock_init(&host->clk_scaling.lock);
|
2012-10-11 11:47:03 +00:00
|
|
|
pr_debug("%s: clk scaling enabled\n", mmc_hostname(host));
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(mmc_init_clk_scaling);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* mmc_exit_clk_scaling() - Disable clock scaling
|
|
|
|
* @host: pointer to mmc host structure
|
|
|
|
*
|
|
|
|
* Disable clock scaling permanently.
|
|
|
|
*/
|
|
|
|
void mmc_exit_clk_scaling(struct mmc_host *host)
|
|
|
|
{
|
|
|
|
cancel_delayed_work_sync(&host->clk_scaling.work);
|
2014-11-18 10:10:54 +00:00
|
|
|
if (host->ops->notify_load)
|
|
|
|
host->ops->notify_load(host, MMC_LOAD_LOW);
|
2012-10-11 11:47:03 +00:00
|
|
|
memset(&host->clk_scaling, 0, sizeof(host->clk_scaling));
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(mmc_exit_clk_scaling);
|
|
|
|
|
2011-01-03 18:36:56 +00:00
|
|
|
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);
|
2011-02-14 07:12:28 +00:00
|
|
|
|
2011-08-29 13:42:11 +00:00
|
|
|
/*
|
|
|
|
* 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);
|
|
|
|
|
2011-02-14 07:12:28 +00:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2011-01-03 18:36:56 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2011-11-28 14:22:00 +00:00
|
|
|
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);
|
2013-02-28 07:29:29 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Card detect status and alive check may be out of sync if card is
|
|
|
|
* removed slowly, when card detect switch changes while card/slot
|
|
|
|
* pads are still contacted in hardware (refer to "SD Card Mechanical
|
|
|
|
* Addendum, Appendix C: Card Detection Switch"). So reschedule a
|
|
|
|
* detect work 200ms later for this case.
|
|
|
|
*/
|
|
|
|
if (!ret && host->ops->get_cd && !host->ops->get_cd(host)) {
|
|
|
|
mmc_detect_change(host, msecs_to_jiffies(200));
|
|
|
|
pr_debug("%s: card removed too slowly\n", mmc_hostname(host));
|
|
|
|
}
|
|
|
|
|
2011-11-28 14:22:00 +00:00
|
|
|
if (ret) {
|
|
|
|
mmc_card_set_removed(host->card);
|
|
|
|
pr_debug("%s: card remove detected\n", mmc_hostname(host));
|
2017-04-18 01:29:57 +00:00
|
|
|
ST_LOG("<%s> %s: card remove detected\n", __func__,mmc_hostname(host));
|
2011-11-28 14:22:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int mmc_detect_card_removed(struct mmc_host *host)
|
|
|
|
{
|
|
|
|
struct mmc_card *card = host->card;
|
2012-02-06 09:42:39 +00:00
|
|
|
int ret;
|
2011-11-28 14:22:00 +00:00
|
|
|
|
|
|
|
WARN_ON(!host->claimed);
|
2012-02-06 09:42:39 +00:00
|
|
|
|
|
|
|
if (!card)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
ret = mmc_card_removed(card);
|
2011-11-28 14:22:00 +00:00
|
|
|
/*
|
|
|
|
* The card will be considered unchanged unless we have been asked to
|
|
|
|
* detect a change or host requires polling to provide card detection.
|
|
|
|
*/
|
2012-02-06 09:42:39 +00:00
|
|
|
if (!host->detect_change && !(host->caps & MMC_CAP_NEEDS_POLL) &&
|
|
|
|
!(host->caps2 & MMC_CAP2_DETECT_ON_ERR))
|
|
|
|
return ret;
|
2011-11-28 14:22:00 +00:00
|
|
|
|
|
|
|
host->detect_change = 0;
|
2012-02-06 09:42:39 +00:00
|
|
|
if (!ret) {
|
|
|
|
ret = _mmc_detect_card_removed(host);
|
|
|
|
if (ret && (host->caps2 & MMC_CAP2_DETECT_ON_ERR)) {
|
|
|
|
/*
|
|
|
|
* Schedule a detect work as soon as possible to let a
|
|
|
|
* rescan handle the card removal.
|
|
|
|
*/
|
|
|
|
cancel_delayed_work(&host->detect);
|
|
|
|
mmc_detect_change(host, 0);
|
|
|
|
}
|
|
|
|
}
|
2011-11-28 14:22:00 +00:00
|
|
|
|
2012-02-06 09:42:39 +00:00
|
|
|
return ret;
|
2011-11-28 14:22:00 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mmc_detect_card_removed);
|
|
|
|
|
2007-05-19 12:06:24 +00:00
|
|
|
void mmc_rescan(struct work_struct *work)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-11-22 14:57:56 +00:00
|
|
|
struct mmc_host *host =
|
|
|
|
container_of(work, struct mmc_host, detect.work);
|
2009-03-23 19:20:37 +00:00
|
|
|
bool extend_wakelock = false;
|
mmc: fix all hangs related to mmc/sd card insert/removal during suspend/resume
If you don't use CONFIG_MMC_UNSAFE_RESUME, as soon as you attempt to
suspend, the card will be removed, therefore this patch doesn't change the
behavior of this option.
However the removal will be done by pm notifier, which runs while
userspace is still not frozen and thus can freely use del_gendisk, without
the risk of deadlock which would happen otherwise.
Card detect workqueue is now disabled while userspace is frozen, Therefore
if you do use CONFIG_MMC_UNSAFE_RESUME, and remove the card during
suspend, the removal will be detected as soon as userspace is unfrozen,
again at the moment it is safe to call del_gendisk.
Tested with and without CONFIG_MMC_UNSAFE_RESUME with suspend and hibernate.
[akpm@linux-foundation.org: clean up function prototype]
[akpm@linux-foundation.org: fix CONFIG_PM-n linkage, small cleanups]
[akpm@linux-foundation.org: coding-style fixes]
Signed-off-by: Maxim Levitsky <maximlevitsky@gmail.com>
Cc: David Brownell <david-b@pacbell.net>
Cc: Alan Stern <stern@rowland.harvard.edu>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 01:01:41 +00:00
|
|
|
|
2011-01-03 18:36:56 +00:00
|
|
|
if (host->rescan_disable)
|
mmc: fix all hangs related to mmc/sd card insert/removal during suspend/resume
If you don't use CONFIG_MMC_UNSAFE_RESUME, as soon as you attempt to
suspend, the card will be removed, therefore this patch doesn't change the
behavior of this option.
However the removal will be done by pm notifier, which runs while
userspace is still not frozen and thus can freely use del_gendisk, without
the risk of deadlock which would happen otherwise.
Card detect workqueue is now disabled while userspace is frozen, Therefore
if you do use CONFIG_MMC_UNSAFE_RESUME, and remove the card during
suspend, the removal will be detected as soon as userspace is unfrozen,
again at the moment it is safe to call del_gendisk.
Tested with and without CONFIG_MMC_UNSAFE_RESUME with suspend and hibernate.
[akpm@linux-foundation.org: clean up function prototype]
[akpm@linux-foundation.org: fix CONFIG_PM-n linkage, small cleanups]
[akpm@linux-foundation.org: coding-style fixes]
Signed-off-by: Maxim Levitsky <maximlevitsky@gmail.com>
Cc: David Brownell <david-b@pacbell.net>
Cc: Alan Stern <stern@rowland.harvard.edu>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 01:01:41 +00:00
|
|
|
return;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-08-23 11:40:55 +00:00
|
|
|
/* If there is a non-removable card registered, only scan once */
|
|
|
|
if ((host->caps & MMC_CAP_NONREMOVABLE) && host->rescan_entered)
|
|
|
|
return;
|
|
|
|
host->rescan_entered = 1;
|
|
|
|
|
2006-12-30 23:11:32 +00:00
|
|
|
mmc_bus_get(host);
|
2014-01-07 11:07:11 +00:00
|
|
|
mmc_rpm_hold(host, &host->class_dev);
|
2007-01-03 18:47:29 +00:00
|
|
|
|
2010-11-28 05:21:28 +00:00
|
|
|
/*
|
|
|
|
* if there is a _removable_ card registered, check whether it is
|
|
|
|
* still present
|
|
|
|
*/
|
|
|
|
if (host->bus_ops && host->bus_ops->detect && !host->bus_dead
|
2011-03-08 21:32:02 +00:00
|
|
|
&& !(host->caps & MMC_CAP_NONREMOVABLE))
|
2009-03-31 14:51:21 +00:00
|
|
|
host->bus_ops->detect(host);
|
|
|
|
|
2011-11-28 14:22:00 +00:00
|
|
|
host->detect_change = 0;
|
2009-07-30 15:21:19 +00:00
|
|
|
/* If the card was removed the bus will be marked
|
|
|
|
* as dead - extend the wakelock so userspace
|
|
|
|
* can respond */
|
|
|
|
if (host->bus_dead)
|
|
|
|
extend_wakelock = 1;
|
|
|
|
|
2011-01-04 17:20:22 +00:00
|
|
|
/*
|
|
|
|
* Let mmc_bus_put() free the bus/bus_ops if we've found that
|
|
|
|
* the card is no longer present.
|
|
|
|
*/
|
2009-03-31 14:51:21 +00:00
|
|
|
mmc_bus_put(host);
|
|
|
|
mmc_bus_get(host);
|
|
|
|
|
|
|
|
/* if there still is a card present, stop here */
|
|
|
|
if (host->bus_ops != NULL) {
|
2014-01-07 11:07:11 +00:00
|
|
|
mmc_rpm_release(host, &host->class_dev);
|
2006-12-30 23:11:32 +00:00
|
|
|
mmc_bus_put(host);
|
2009-03-31 14:51:21 +00:00
|
|
|
goto out;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-01-07 11:07:11 +00:00
|
|
|
mmc_rpm_release(host, &host->class_dev);
|
|
|
|
|
2009-03-31 14:51:21 +00:00
|
|
|
/*
|
|
|
|
* Only we can add a new handler, so it's safe to
|
|
|
|
* release the lock here.
|
|
|
|
*/
|
|
|
|
mmc_bus_put(host);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-05-09 14:15:26 +00:00
|
|
|
if (host->ops->get_cd && host->ops->get_cd(host) == 0) {
|
|
|
|
mmc_claim_host(host);
|
|
|
|
mmc_power_off(host);
|
|
|
|
mmc_release_host(host);
|
2009-03-31 14:51:21 +00:00
|
|
|
goto out;
|
2012-05-09 14:15:26 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-04-18 01:29:57 +00:00
|
|
|
#if !defined(CONFIG_SEC_HYBRID_TRAY)
|
|
|
|
ST_LOG("<%s> %s insertion detected",__func__,host->class_dev.kobj.name);
|
|
|
|
#endif
|
2013-02-11 10:01:35 +00:00
|
|
|
mmc_rpm_hold(host, &host->class_dev);
|
2011-01-03 18:36:56 +00:00
|
|
|
mmc_claim_host(host);
|
2011-08-08 07:29:48 +00:00
|
|
|
if (!mmc_rescan_try_freq(host, host->f_min))
|
|
|
|
extend_wakelock = true;
|
2011-01-03 18:36:56 +00:00
|
|
|
mmc_release_host(host);
|
2013-02-11 10:01:35 +00:00
|
|
|
mmc_rpm_release(host, &host->class_dev);
|
2011-01-03 18:36:56 +00:00
|
|
|
out:
|
2014-05-05 09:01:11 +00:00
|
|
|
/* only extend the wakelock, if suspend has not started yet */
|
|
|
|
if (extend_wakelock && !host->rescan_disable)
|
2011-09-08 00:28:58 +00:00
|
|
|
wake_lock_timeout(&host->detect_wake_lock, HZ / 2);
|
2013-01-10 03:54:21 +00:00
|
|
|
|
|
|
|
if (host->caps & MMC_CAP_NEEDS_POLL)
|
2008-06-17 14:17:15 +00:00
|
|
|
mmc_schedule_delayed_work(&host->detect, HZ);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2007-05-19 12:06:24 +00:00
|
|
|
void mmc_start_host(struct mmc_host *host)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2015-02-05 07:04:52 +00:00
|
|
|
mmc_claim_host(host);
|
2012-05-09 14:15:26 +00:00
|
|
|
host->f_init = max(freqs[0], host->f_min);
|
2012-06-14 08:17:39 +00:00
|
|
|
host->rescan_disable = 0;
|
2013-04-15 15:27:25 +00:00
|
|
|
if (host->caps2 & MMC_CAP2_NO_PRESCAN_POWERUP)
|
|
|
|
mmc_power_off(host);
|
|
|
|
else
|
2013-04-04 13:41:06 +00:00
|
|
|
mmc_power_up(host);
|
2015-02-05 07:04:52 +00:00
|
|
|
mmc_release_host(host);
|
2007-05-19 12:06:24 +00:00
|
|
|
mmc_detect_change(host, 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2007-05-19 12:06:24 +00:00
|
|
|
void mmc_stop_host(struct mmc_host *host)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-02-11 19:43:19 +00:00
|
|
|
#ifdef CONFIG_MMC_DEBUG
|
2007-05-08 20:35:17 +00:00
|
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&host->lock, flags);
|
2007-02-11 19:43:19 +00:00
|
|
|
host->removed = 1;
|
2007-05-08 20:35:17 +00:00
|
|
|
spin_unlock_irqrestore(&host->lock, flags);
|
2007-02-11 19:43:19 +00:00
|
|
|
#endif
|
|
|
|
|
2012-06-14 08:17:39 +00:00
|
|
|
host->rescan_disable = 1;
|
2013-01-10 03:54:21 +00:00
|
|
|
cancel_delayed_work_sync(&host->detect);
|
|
|
|
|
2007-02-11 19:43:19 +00:00
|
|
|
mmc_flush_scheduled_work();
|
|
|
|
|
2010-03-05 21:43:31 +00:00
|
|
|
/* clear pm flags now and let card drivers set them as needed */
|
|
|
|
host->pm_flags = 0;
|
|
|
|
|
2006-12-30 23:11:32 +00:00
|
|
|
mmc_bus_get(host);
|
|
|
|
if (host->bus_ops && !host->bus_dead) {
|
2012-01-04 14:28:45 +00:00
|
|
|
/* Calling bus_ops->remove() with a claimed host can deadlock */
|
2006-12-30 23:11:32 +00:00
|
|
|
if (host->bus_ops->remove)
|
|
|
|
host->bus_ops->remove(host);
|
|
|
|
|
|
|
|
mmc_claim_host(host);
|
|
|
|
mmc_detach_bus(host);
|
2011-09-21 18:08:13 +00:00
|
|
|
mmc_power_off(host);
|
2006-12-30 23:11:32 +00:00
|
|
|
mmc_release_host(host);
|
2009-09-22 23:44:36 +00:00
|
|
|
mmc_bus_put(host);
|
|
|
|
return;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2006-12-30 23:11:32 +00:00
|
|
|
mmc_bus_put(host);
|
|
|
|
|
|
|
|
BUG_ON(host->card);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
mmc_power_off(host);
|
|
|
|
}
|
|
|
|
|
2010-10-02 11:54:06 +00:00
|
|
|
int mmc_power_save_host(struct mmc_host *host)
|
2009-09-22 23:44:33 +00:00
|
|
|
{
|
2010-10-02 11:54:06 +00:00
|
|
|
int ret = 0;
|
|
|
|
|
2011-07-17 15:38:41 +00:00
|
|
|
#ifdef CONFIG_MMC_DEBUG
|
|
|
|
pr_info("%s: %s: powering down\n", mmc_hostname(host), __func__);
|
|
|
|
#endif
|
|
|
|
|
2009-09-22 23:44:33 +00:00
|
|
|
mmc_bus_get(host);
|
|
|
|
|
|
|
|
if (!host->bus_ops || host->bus_dead || !host->bus_ops->power_restore) {
|
|
|
|
mmc_bus_put(host);
|
2010-10-02 11:54:06 +00:00
|
|
|
return -EINVAL;
|
2009-09-22 23:44:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (host->bus_ops->power_save)
|
2010-10-02 11:54:06 +00:00
|
|
|
ret = host->bus_ops->power_save(host);
|
2009-09-22 23:44:33 +00:00
|
|
|
|
|
|
|
mmc_bus_put(host);
|
|
|
|
|
|
|
|
mmc_power_off(host);
|
2010-10-02 11:54:06 +00:00
|
|
|
|
|
|
|
return ret;
|
2009-09-22 23:44:33 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mmc_power_save_host);
|
|
|
|
|
2010-10-02 11:54:06 +00:00
|
|
|
int mmc_power_restore_host(struct mmc_host *host)
|
2009-09-22 23:44:33 +00:00
|
|
|
{
|
2010-10-02 11:54:06 +00:00
|
|
|
int ret;
|
|
|
|
|
2011-07-17 15:38:41 +00:00
|
|
|
#ifdef CONFIG_MMC_DEBUG
|
|
|
|
pr_info("%s: %s: powering up\n", mmc_hostname(host), __func__);
|
|
|
|
#endif
|
|
|
|
|
2009-09-22 23:44:33 +00:00
|
|
|
mmc_bus_get(host);
|
|
|
|
|
|
|
|
if (!host->bus_ops || host->bus_dead || !host->bus_ops->power_restore) {
|
|
|
|
mmc_bus_put(host);
|
2010-10-02 11:54:06 +00:00
|
|
|
return -EINVAL;
|
2009-09-22 23:44:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
mmc_power_up(host);
|
2015-09-28 10:25:01 +00:00
|
|
|
mmc_claim_host(host);
|
2010-10-02 11:54:06 +00:00
|
|
|
ret = host->bus_ops->power_restore(host);
|
2015-09-28 10:25:01 +00:00
|
|
|
mmc_release_host(host);
|
2009-09-22 23:44:33 +00:00
|
|
|
|
|
|
|
mmc_bus_put(host);
|
2010-10-02 11:54:06 +00:00
|
|
|
|
|
|
|
return ret;
|
2009-09-22 23:44:33 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mmc_power_restore_host);
|
|
|
|
|
2016-04-01 11:21:04 +00:00
|
|
|
int mmc_power_restore_broken_host(struct mmc_host *host)
|
|
|
|
{
|
|
|
|
if (!host->bus_ops || host->bus_dead || !host->bus_ops->power_restore)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return host->bus_ops->power_restore(host);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mmc_power_restore_broken_host);
|
|
|
|
|
2009-09-22 23:44:34 +00:00
|
|
|
int mmc_card_awake(struct mmc_host *host)
|
|
|
|
{
|
|
|
|
int err = -ENOSYS;
|
|
|
|
|
2011-12-19 15:24:19 +00:00
|
|
|
if (host->caps2 & MMC_CAP2_NO_SLEEP_CMD)
|
|
|
|
return 0;
|
|
|
|
|
2009-09-22 23:44:34 +00:00
|
|
|
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;
|
|
|
|
|
2011-12-19 15:24:19 +00:00
|
|
|
if (host->caps2 & MMC_CAP2_NO_SLEEP_CMD)
|
|
|
|
return 0;
|
|
|
|
|
2009-09-22 23:44:34 +00:00
|
|
|
mmc_bus_get(host);
|
|
|
|
|
2011-11-17 04:34:33 +00:00
|
|
|
if (host->bus_ops && !host->bus_dead && host->bus_ops->sleep)
|
2009-09-22 23:44:34 +00:00
|
|
|
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);
|
|
|
|
|
2011-10-14 05:03:21 +00:00
|
|
|
/*
|
|
|
|
* Flush the cache to the non-volatile storage.
|
|
|
|
*/
|
|
|
|
int mmc_flush_cache(struct mmc_card *card)
|
|
|
|
{
|
|
|
|
struct mmc_host *host = card->host;
|
2013-06-30 06:31:21 +00:00
|
|
|
int err = 0, rc;
|
2011-10-14 05:03:21 +00:00
|
|
|
|
2014-01-27 09:46:25 +00:00
|
|
|
if (!(host->caps2 & MMC_CAP2_CACHE_CTRL) ||
|
|
|
|
(card->quirks & MMC_QUIRK_CACHE_DISABLE))
|
2011-10-14 05:03:21 +00:00
|
|
|
return err;
|
|
|
|
|
|
|
|
if (mmc_card_mmc(card) &&
|
|
|
|
(card->ext_csd.cache_size > 0) &&
|
|
|
|
(card->ext_csd.cache_ctrl & 1)) {
|
2013-06-25 07:43:24 +00:00
|
|
|
err = mmc_switch_ignore_timeout(card, EXT_CSD_CMD_SET_NORMAL,
|
2013-06-30 06:31:21 +00:00
|
|
|
EXT_CSD_FLUSH_CACHE, 1,
|
|
|
|
MMC_FLUSH_REQ_TIMEOUT_MS);
|
|
|
|
if (err == -ETIMEDOUT) {
|
2013-09-22 12:58:41 +00:00
|
|
|
pr_err("%s: cache flush timeout\n",
|
2013-06-30 06:31:21 +00:00
|
|
|
mmc_hostname(card->host));
|
|
|
|
rc = mmc_interrupt_hpi(card);
|
2015-01-18 13:34:18 +00:00
|
|
|
if (rc) {
|
2013-06-30 06:31:21 +00:00
|
|
|
pr_err("%s: mmc_interrupt_hpi() failed (%d)\n",
|
|
|
|
mmc_hostname(host), rc);
|
2015-01-18 13:34:18 +00:00
|
|
|
err = -ENODEV;
|
|
|
|
}
|
2013-06-30 06:31:21 +00:00
|
|
|
} else if (err) {
|
2011-10-14 05:03:21 +00:00
|
|
|
pr_err("%s: cache flush error %d\n",
|
|
|
|
mmc_hostname(card->host), err);
|
2013-06-30 06:31:21 +00:00
|
|
|
}
|
2011-10-14 05:03:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mmc_flush_cache);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#ifdef CONFIG_PM
|
|
|
|
|
|
|
|
/**
|
|
|
|
* mmc_suspend_host - suspend a host
|
|
|
|
* @host: mmc host
|
|
|
|
*/
|
2010-05-26 21:42:08 +00:00
|
|
|
int mmc_suspend_host(struct mmc_host *host)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-09-22 23:45:29 +00:00
|
|
|
int err = 0;
|
2016-01-07 10:43:21 +00:00
|
|
|
bool remove_pm_vote = false;
|
2013-12-06 07:36:18 +00:00
|
|
|
ktime_t start = ktime_get();
|
2009-09-22 23:45:29 +00:00
|
|
|
|
2009-07-30 14:55:28 +00:00
|
|
|
if (mmc_bus_needs_resume(host))
|
|
|
|
return 0;
|
|
|
|
|
2006-12-30 23:11:32 +00:00
|
|
|
mmc_bus_get(host);
|
|
|
|
if (host->bus_ops && !host->bus_dead) {
|
2016-01-07 10:43:21 +00:00
|
|
|
if (host->ops->notify_pm_status)
|
|
|
|
host->ops->notify_pm_status(host, DEV_SUSPENDING);
|
2015-11-02 08:03:32 +00:00
|
|
|
/*
|
|
|
|
* Disable clock scaling before suspend and enable it after
|
|
|
|
* resume so as to avoid clock scaling decisions kicking in
|
|
|
|
* during this window.
|
|
|
|
*/
|
|
|
|
if (mmc_can_scale_clk(host))
|
|
|
|
mmc_disable_clk_scaling(host);
|
|
|
|
|
2013-02-12 03:28:23 +00:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* Skip try claim host for SDIO cards, doing so fixes deadlock
|
|
|
|
* conditions. The function driver suspend may again call into
|
|
|
|
* SDIO driver within a different context for enabling power
|
|
|
|
* save mode in the card and hence wait in mmc_claim_host
|
|
|
|
* causing deadlock.
|
|
|
|
*/
|
|
|
|
if (!(host->card && mmc_card_sdio(host->card)))
|
2016-01-07 10:43:21 +00:00
|
|
|
if (!mmc_try_claim_host(host)) {
|
2013-02-12 03:28:23 +00:00
|
|
|
err = -EBUSY;
|
2016-01-07 10:43:21 +00:00
|
|
|
remove_pm_vote = true;
|
|
|
|
}
|
2011-11-23 03:13:18 +00:00
|
|
|
|
2013-02-12 03:28:23 +00:00
|
|
|
if (!err) {
|
|
|
|
if (host->bus_ops->suspend) {
|
2013-11-05 10:58:21 +00:00
|
|
|
if (host->card) {
|
|
|
|
err = mmc_stop_bkops(host->card);
|
2016-01-07 10:43:21 +00:00
|
|
|
if (err) {
|
|
|
|
remove_pm_vote = true;
|
2013-11-05 10:58:21 +00:00
|
|
|
goto out;
|
2016-01-07 10:43:21 +00:00
|
|
|
}
|
2013-11-05 10:58:21 +00:00
|
|
|
}
|
2013-02-12 03:28:23 +00:00
|
|
|
err = host->bus_ops->suspend(host);
|
2016-01-07 10:43:21 +00:00
|
|
|
if (err)
|
|
|
|
remove_pm_vote = true;
|
2013-11-05 10:58:21 +00:00
|
|
|
if (host->card)
|
|
|
|
MMC_UPDATE_BKOPS_STATS_SUSPEND(host->
|
2012-10-11 16:29:28 +00:00
|
|
|
card->bkops_info.bkops_stats);
|
2013-02-12 03:28:23 +00:00
|
|
|
}
|
|
|
|
if (!(host->card && mmc_card_sdio(host->card)))
|
|
|
|
mmc_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;
|
|
|
|
}
|
2010-10-13 07:31:56 +00:00
|
|
|
}
|
2007-04-28 15:30:50 +00:00
|
|
|
}
|
2006-12-30 23:11:32 +00:00
|
|
|
mmc_bus_put(host);
|
|
|
|
|
2015-02-05 07:04:52 +00:00
|
|
|
if (!err && !mmc_card_keep_power(host)) {
|
|
|
|
mmc_claim_host(host);
|
2009-09-22 23:45:29 +00:00
|
|
|
mmc_power_off(host);
|
2015-02-05 07:04:52 +00:00
|
|
|
mmc_release_host(host);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2015-11-02 08:03:32 +00:00
|
|
|
if (err && mmc_can_scale_clk(host))
|
|
|
|
mmc_init_clk_scaling(host);
|
2013-12-06 07:36:18 +00:00
|
|
|
trace_mmc_suspend_host(mmc_hostname(host), err,
|
|
|
|
ktime_to_us(ktime_sub(ktime_get(), start)));
|
2016-01-07 10:43:21 +00:00
|
|
|
if (host->ops->notify_pm_status)
|
|
|
|
host->ops->notify_pm_status(host,
|
|
|
|
remove_pm_vote ? DEV_ERROR : DEV_SUSPENDED);
|
|
|
|
|
2017-04-18 01:29:57 +00:00
|
|
|
if (host->card && host->card->type == MMC_TYPE_SD)
|
|
|
|
mdelay(50);
|
|
|
|
|
2013-02-12 03:28:23 +00:00
|
|
|
return err;
|
2011-10-14 05:03:21 +00:00
|
|
|
out:
|
2013-02-12 03:28:23 +00:00
|
|
|
if (!(host->card && mmc_card_sdio(host->card)))
|
|
|
|
mmc_release_host(host);
|
2016-01-07 10:43:21 +00:00
|
|
|
if (host->ops->notify_pm_status)
|
|
|
|
host->ops->notify_pm_status(host,
|
|
|
|
remove_pm_vote ? DEV_ERROR : DEV_SUSPENDED);
|
2013-02-12 03:28:23 +00:00
|
|
|
|
2009-09-22 23:45:29 +00:00
|
|
|
return err;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(mmc_suspend_host);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* mmc_resume_host - resume a previously suspended host
|
|
|
|
* @host: mmc host
|
|
|
|
*/
|
|
|
|
int mmc_resume_host(struct mmc_host *host)
|
|
|
|
{
|
2009-09-22 23:45:29 +00:00
|
|
|
int err = 0;
|
2016-01-07 10:43:21 +00:00
|
|
|
bool remove_pm_vote = false;
|
2013-12-06 07:36:18 +00:00
|
|
|
ktime_t start = ktime_get();
|
2009-09-22 23:45:29 +00:00
|
|
|
|
2007-05-01 14:00:02 +00:00
|
|
|
mmc_bus_get(host);
|
2010-10-14 22:20:21 +00:00
|
|
|
if (mmc_bus_manual_resume(host)) {
|
2009-07-30 14:55:28 +00:00
|
|
|
host->bus_resume_flags |= MMC_BUSRESUME_NEEDS_RESUME;
|
|
|
|
mmc_bus_put(host);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-05-01 14:00:02 +00:00
|
|
|
if (host->bus_ops && !host->bus_dead) {
|
2016-01-07 10:43:21 +00:00
|
|
|
if (host->ops->notify_pm_status)
|
|
|
|
host->ops->notify_pm_status(host, DEV_RESUMING);
|
2011-04-05 14:43:20 +00:00
|
|
|
if (!mmc_card_keep_power(host)) {
|
2015-02-05 07:04:52 +00:00
|
|
|
mmc_claim_host(host);
|
2010-03-05 21:43:31 +00:00
|
|
|
mmc_power_up(host);
|
2015-02-05 07:04:52 +00:00
|
|
|
mmc_release_host(host);
|
2010-03-05 21:43:31 +00:00
|
|
|
mmc_select_voltage(host, host->ocr);
|
2010-11-28 05:21:30 +00:00
|
|
|
/*
|
|
|
|
* 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);
|
|
|
|
}
|
2010-03-05 21:43:31 +00:00
|
|
|
}
|
2007-05-01 14:00:02 +00:00
|
|
|
BUG_ON(!host->bus_ops->resume);
|
2009-09-22 23:45:29 +00:00
|
|
|
err = host->bus_ops->resume(host);
|
|
|
|
if (err) {
|
2011-10-11 06:14:09 +00:00
|
|
|
pr_warning("%s: error %d during resume "
|
2009-09-22 23:45:29 +00:00
|
|
|
"(card was removed?)\n",
|
|
|
|
mmc_hostname(host), err);
|
2016-01-07 10:43:21 +00:00
|
|
|
remove_pm_vote = true;
|
2009-09-22 23:45:29 +00:00
|
|
|
err = 0;
|
|
|
|
}
|
2007-05-01 14:00:02 +00:00
|
|
|
}
|
2011-05-09 08:32:31 +00:00
|
|
|
host->pm_flags &= ~MMC_PM_KEEP_POWER;
|
2016-04-09 16:28:17 +00:00
|
|
|
host->pm_flags &= ~MMC_PM_WAKE_SDIO_IRQ;
|
2007-05-01 14:00:02 +00:00
|
|
|
mmc_bus_put(host);
|
|
|
|
|
2013-12-06 07:36:18 +00:00
|
|
|
trace_mmc_resume_host(mmc_hostname(host), err,
|
|
|
|
ktime_to_us(ktime_sub(ktime_get(), start)));
|
2016-01-07 10:43:21 +00:00
|
|
|
if (host->ops->notify_pm_status)
|
|
|
|
host->ops->notify_pm_status(host,
|
|
|
|
remove_pm_vote ? DEV_ERROR : DEV_RESUMED);
|
|
|
|
|
2009-09-22 23:45:29 +00:00
|
|
|
return err;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(mmc_resume_host);
|
|
|
|
|
mmc: fix all hangs related to mmc/sd card insert/removal during suspend/resume
If you don't use CONFIG_MMC_UNSAFE_RESUME, as soon as you attempt to
suspend, the card will be removed, therefore this patch doesn't change the
behavior of this option.
However the removal will be done by pm notifier, which runs while
userspace is still not frozen and thus can freely use del_gendisk, without
the risk of deadlock which would happen otherwise.
Card detect workqueue is now disabled while userspace is frozen, Therefore
if you do use CONFIG_MMC_UNSAFE_RESUME, and remove the card during
suspend, the removal will be detected as soon as userspace is unfrozen,
again at the moment it is safe to call del_gendisk.
Tested with and without CONFIG_MMC_UNSAFE_RESUME with suspend and hibernate.
[akpm@linux-foundation.org: clean up function prototype]
[akpm@linux-foundation.org: fix CONFIG_PM-n linkage, small cleanups]
[akpm@linux-foundation.org: coding-style fixes]
Signed-off-by: Maxim Levitsky <maximlevitsky@gmail.com>
Cc: David Brownell <david-b@pacbell.net>
Cc: Alan Stern <stern@rowland.harvard.edu>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 01:01:41 +00:00
|
|
|
/* 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;
|
2012-09-17 08:42:02 +00:00
|
|
|
int err = 0;
|
mmc: fix all hangs related to mmc/sd card insert/removal during suspend/resume
If you don't use CONFIG_MMC_UNSAFE_RESUME, as soon as you attempt to
suspend, the card will be removed, therefore this patch doesn't change the
behavior of this option.
However the removal will be done by pm notifier, which runs while
userspace is still not frozen and thus can freely use del_gendisk, without
the risk of deadlock which would happen otherwise.
Card detect workqueue is now disabled while userspace is frozen, Therefore
if you do use CONFIG_MMC_UNSAFE_RESUME, and remove the card during
suspend, the removal will be detected as soon as userspace is unfrozen,
again at the moment it is safe to call del_gendisk.
Tested with and without CONFIG_MMC_UNSAFE_RESUME with suspend and hibernate.
[akpm@linux-foundation.org: clean up function prototype]
[akpm@linux-foundation.org: fix CONFIG_PM-n linkage, small cleanups]
[akpm@linux-foundation.org: coding-style fixes]
Signed-off-by: Maxim Levitsky <maximlevitsky@gmail.com>
Cc: David Brownell <david-b@pacbell.net>
Cc: Alan Stern <stern@rowland.harvard.edu>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 01:01:41 +00:00
|
|
|
|
|
|
|
switch (mode) {
|
|
|
|
case PM_HIBERNATION_PREPARE:
|
|
|
|
case PM_SUSPEND_PREPARE:
|
mmc: core: Add support for idle time BKOPS
Devices have various maintenance operations need to perform internally.
In order to reduce latencies during time critical operations like read
and write, it is better to execute maintenance operations in other
times - when the host is not being serviced. Such operations are called
Background operations (BKOPS).
The device notifies the status of the BKOPS need by updating BKOPS_STATUS
(EXT_CSD byte [246]).
According to the standard a host that supports BKOPS shall check the
status periodically and start background operations as needed, so that
the device has enough time for its maintenance operations.
This patch adds support for this periodic check of the BKOPS status.
Since foreground operations are of higher priority than background
operations the host will check the need for BKOPS when it is idle,
and in case of an incoming request the BKOPS operation will be
interrupted.
When the mmcqd thread is idle, a delayed work is created to check the
need for BKOPS. The time to start the delayed work is calculated based
on the host controller suspend timeout, in case it was set. If not, a
default time is used.
If BKOPS are required in level 1, which is non-blocking, there will be
polling of the card status to wait for the BKOPS completion and prevent
suspend that will interrupt the BKOPS.
If the card raised an exception, the need for urgent BKOPS (level 2/3)
will be checked immediately and if needed, the BKOPS will be performed
without waiting for the next idle time.
Change-Id: I7460afea1bc94498a93ff6553276b994d3bba012
Signed-off-by: Maya Erez <merez@codeaurora.org>
2012-10-10 01:47:54 +00:00
|
|
|
if (host->card && mmc_card_mmc(host->card)) {
|
2013-01-04 08:55:00 +00:00
|
|
|
mmc_claim_host(host);
|
2012-09-17 08:42:02 +00:00
|
|
|
err = mmc_stop_bkops(host->card);
|
2013-01-04 08:55:00 +00:00
|
|
|
mmc_release_host(host);
|
2012-09-17 08:42:02 +00:00
|
|
|
if (err) {
|
|
|
|
pr_err("%s: didn't stop bkops\n",
|
|
|
|
mmc_hostname(host));
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
}
|
mmc: fix all hangs related to mmc/sd card insert/removal during suspend/resume
If you don't use CONFIG_MMC_UNSAFE_RESUME, as soon as you attempt to
suspend, the card will be removed, therefore this patch doesn't change the
behavior of this option.
However the removal will be done by pm notifier, which runs while
userspace is still not frozen and thus can freely use del_gendisk, without
the risk of deadlock which would happen otherwise.
Card detect workqueue is now disabled while userspace is frozen, Therefore
if you do use CONFIG_MMC_UNSAFE_RESUME, and remove the card during
suspend, the removal will be detected as soon as userspace is unfrozen,
again at the moment it is safe to call del_gendisk.
Tested with and without CONFIG_MMC_UNSAFE_RESUME with suspend and hibernate.
[akpm@linux-foundation.org: clean up function prototype]
[akpm@linux-foundation.org: fix CONFIG_PM-n linkage, small cleanups]
[akpm@linux-foundation.org: coding-style fixes]
Signed-off-by: Maxim Levitsky <maximlevitsky@gmail.com>
Cc: David Brownell <david-b@pacbell.net>
Cc: Alan Stern <stern@rowland.harvard.edu>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 01:01:41 +00:00
|
|
|
|
|
|
|
spin_lock_irqsave(&host->lock, flags);
|
2010-10-14 22:20:21 +00:00
|
|
|
if (mmc_bus_needs_resume(host)) {
|
|
|
|
spin_unlock_irqrestore(&host->lock, flags);
|
|
|
|
break;
|
|
|
|
}
|
2014-05-05 09:01:11 +00:00
|
|
|
|
|
|
|
/* since its suspending anyway, disable rescan */
|
|
|
|
host->rescan_disable = 1;
|
2013-01-10 03:54:21 +00:00
|
|
|
spin_unlock_irqrestore(&host->lock, flags);
|
|
|
|
|
|
|
|
/* Wait for pending detect work to be completed */
|
|
|
|
if (!(host->caps & MMC_CAP_NEEDS_POLL))
|
|
|
|
flush_work(&host->detect.work);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* In some cases, the detect work might be scheduled
|
|
|
|
* just before rescan_disable is set to true.
|
|
|
|
* Cancel such the scheduled works.
|
|
|
|
*/
|
|
|
|
cancel_delayed_work_sync(&host->detect);
|
mmc: fix all hangs related to mmc/sd card insert/removal during suspend/resume
If you don't use CONFIG_MMC_UNSAFE_RESUME, as soon as you attempt to
suspend, the card will be removed, therefore this patch doesn't change the
behavior of this option.
However the removal will be done by pm notifier, which runs while
userspace is still not frozen and thus can freely use del_gendisk, without
the risk of deadlock which would happen otherwise.
Card detect workqueue is now disabled while userspace is frozen, Therefore
if you do use CONFIG_MMC_UNSAFE_RESUME, and remove the card during
suspend, the removal will be detected as soon as userspace is unfrozen,
again at the moment it is safe to call del_gendisk.
Tested with and without CONFIG_MMC_UNSAFE_RESUME with suspend and hibernate.
[akpm@linux-foundation.org: clean up function prototype]
[akpm@linux-foundation.org: fix CONFIG_PM-n linkage, small cleanups]
[akpm@linux-foundation.org: coding-style fixes]
Signed-off-by: Maxim Levitsky <maximlevitsky@gmail.com>
Cc: David Brownell <david-b@pacbell.net>
Cc: Alan Stern <stern@rowland.harvard.edu>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 01:01:41 +00:00
|
|
|
|
2014-05-05 09:01:11 +00:00
|
|
|
/*
|
|
|
|
* It is possible that the wake-lock has been acquired, since
|
|
|
|
* its being suspended, release the wakelock
|
|
|
|
*/
|
|
|
|
if (wake_lock_active(&host->detect_wake_lock))
|
|
|
|
wake_unlock(&host->detect_wake_lock);
|
|
|
|
|
mmc: fix all hangs related to mmc/sd card insert/removal during suspend/resume
If you don't use CONFIG_MMC_UNSAFE_RESUME, as soon as you attempt to
suspend, the card will be removed, therefore this patch doesn't change the
behavior of this option.
However the removal will be done by pm notifier, which runs while
userspace is still not frozen and thus can freely use del_gendisk, without
the risk of deadlock which would happen otherwise.
Card detect workqueue is now disabled while userspace is frozen, Therefore
if you do use CONFIG_MMC_UNSAFE_RESUME, and remove the card during
suspend, the removal will be detected as soon as userspace is unfrozen,
again at the moment it is safe to call del_gendisk.
Tested with and without CONFIG_MMC_UNSAFE_RESUME with suspend and hibernate.
[akpm@linux-foundation.org: clean up function prototype]
[akpm@linux-foundation.org: fix CONFIG_PM-n linkage, small cleanups]
[akpm@linux-foundation.org: coding-style fixes]
Signed-off-by: Maxim Levitsky <maximlevitsky@gmail.com>
Cc: David Brownell <david-b@pacbell.net>
Cc: Alan Stern <stern@rowland.harvard.edu>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 01:01:41 +00:00
|
|
|
if (!host->bus_ops || host->bus_ops->suspend)
|
|
|
|
break;
|
|
|
|
|
2012-01-04 14:28:45 +00:00
|
|
|
/* Calling bus_ops->remove() with a claimed host can deadlock */
|
mmc: fix all hangs related to mmc/sd card insert/removal during suspend/resume
If you don't use CONFIG_MMC_UNSAFE_RESUME, as soon as you attempt to
suspend, the card will be removed, therefore this patch doesn't change the
behavior of this option.
However the removal will be done by pm notifier, which runs while
userspace is still not frozen and thus can freely use del_gendisk, without
the risk of deadlock which would happen otherwise.
Card detect workqueue is now disabled while userspace is frozen, Therefore
if you do use CONFIG_MMC_UNSAFE_RESUME, and remove the card during
suspend, the removal will be detected as soon as userspace is unfrozen,
again at the moment it is safe to call del_gendisk.
Tested with and without CONFIG_MMC_UNSAFE_RESUME with suspend and hibernate.
[akpm@linux-foundation.org: clean up function prototype]
[akpm@linux-foundation.org: fix CONFIG_PM-n linkage, small cleanups]
[akpm@linux-foundation.org: coding-style fixes]
Signed-off-by: Maxim Levitsky <maximlevitsky@gmail.com>
Cc: David Brownell <david-b@pacbell.net>
Cc: Alan Stern <stern@rowland.harvard.edu>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 01:01:41 +00:00
|
|
|
if (host->bus_ops->remove)
|
|
|
|
host->bus_ops->remove(host);
|
|
|
|
|
2012-01-04 14:28:45 +00:00
|
|
|
mmc_claim_host(host);
|
mmc: fix all hangs related to mmc/sd card insert/removal during suspend/resume
If you don't use CONFIG_MMC_UNSAFE_RESUME, as soon as you attempt to
suspend, the card will be removed, therefore this patch doesn't change the
behavior of this option.
However the removal will be done by pm notifier, which runs while
userspace is still not frozen and thus can freely use del_gendisk, without
the risk of deadlock which would happen otherwise.
Card detect workqueue is now disabled while userspace is frozen, Therefore
if you do use CONFIG_MMC_UNSAFE_RESUME, and remove the card during
suspend, the removal will be detected as soon as userspace is unfrozen,
again at the moment it is safe to call del_gendisk.
Tested with and without CONFIG_MMC_UNSAFE_RESUME with suspend and hibernate.
[akpm@linux-foundation.org: clean up function prototype]
[akpm@linux-foundation.org: fix CONFIG_PM-n linkage, small cleanups]
[akpm@linux-foundation.org: coding-style fixes]
Signed-off-by: Maxim Levitsky <maximlevitsky@gmail.com>
Cc: David Brownell <david-b@pacbell.net>
Cc: Alan Stern <stern@rowland.harvard.edu>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 01:01:41 +00:00
|
|
|
mmc_detach_bus(host);
|
2011-09-21 18:08:13 +00:00
|
|
|
mmc_power_off(host);
|
mmc: fix all hangs related to mmc/sd card insert/removal during suspend/resume
If you don't use CONFIG_MMC_UNSAFE_RESUME, as soon as you attempt to
suspend, the card will be removed, therefore this patch doesn't change the
behavior of this option.
However the removal will be done by pm notifier, which runs while
userspace is still not frozen and thus can freely use del_gendisk, without
the risk of deadlock which would happen otherwise.
Card detect workqueue is now disabled while userspace is frozen, Therefore
if you do use CONFIG_MMC_UNSAFE_RESUME, and remove the card during
suspend, the removal will be detected as soon as userspace is unfrozen,
again at the moment it is safe to call del_gendisk.
Tested with and without CONFIG_MMC_UNSAFE_RESUME with suspend and hibernate.
[akpm@linux-foundation.org: clean up function prototype]
[akpm@linux-foundation.org: fix CONFIG_PM-n linkage, small cleanups]
[akpm@linux-foundation.org: coding-style fixes]
Signed-off-by: Maxim Levitsky <maximlevitsky@gmail.com>
Cc: David Brownell <david-b@pacbell.net>
Cc: Alan Stern <stern@rowland.harvard.edu>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 01:01:41 +00:00
|
|
|
mmc_release_host(host);
|
|
|
|
host->pm_flags = 0;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PM_POST_SUSPEND:
|
|
|
|
case PM_POST_HIBERNATION:
|
2010-12-10 07:40:31 +00:00
|
|
|
case PM_POST_RESTORE:
|
mmc: fix all hangs related to mmc/sd card insert/removal during suspend/resume
If you don't use CONFIG_MMC_UNSAFE_RESUME, as soon as you attempt to
suspend, the card will be removed, therefore this patch doesn't change the
behavior of this option.
However the removal will be done by pm notifier, which runs while
userspace is still not frozen and thus can freely use del_gendisk, without
the risk of deadlock which would happen otherwise.
Card detect workqueue is now disabled while userspace is frozen, Therefore
if you do use CONFIG_MMC_UNSAFE_RESUME, and remove the card during
suspend, the removal will be detected as soon as userspace is unfrozen,
again at the moment it is safe to call del_gendisk.
Tested with and without CONFIG_MMC_UNSAFE_RESUME with suspend and hibernate.
[akpm@linux-foundation.org: clean up function prototype]
[akpm@linux-foundation.org: fix CONFIG_PM-n linkage, small cleanups]
[akpm@linux-foundation.org: coding-style fixes]
Signed-off-by: Maxim Levitsky <maximlevitsky@gmail.com>
Cc: David Brownell <david-b@pacbell.net>
Cc: Alan Stern <stern@rowland.harvard.edu>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 01:01:41 +00:00
|
|
|
|
|
|
|
spin_lock_irqsave(&host->lock, flags);
|
2015-06-29 02:42:13 +00:00
|
|
|
host->rescan_disable = 0;
|
2010-10-14 22:20:21 +00:00
|
|
|
if (mmc_bus_manual_resume(host)) {
|
|
|
|
spin_unlock_irqrestore(&host->lock, flags);
|
|
|
|
break;
|
|
|
|
}
|
mmc: fix all hangs related to mmc/sd card insert/removal during suspend/resume
If you don't use CONFIG_MMC_UNSAFE_RESUME, as soon as you attempt to
suspend, the card will be removed, therefore this patch doesn't change the
behavior of this option.
However the removal will be done by pm notifier, which runs while
userspace is still not frozen and thus can freely use del_gendisk, without
the risk of deadlock which would happen otherwise.
Card detect workqueue is now disabled while userspace is frozen, Therefore
if you do use CONFIG_MMC_UNSAFE_RESUME, and remove the card during
suspend, the removal will be detected as soon as userspace is unfrozen,
again at the moment it is safe to call del_gendisk.
Tested with and without CONFIG_MMC_UNSAFE_RESUME with suspend and hibernate.
[akpm@linux-foundation.org: clean up function prototype]
[akpm@linux-foundation.org: fix CONFIG_PM-n linkage, small cleanups]
[akpm@linux-foundation.org: coding-style fixes]
Signed-off-by: Maxim Levitsky <maximlevitsky@gmail.com>
Cc: David Brownell <david-b@pacbell.net>
Cc: Alan Stern <stern@rowland.harvard.edu>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 01:01:41 +00:00
|
|
|
spin_unlock_irqrestore(&host->lock, flags);
|
|
|
|
mmc_detect_change(host, 0);
|
2013-01-10 03:54:21 +00:00
|
|
|
break;
|
mmc: fix all hangs related to mmc/sd card insert/removal during suspend/resume
If you don't use CONFIG_MMC_UNSAFE_RESUME, as soon as you attempt to
suspend, the card will be removed, therefore this patch doesn't change the
behavior of this option.
However the removal will be done by pm notifier, which runs while
userspace is still not frozen and thus can freely use del_gendisk, without
the risk of deadlock which would happen otherwise.
Card detect workqueue is now disabled while userspace is frozen, Therefore
if you do use CONFIG_MMC_UNSAFE_RESUME, and remove the card during
suspend, the removal will be detected as soon as userspace is unfrozen,
again at the moment it is safe to call del_gendisk.
Tested with and without CONFIG_MMC_UNSAFE_RESUME with suspend and hibernate.
[akpm@linux-foundation.org: clean up function prototype]
[akpm@linux-foundation.org: fix CONFIG_PM-n linkage, small cleanups]
[akpm@linux-foundation.org: coding-style fixes]
Signed-off-by: Maxim Levitsky <maximlevitsky@gmail.com>
Cc: David Brownell <david-b@pacbell.net>
Cc: Alan Stern <stern@rowland.harvard.edu>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 01:01:41 +00:00
|
|
|
|
2013-01-10 03:54:21 +00:00
|
|
|
default:
|
|
|
|
return -EINVAL;
|
mmc: fix all hangs related to mmc/sd card insert/removal during suspend/resume
If you don't use CONFIG_MMC_UNSAFE_RESUME, as soon as you attempt to
suspend, the card will be removed, therefore this patch doesn't change the
behavior of this option.
However the removal will be done by pm notifier, which runs while
userspace is still not frozen and thus can freely use del_gendisk, without
the risk of deadlock which would happen otherwise.
Card detect workqueue is now disabled while userspace is frozen, Therefore
if you do use CONFIG_MMC_UNSAFE_RESUME, and remove the card during
suspend, the removal will be detected as soon as userspace is unfrozen,
again at the moment it is safe to call del_gendisk.
Tested with and without CONFIG_MMC_UNSAFE_RESUME with suspend and hibernate.
[akpm@linux-foundation.org: clean up function prototype]
[akpm@linux-foundation.org: fix CONFIG_PM-n linkage, small cleanups]
[akpm@linux-foundation.org: coding-style fixes]
Signed-off-by: Maxim Levitsky <maximlevitsky@gmail.com>
Cc: David Brownell <david-b@pacbell.net>
Cc: Alan Stern <stern@rowland.harvard.edu>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-08-11 01:01:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
|
|
|
|
2013-03-20 16:25:05 +00:00
|
|
|
#ifdef CONFIG_PM_RUNTIME
|
|
|
|
void mmc_dump_dev_pm_state(struct mmc_host *host, struct device *dev)
|
|
|
|
{
|
|
|
|
pr_err("%s: %s: err: runtime_error: %d\n", dev_name(dev),
|
|
|
|
mmc_hostname(host), dev->power.runtime_error);
|
|
|
|
pr_err("%s: %s: disable_depth: %d runtime_status: %d idle_notification: %d\n",
|
|
|
|
dev_name(dev), mmc_hostname(host), dev->power.disable_depth,
|
|
|
|
dev->power.runtime_status,
|
|
|
|
dev->power.idle_notification);
|
|
|
|
pr_err("%s: %s: request_pending: %d, request: %d\n",
|
|
|
|
dev_name(dev), mmc_hostname(host),
|
|
|
|
dev->power.request_pending, dev->power.request);
|
|
|
|
}
|
|
|
|
|
2013-02-11 10:01:35 +00:00
|
|
|
void mmc_rpm_hold(struct mmc_host *host, struct device *dev)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (!mmc_use_core_runtime_pm(host))
|
|
|
|
return;
|
|
|
|
|
|
|
|
ret = pm_runtime_get_sync(dev);
|
2013-03-20 16:25:05 +00:00
|
|
|
if ((ret < 0) &&
|
|
|
|
(dev->power.runtime_error || (dev->power.disable_depth > 0))) {
|
|
|
|
pr_err("%s: %s: %s: pm_runtime_get_sync: err: %d\n",
|
2013-02-11 10:01:35 +00:00
|
|
|
dev_name(dev), mmc_hostname(host), __func__, ret);
|
2013-03-20 16:25:05 +00:00
|
|
|
mmc_dump_dev_pm_state(host, dev);
|
2013-02-11 10:01:35 +00:00
|
|
|
if (pm_runtime_suspended(dev))
|
|
|
|
BUG_ON(1);
|
|
|
|
}
|
|
|
|
}
|
2013-03-20 16:25:05 +00:00
|
|
|
|
2013-02-11 10:01:35 +00:00
|
|
|
EXPORT_SYMBOL(mmc_rpm_hold);
|
|
|
|
|
|
|
|
void mmc_rpm_release(struct mmc_host *host, struct device *dev)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (!mmc_use_core_runtime_pm(host))
|
|
|
|
return;
|
|
|
|
|
2015-05-27 07:36:23 +00:00
|
|
|
ret = pm_runtime_put(dev);
|
2013-03-20 16:25:05 +00:00
|
|
|
if ((ret < 0) &&
|
|
|
|
(dev->power.runtime_error || (dev->power.disable_depth > 0))) {
|
|
|
|
pr_err("%s: %s: %s: pm_runtime_put_sync: err: %d\n",
|
2013-02-11 10:01:35 +00:00
|
|
|
dev_name(dev), mmc_hostname(host), __func__, ret);
|
2013-03-20 16:25:05 +00:00
|
|
|
mmc_dump_dev_pm_state(host, dev);
|
|
|
|
}
|
2013-02-11 10:01:35 +00:00
|
|
|
}
|
2013-03-20 16:25:05 +00:00
|
|
|
|
2013-02-11 10:01:35 +00:00
|
|
|
EXPORT_SYMBOL(mmc_rpm_release);
|
2013-03-20 16:25:05 +00:00
|
|
|
#else
|
|
|
|
void mmc_rpm_hold(struct mmc_host *host, struct device *dev) {}
|
|
|
|
EXPORT_SYMBOL(mmc_rpm_hold);
|
|
|
|
|
|
|
|
void mmc_rpm_release(struct mmc_host *host, struct device *dev) {}
|
|
|
|
EXPORT_SYMBOL(mmc_rpm_release);
|
|
|
|
#endif
|
2013-02-11 10:01:35 +00:00
|
|
|
|
2013-01-14 19:28:17 +00:00
|
|
|
/**
|
|
|
|
* mmc_init_context_info() - init synchronization context
|
|
|
|
* @host: mmc host
|
|
|
|
*
|
|
|
|
* Init struct context_info needed to implement asynchronous
|
|
|
|
* request mechanism, used by mmc core, host driver and mmc requests
|
|
|
|
* supplier.
|
|
|
|
*/
|
|
|
|
void mmc_init_context_info(struct mmc_host *host)
|
|
|
|
{
|
|
|
|
spin_lock_init(&host->context_info.lock);
|
|
|
|
host->context_info.is_new_req = false;
|
|
|
|
host->context_info.is_done_rcv = false;
|
|
|
|
host->context_info.is_waiting_last_req = false;
|
|
|
|
init_waitqueue_head(&host->context_info.wait);
|
|
|
|
}
|
|
|
|
|
2008-04-14 22:22:49 +00:00
|
|
|
#ifdef CONFIG_MMC_EMBEDDED_SDIO
|
|
|
|
void mmc_set_embedded_sdio_data(struct mmc_host *host,
|
|
|
|
struct sdio_cis *cis,
|
|
|
|
struct sdio_cccr *cccr,
|
|
|
|
struct sdio_embedded_func *funcs,
|
|
|
|
int num_funcs)
|
|
|
|
{
|
|
|
|
host->embedded_sdio_data.cis = cis;
|
|
|
|
host->embedded_sdio_data.cccr = cccr;
|
|
|
|
host->embedded_sdio_data.funcs = funcs;
|
|
|
|
host->embedded_sdio_data.num_funcs = num_funcs;
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(mmc_set_embedded_sdio_data);
|
|
|
|
#endif
|
|
|
|
|
2007-05-19 12:32:22 +00:00
|
|
|
static int __init mmc_init(void)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2010-12-24 15:00:17 +00:00
|
|
|
workqueue = alloc_ordered_workqueue("kmmcd", 0);
|
2007-05-19 12:32:22 +00:00
|
|
|
if (!workqueue)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
ret = mmc_register_bus();
|
2007-05-26 11:48:18 +00:00
|
|
|
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);
|
|
|
|
|
2007-05-19 12:32:22 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit mmc_exit(void)
|
|
|
|
{
|
2007-05-26 11:48:18 +00:00
|
|
|
sdio_unregister_bus();
|
2007-05-19 12:32:22 +00:00
|
|
|
mmc_unregister_host_class();
|
|
|
|
mmc_unregister_bus();
|
|
|
|
destroy_workqueue(workqueue);
|
|
|
|
}
|
|
|
|
|
2007-06-16 06:07:53 +00:00
|
|
|
subsys_initcall(mmc_init);
|
2007-05-19 12:32:22 +00:00
|
|
|
module_exit(mmc_exit);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
MODULE_LICENSE("GPL");
|