lkml.org 
[lkml]   [2009]   [Jul]   [28]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
Patch in this message
/
From
Date
Subject[PATCH V2 21/32] omap_hsmmc: add mmc card sleep and awake support
From 372d05a33f04d6a664ad1d3a80bed3d9ae80e495 Mon Sep 17 00:00:00 2001
From: Jarkko Lavinen <jarkko.lavinen@nokia.com>
Date: Tue, 12 May 2009 19:46:14 +0300
Subject: [PATCH] omap_hsmmc: add mmc card sleep and awake support

After 1 second of inactivity, put card and/or regulator
to sleep. After 8 seconds of inactivity, turn off the
power.

Signed-off-by: Jarkko Lavinen <jarkko.lavinen@nokia.com>
Signed-off-by: Adrian Hunter <adrian.hunter@nokia.com>
---
drivers/mmc/host/omap_hsmmc.c | 162 ++++++++++++++++++++++-------------------
1 files changed, 88 insertions(+), 74 deletions(-)
diff --git a/drivers/mmc/host/omap_hsmmc.c b/drivers/mmc/host/omap_hsmmc.c
index 7a17901..d5fb066 100644
--- a/drivers/mmc/host/omap_hsmmc.c
+++ b/drivers/mmc/host/omap_hsmmc.c
@@ -27,6 +27,7 @@
#include <linux/timer.h>
#include <linux/clk.h>
#include <linux/mmc/host.h>
+#include <linux/mmc/core.h>
#include <linux/io.h>
#include <linux/semaphore.h>
#include <mach/dma.h>
@@ -113,7 +114,8 @@

/* Timeouts for entering power saving states on inactivity, msec */
#define OMAP_MMC_DISABLED_TIMEOUT 100
-#define OMAP_MMC_OFF_TIMEOUT 1000
+#define OMAP_MMC_SLEEP_TIMEOUT 1000
+#define OMAP_MMC_OFF_TIMEOUT 8000

/*
* One controller can have multiple slots, like on some omap boards using
@@ -1175,20 +1177,21 @@ static void omap_hsmmc_init(struct mmc_omap_host *host)

/*
* Dynamic power saving handling, FSM:
- * ENABLED -> DISABLED -> OFF / REGSLEEP
- * ^___________| |
- * |______________________|
+ * ENABLED -> DISABLED -> CARDSLEEP / REGSLEEP -> OFF
+ * ^___________| | |
+ * |______________________|______________________|
*
* ENABLED: mmc host is fully functional
* DISABLED: fclk is off
- * OFF: fclk is off,voltage regulator is off
- * REGSLEEP: fclk is off,voltage regulator is asleep
+ * CARDSLEEP: fclk is off, card is asleep, voltage regulator is asleep
+ * REGSLEEP: fclk is off, voltage regulator is asleep
+ * OFF: fclk is off, voltage regulator is off
*
* Transition handlers return the timeout for the next state transition
* or negative error.
*/

-enum {ENABLED = 0, DISABLED, REGSLEEP, OFF};
+enum {ENABLED = 0, DISABLED, CARDSLEEP, REGSLEEP, OFF};

/* Handler for [ENABLED -> DISABLED] transition */
static int omap_mmc_enabled_to_disabled(struct mmc_omap_host *host)
@@ -1202,46 +1205,72 @@ static int omap_mmc_enabled_to_disabled(struct mmc_omap_host *host)
if (host->power_mode == MMC_POWER_OFF)
return 0;

- return msecs_to_jiffies(OMAP_MMC_OFF_TIMEOUT);
+ return msecs_to_jiffies(OMAP_MMC_SLEEP_TIMEOUT);
}

