AuxXxilium/linux_dsm_epyc7002
1
0
Fork 0
mirror of https://github.com/AuxXxilium/linux_dsm_epyc7002.git synced 2024-11-24 18:30:54 +07:00
Code Issues Actions Packages Projects Releases Wiki Activity

omap_hsmmc: add mmc card sleep and awake support

Browse Source 
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>
Acked-by: Matt Fleming <matt@console-pimps.org>
Cc: Ian Molton <ian@mnementh.co.uk>
Cc: "Roberto A. Foglietta" <roberto.foglietta@gmail.com>
Cc: Jarkko Lavinen <jarkko.lavinen@nokia.com>
Cc: Denis Karpov <ext-denis.2.karpov@nokia.com>
Cc: Pierre Ossman <pierre@ossman.eu>
Cc: Philip Langdale <philipl@overt.org>
Cc: "Madhusudhan" <madhu.cr@ti.com>
Cc: <linux-mmc@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Jarkko Lavinen 2009-09-22 16:44:53 -07:00 committed by Linus Torvalds
parent 623821f71b
commit 13189e78ca
1 changed files with 92 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

170
drivers/mmc/host/omap_hsmmc.c
View File

@ -27,6 +27,7 @@
#include <linux/timer.h> #include <linux/timer.h>
#include <linux/clk.h> #include <linux/clk.h>
#include <linux/mmc/host.h> #include <linux/mmc/host.h>
#include <linux/mmc/core.h>
#include <linux/io.h> #include <linux/io.h>
#include <linux/semaphore.h> #include <linux/semaphore.h>
#include <mach/dma.h> #include <mach/dma.h>
@ -115,7 +116,8 @@
/* Timeouts for entering power saving states on inactivity, msec */ /* Timeouts for entering power saving states on inactivity, msec */
#define OMAP_MMC_DISABLED_TIMEOUT 100 #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 * One controller can have multiple slots, like on some omap boards using
@ -1182,20 +1184,21 @@ static void omap_hsmmc_init(struct mmc_omap_host *host)
/* /*
* Dynamic power saving handling, FSM: * Dynamic power saving handling, FSM:
* ENABLED -> DISABLED -> OFF / REGSLEEP * ENABLED -> DISABLED -> CARDSLEEP / REGSLEEP -> OFF
* ^___________| | * ^___________| | |
* |______________________| * |______________________|______________________|
* *
* ENABLED: mmc host is fully functional * ENABLED: mmc host is fully functional
* DISABLED: fclk is off * DISABLED: fclk is off
* OFF: fclk is off,voltage regulator is off * CARDSLEEP: fclk is off, card is asleep, voltage regulator is asleep
* REGSLEEP: fclk is off,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 * Transition handlers return the timeout for the next state transition
* or negative error. * or negative error.
*/ */
enum {ENABLED = 0, DISABLED, REGSLEEP, OFF}; enum {ENABLED = 0, DISABLED, CARDSLEEP, REGSLEEP, OFF};
/* Handler for [ENABLED -> DISABLED] transition */ /* Handler for [ENABLED -> DISABLED] transition */
static int omap_mmc_enabled_to_disabled(struct mmc_omap_host *host) static int omap_mmc_enabled_to_disabled(struct mmc_omap_host *host)
@ -1209,46 +1212,72 @@ static int omap_mmc_enabled_to_disabled(struct mmc_omap_host *host)
if (host->power_mode == MMC_POWER_OFF) if (host->power_mode == MMC_POWER_OFF)
return 0; return 0;
return msecs_to_jiffies(OMAP_MMC_OFF_TIMEOUT); return msecs_to_jiffies(OMAP_MMC_SLEEP_TIMEOUT);
} }
/* Handler for [DISABLED -> OFF] transition */ /* Handler for [DISABLED -> REGSLEEP / CARDSLEEP] transition */
static int omap_mmc_disabled_to_off(struct mmc_omap_host *host) static int omap_mmc_disabled_to_sleep(struct mmc_omap_host *host)
{ {
int new_state; int err, new_state;
dev_dbg(mmc_dev(host->mmc), "DISABLED -> OFF\n");
if (!mmc_try_claim_host(host->mmc)) if (!mmc_try_claim_host(host->mmc))
return 0; return 0;
clk_enable(host->fclk); clk_enable(host->fclk);
omap_mmc_restore_ctx(host); 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) || if ((host->mmc->caps & MMC_CAP_NONREMOVABLE) ||
mmc_slot(host).card_detect || mmc_slot(host).card_detect ||
(mmc_slot(host).get_cover_state && (mmc_slot(host).get_cover_state &&
mmc_slot(host).get_cover_state(host->dev, host->slot_id))) { mmc_slot(host).get_cover_state(host->dev, host->slot_id)))
mmc_power_save_host(host->mmc); return msecs_to_jiffies(OMAP_MMC_OFF_TIMEOUT);
new_state = OFF;
} else { return 0;
if (mmc_slot(host).set_sleep) }
mmc_slot(host).set_sleep(host->dev, host->slot_id,
1, 0, 0); /* Handler for [REGSLEEP / CARDSLEEP -> OFF] transition */
new_state = REGSLEEP; 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); mmc_slot(host).set_power(host->dev, host->slot_id, 0, 0);
OMAP_HSMMC_WRITE(host->base, IE, 0); host->vdd = 0;
OMAP_HSMMC_WRITE(host->base, HCTL, host->power_mode = MMC_POWER_OFF;
OMAP_HSMMC_READ(host->base, HCTL) & ~SDBP);
clk_disable(host->fclk); dev_dbg(mmc_dev(host->mmc), "%s -> OFF\n",
clk_disable(host->iclk); host->dpm_state == CARDSLEEP ? "CARDSLEEP" : "REGSLEEP");
clk_disable(host->dbclk);
host->dpm_state = new_state; host->dpm_state = OFF;
mmc_release_host(host->mmc); mmc_release_host(host->mmc);
@ -1273,15 +1302,34 @@ static int omap_mmc_disabled_to_enabled(struct mmc_omap_host *host)
return 0; return 0;
} }
/* Handler for [SLEEP -> ENABLED] transition */
static int omap_mmc_sleep_to_enabled(struct mmc_omap_host *host)
{
if (!mmc_try_claim_host(host->mmc))
return 0;
clk_enable(host->fclk);
omap_mmc_restore_ctx(host);
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;
mmc_release_host(host->mmc);
return 0;
}
/* Handler for [OFF -> ENABLED] transition */ /* Handler for [OFF -> ENABLED] transition */
static int omap_mmc_off_to_enabled(struct mmc_omap_host *host) static int omap_mmc_off_to_enabled(struct mmc_omap_host *host)
{ {
clk_enable(host->fclk); 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); omap_mmc_restore_ctx(host);
omap_hsmmc_init(host); omap_hsmmc_init(host);
@ -1294,44 +1342,6 @@ static int omap_mmc_off_to_enabled(struct mmc_omap_host *host)
return 0; return 0;
} }
/* Handler for [REGSLEEP -> ENABLED] transition */
static int omap_mmc_regsleep_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);
host->dpm_state = ENABLED;
return 0;
}
/* /*
* Bring MMC host to ENABLED from any other PM state. * Bring MMC host to ENABLED from any other PM state.
*/ */
@ -1342,8 +1352,9 @@ static int omap_mmc_enable(struct mmc_host *mmc)
switch (host->dpm_state) { switch (host->dpm_state) {
case DISABLED: case DISABLED:
return omap_mmc_disabled_to_enabled(host); return omap_mmc_disabled_to_enabled(host);
case CARDSLEEP:
case REGSLEEP: case REGSLEEP:
return omap_mmc_regsleep_to_enabled(host); return omap_mmc_sleep_to_enabled(host);
case OFF: case OFF:
return omap_mmc_off_to_enabled(host); return omap_mmc_off_to_enabled(host);
default: default:
@ -1369,7 +1380,10 @@ static int omap_mmc_disable(struct mmc_host *mmc, int lazy)
return 0; return 0;
} }
case DISABLED: 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: default:
dev_dbg(mmc_dev(host->mmc), "UNKNOWN state\n"); dev_dbg(mmc_dev(host->mmc), "UNKNOWN state\n");
return -EINVAL; return -EINVAL;
@ -1441,8 +1455,7 @@ static int mmc_regs_show(struct seq_file *s, void *data)
host->dpm_state, mmc->nesting_cnt, host->dpm_state, mmc->nesting_cnt,
host->context_loss, context_loss); host->context_loss, context_loss);
if (host->suspended || host->dpm_state == OFF || if (host->suspended || host->dpm_state == OFF) {
host->dpm_state == REGSLEEP) {
seq_printf(s, "host suspended, can't read registers\n"); seq_printf(s, "host suspended, can't read registers\n");
return 0; return 0;
} }
@ -1617,7 +1630,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_req_size = mmc->max_blk_size * mmc->max_blk_count;
mmc->max_seg_size = mmc->max_req_size; 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) if (pdata->slots[host->slot_id].wires >= 8)
mmc->caps |= MMC_CAP_8_BIT_DATA; mmc->caps |= MMC_CAP_8_BIT_DATA;