-/* Handler for [DISABLED -> OFF] transition */
-static int omap_mmc_disabled_to_off(struct mmc_omap_host *host)
+/* Handler for [DISABLED -> REGSLEEP / CARDSLEEP] transition */
+static int omap_mmc_disabled_to_sleep(struct mmc_omap_host *host)
{
- int new_state;
-
- dev_dbg(mmc_dev(host->mmc), "DISABLED -> OFF\n");
+ int err, new_state;

if (!mmc_try_claim_host(host->mmc))
return 0;

clk_enable(host->fclk);
-
omap_mmc_restore_ctx(host);
+ if (mmc_card_can_sleep(host->mmc)) {
+ err = mmc_card_sleep(host->mmc);
+ if (err < 0) {
+ clk_disable(host->fclk);
+ mmc_release_host(host->mmc);
+ return err;
+ }
+ new_state = CARDSLEEP;
+ } else
+ new_state = REGSLEEP;
+ if (mmc_slot(host).set_sleep)
+ mmc_slot(host).set_sleep(host->dev, host->slot_id, 1, 0,
+ new_state == CARDSLEEP);
+ /* FIXME: turn off bus power and perhaps interrupts too */
+ clk_disable(host->fclk);
+ host->dpm_state = new_state;
+
+ mmc_release_host(host->mmc);
+
+ dev_dbg(mmc_dev(host->mmc), "DISABLED -> %s\n",
+ host->dpm_state == CARDSLEEP ? "CARDSLEEP" : "REGSLEEP");

if ((host->mmc->caps & MMC_CAP_NONREMOVABLE) ||
mmc_slot(host).card_detect ||
(mmc_slot(host).get_cover_state &&
- mmc_slot(host).get_cover_state(host->dev, host->slot_id))) {
- mmc_power_save_host(host->mmc);
- new_state = OFF;
- } else {
- if (mmc_slot(host).set_sleep)
- mmc_slot(host).set_sleep(host->dev, host->slot_id,
- 1, 0, 0);
- new_state = REGSLEEP;
+ mmc_slot(host).get_cover_state(host->dev, host->slot_id)))
+ return msecs_to_jiffies(OMAP_MMC_OFF_TIMEOUT);
+
+ return 0;
+}
+
+/* Handler for [REGSLEEP / CARDSLEEP -> OFF] transition */
+static int omap_mmc_sleep_to_off(struct mmc_omap_host *host)
+{
+ if (!mmc_try_claim_host(host->mmc))
+ return 0;
+
+ if (!((host->mmc->caps & MMC_CAP_NONREMOVABLE) ||
+ mmc_slot(host).card_detect ||
+ (mmc_slot(host).get_cover_state &&
+ mmc_slot(host).get_cover_state(host->dev, host->slot_id)))) {
+ mmc_release_host(host->mmc);
+ return 0;
}

- OMAP_HSMMC_WRITE(host->base, ISE, 0);
- OMAP_HSMMC_WRITE(host->base, IE, 0);
- OMAP_HSMMC_WRITE(host->base, HCTL,
- OMAP_HSMMC_READ(host->base, HCTL) & ~SDBP);
+ mmc_slot(host).set_power(host->dev, host->slot_id, 0, 0);
+ host->vdd = 0;
+ host->power_mode = MMC_POWER_OFF;

- clk_disable(host->fclk);
- clk_disable(host->iclk);
- clk_disable(host->dbclk);
+ dev_dbg(mmc_dev(host->mmc), "%s -> OFF\n",
+ host->dpm_state == CARDSLEEP ? "CARDSLEEP" : "REGSLEEP");

- host->dpm_state = new_state;
+ host->dpm_state = OFF;

mmc_release_host(host->mmc);

@@ -1266,62 +1295,43 @@ static int omap_mmc_disabled_to_enabled(struct mmc_omap_host *host)
return 0;
}

-/* Handler for [OFF -> ENABLED] transition */
-static int omap_mmc_off_to_enabled(struct mmc_omap_host *host)
+/* Handler for [SLEEP -> ENABLED] transition */
+static int omap_mmc_sleep_to_enabled(struct mmc_omap_host *host)
{
- clk_enable(host->fclk);
- clk_enable(host->iclk);
-
- if (clk_enable(host->dbclk))
- dev_dbg(mmc_dev(host->mmc),
- "Enabling debounce clk failed\n");
+ if (!mmc_try_claim_host(host->mmc))
+ return 0;

+ clk_enable(host->fclk);
omap_mmc_restore_ctx(host);
- omap_hsmmc_init(host);
- mmc_power_restore_host(host->mmc);
+ if (mmc_slot(host).set_sleep)
+ mmc_slot(host).set_sleep(host->dev, host->slot_id, 0,
+ host->vdd, host->dpm_state == CARDSLEEP);
+ if (mmc_card_can_sleep(host->mmc))
+ mmc_card_awake(host->mmc);
+
+ dev_dbg(mmc_dev(host->mmc), "%s -> ENABLED\n",
+ host->dpm_state == CARDSLEEP ? "CARDSLEEP" : "REGSLEEP");

host->dpm_state = ENABLED;

- dev_dbg(mmc_dev(host->mmc), "OFF -> ENABLED\n");
+ mmc_release_host(host->mmc);

return 0;
}

-/* Handler for [REGSLEEP -> ENABLED] transition */
-static int omap_mmc_regsleep_to_enabled(struct mmc_omap_host *host)
+/* Handler for [OFF -> ENABLED] transition */
+static int omap_mmc_off_to_enabled(struct mmc_omap_host *host)
{
- unsigned long timeout;
-
- dev_dbg(mmc_dev(host->mmc), "REGSLEEP -> ENABLED\n");
-
clk_enable(host->fclk);
- clk_enable(host->iclk);
-
- if (clk_enable(host->dbclk))
- dev_dbg(mmc_dev(host->mmc),
- "Enabling debounce clk failed\n");

omap_mmc_restore_ctx(host);
-
- /*
- * We turned off interrupts and bus power. Interrupts
- * are turned on by 'mmc_omap_start_command()' so we
- * just need to turn on the bus power here.
- */
- OMAP_HSMMC_WRITE(host->base, HCTL,
- OMAP_HSMMC_READ(host->base, HCTL) | SDBP);
-
- timeout = jiffies + msecs_to_jiffies(MMC_TIMEOUT_MS);
- while ((OMAP_HSMMC_READ(host->base, HCTL) & SDBP) != SDBP &&
- time_before(jiffies, timeout))
- ;
-
- if (mmc_slot(host).set_sleep)
- mmc_slot(host).set_sleep(host->dev, host->slot_id,
- 0, host->vdd, 0);
+ omap_hsmmc_init(host);
+ mmc_power_restore_host(host->mmc);

host->dpm_state = ENABLED;

+ dev_dbg(mmc_dev(host->mmc), "OFF -> ENABLED\n");
+
return 0;
}

@@ -1335,8 +1345,9 @@ static int omap_mmc_enable(struct mmc_host *mmc)
switch (host->dpm_state) {
case DISABLED:
return omap_mmc_disabled_to_enabled(host);
+ case CARDSLEEP:
case REGSLEEP:
- return omap_mmc_regsleep_to_enabled(host);
+ return omap_mmc_sleep_to_enabled(host);
case OFF:
return omap_mmc_off_to_enabled(host);
default:
@@ -1362,7 +1373,10 @@ static int omap_mmc_disable(struct mmc_host *mmc, int lazy)
return 0;
}
case DISABLED:
- return omap_mmc_disabled_to_off(host);
+ return omap_mmc_disabled_to_sleep(host);
+ case CARDSLEEP:
+ case REGSLEEP:
+ return omap_mmc_sleep_to_off(host);
default:
dev_dbg(mmc_dev(host->mmc), "UNKNOWN state\n");
return -EINVAL;
@@ -1434,8 +1448,7 @@ static int mmc_regs_show(struct seq_file *s, void *data)
host->dpm_state, mmc->nesting_cnt,
host->context_loss, context_loss);

- if (host->suspended || host->dpm_state == OFF ||
- host->dpm_state == REGSLEEP) {
+ if (host->suspended || host->dpm_state == OFF) {
seq_printf(s, "host suspended, can't read registers\n");
return 0;
}
@@ -1610,7 +1623,8 @@ static int __init omap_mmc_probe(struct platform_device *pdev)
mmc->max_req_size = mmc->max_blk_size * mmc->max_blk_count;
mmc->max_seg_size = mmc->max_req_size;

- mmc->caps |= MMC_CAP_MMC_HIGHSPEED | MMC_CAP_SD_HIGHSPEED;
+ mmc->caps |= MMC_CAP_MMC_HIGHSPEED | MMC_CAP_SD_HIGHSPEED |
+ MMC_CAP_WAIT_WHILE_BUSY;

if (pdata->slots[host->slot_id].wires >= 8)
mmc->caps |= MMC_CAP_8_BIT_DATA;
--
1.5.6.3


\
 
 \ /
  Last update: 2009-07-28 12:57    [from the cache]
©2003-2014 Jasper Spaans. Advertise on this site