Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 7a8c2cef authored by Balaji T K's avatar Balaji T K Committed by Chris Ball
Browse files

mmc: omap_hsmmc: Remove lazy_disable 



lazy_disable framework in OMAP HSMMC manages multiple low power states and
card is powered off after inactivity time of 8 seconds.  Based on previous
discussion on the list, card power (regulator) handling (when to power
OFF/ON) should ideally be handled by core layer.  Remove usage of lazy
disable to allow core layer _only_ to handle card power.  With the removal
of lazy disable framework, MMC regulators are left ON until MMC_POWER_OFF
via set_ios.

Signed-off-by: default avatarBalaji T K <balajitk@ti.com>
Signed-off-by: default avatarChris Ball <cjb@laptop.org>
parent ca8e99b3

drivers/mmc/host/omap_hsmmc.c

+2 −244
Original line number Original line Diff line number Diff line
@@ -120,11 +120,6 @@ 
#define OMAP_MMC_MASTER_CLOCK	96000000

#define OMAP_MMC_MASTER_CLOCK	96000000

#define DRIVER_NAME		"omap_hsmmc"

#define DRIVER_NAME		"omap_hsmmc"





/* Timeouts for entering power saving states on inactivity, msec */

#define OMAP_MMC_DISABLED_TIMEOUT	100

#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

 * omap.c controller driver. Luckily this is not currently done on any known

 * omap.c controller driver. Luckily this is not currently done on any known
@@ -1707,8 +1702,6 @@ static void omap_hsmmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios) 




	if (host->power_mode == MMC_POWER_OFF)

	if (host->power_mode == MMC_POWER_OFF)

		mmc_host_disable(host->mmc);

		mmc_host_disable(host->mmc);

	else

		mmc_host_lazy_disable(host->mmc);

}

}





static int omap_hsmmc_get_cd(struct mmc_host *mmc)

static int omap_hsmmc_get_cd(struct mmc_host *mmc)
@@ -1764,220 +1757,6 @@ static void omap_hsmmc_conf_bus_power(struct omap_hsmmc_host *host) 
	set_sd_bus_power(host);

	set_sd_bus_power(host);

}

}





/*

 * Dynamic power saving handling, FSM:

 *   ENABLED -> DISABLED -> CARDSLEEP / REGSLEEP -> OFF

 *     ^___________|          |                      |

 *     |______________________|______________________|

 *

 * ENABLED:   mmc host is fully functional

 * DISABLED:  fclk is off

 * 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, CARDSLEEP, REGSLEEP, OFF};



/* Handler for [ENABLED -> DISABLED] transition */

static int omap_hsmmc_enabled_to_disabled(struct omap_hsmmc_host *host)

{

	omap_hsmmc_context_save(host);

	clk_disable(host->fclk);

	host->dpm_state = DISABLED;



	dev_dbg(mmc_dev(host->mmc), "ENABLED -> DISABLED\n");



	if (host->power_mode == MMC_POWER_OFF)

		return 0;



	return OMAP_MMC_SLEEP_TIMEOUT;

}



/* Handler for [DISABLED -> REGSLEEP / CARDSLEEP] transition */

static int omap_hsmmc_disabled_to_sleep(struct omap_hsmmc_host *host)

{

	int err, new_state;



	if (!mmc_try_claim_host(host->mmc))

		return 0;



	clk_enable(host->fclk);

	omap_hsmmc_context_restore(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 (mmc_slot(host).no_off)

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

		return OMAP_MMC_OFF_TIMEOUT;



	return 0;

}



/* Handler for [REGSLEEP / CARDSLEEP -> OFF] transition */

static int omap_hsmmc_sleep_to_off(struct omap_hsmmc_host *host)

{

	if (!mmc_try_claim_host(host->mmc))

		return 0;



	if (mmc_slot(host).no_off)

		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;

	}



	mmc_slot(host).set_power(host->dev, host->slot_id, 0, 0);

	host->vdd = 0;

	host->power_mode = MMC_POWER_OFF;



	dev_dbg(mmc_dev(host->mmc), "%s -> OFF\n",

		host->dpm_state == CARDSLEEP ? "CARDSLEEP" : "REGSLEEP");



	host->dpm_state = OFF;



	mmc_release_host(host->mmc);



	return 0;

}



/* Handler for [DISABLED -> ENABLED] transition */

static int omap_hsmmc_disabled_to_enabled(struct omap_hsmmc_host *host)

{

	int err;



	err = clk_enable(host->fclk);

	if (err < 0)

		return err;



	omap_hsmmc_context_restore(host);

	host->dpm_state = ENABLED;



	dev_dbg(mmc_dev(host->mmc), "DISABLED -> ENABLED\n");



	return 0;

}



/* Handler for [SLEEP -> ENABLED] transition */

static int omap_hsmmc_sleep_to_enabled(struct omap_hsmmc_host *host)

{

	if (!mmc_try_claim_host(host->mmc))

		return 0;



	clk_enable(host->fclk);

	omap_hsmmc_context_restore(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 */

static int omap_hsmmc_off_to_enabled(struct omap_hsmmc_host *host)

{

	clk_enable(host->fclk);



	omap_hsmmc_context_restore(host);

	omap_hsmmc_conf_bus_power(host);

	mmc_power_restore_host(host->mmc);



	host->dpm_state = ENABLED;



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



	return 0;

}



/*

 * Bring MMC host to ENABLED from any other PM state.

 */

static int omap_hsmmc_enable(struct mmc_host *mmc)

{

	struct omap_hsmmc_host *host = mmc_priv(mmc);



	switch (host->dpm_state) {

	case DISABLED:

		return omap_hsmmc_disabled_to_enabled(host);

	case CARDSLEEP:

	case REGSLEEP:

		return omap_hsmmc_sleep_to_enabled(host);

	case OFF:

		return omap_hsmmc_off_to_enabled(host);

	default:

		dev_dbg(mmc_dev(host->mmc), "UNKNOWN state\n");

		return -EINVAL;

	}

}



/*

 * Bring MMC host in PM state (one level deeper).

 */

static int omap_hsmmc_disable(struct mmc_host *mmc, int lazy)

{

	struct omap_hsmmc_host *host = mmc_priv(mmc);



	switch (host->dpm_state) {

	case ENABLED: {

		int delay;



		delay = omap_hsmmc_enabled_to_disabled(host);

		if (lazy || delay < 0)

			return delay;

		return 0;

	}

	case DISABLED:

		return omap_hsmmc_disabled_to_sleep(host);

	case CARDSLEEP:

	case REGSLEEP:

		return omap_hsmmc_sleep_to_off(host);

	default:

		dev_dbg(mmc_dev(host->mmc), "UNKNOWN state\n");

		return -EINVAL;

	}

}



static int omap_hsmmc_enable_fclk(struct mmc_host *mmc)

static int omap_hsmmc_enable_fclk(struct mmc_host *mmc)

{

{

	struct omap_hsmmc_host *host = mmc_priv(mmc);

	struct omap_hsmmc_host *host = mmc_priv(mmc);
@@ -2014,17 +1793,6 @@ static const struct mmc_host_ops omap_hsmmc_ops = { 
	/* NYET -- enable_sdio_irq */

	/* NYET -- enable_sdio_irq */

};

};





static const struct mmc_host_ops omap_hsmmc_ps_ops = {

	.enable = omap_hsmmc_enable,

	.disable = omap_hsmmc_disable,

	.request = omap_hsmmc_request,

	.set_ios = omap_hsmmc_set_ios,

	.get_cd = omap_hsmmc_get_cd,

	.get_ro = omap_hsmmc_get_ro,

	.init_card = omap_hsmmc_init_card,

	/* NYET -- enable_sdio_irq */

};



#ifdef CONFIG_DEBUG_FS

#ifdef CONFIG_DEBUG_FS





static int omap_hsmmc_regs_show(struct seq_file *s, void *data)

static int omap_hsmmc_regs_show(struct seq_file *s, void *data)
@@ -2046,7 +1814,7 @@ static int omap_hsmmc_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) {

		seq_printf(s, "host suspended, can't read registers\n");

		seq_printf(s, "host suspended, can't read registers\n");

		return 0;

		return 0;

	}

	}
@@ -2160,9 +1928,6 @@ static int __init omap_hsmmc_probe(struct platform_device *pdev) 
	platform_set_drvdata(pdev, host);

	platform_set_drvdata(pdev, host);

	INIT_WORK(&host->mmc_carddetect_work, omap_hsmmc_detect);

	INIT_WORK(&host->mmc_carddetect_work, omap_hsmmc_detect);





	if (mmc_slot(host).power_saving)

		mmc->ops	= &omap_hsmmc_ps_ops;

	else

	mmc->ops	= &omap_hsmmc_ops;

	mmc->ops	= &omap_hsmmc_ops;





	/*

	/*
@@ -2194,9 +1959,6 @@ static int __init omap_hsmmc_probe(struct platform_device *pdev) 
	omap_hsmmc_context_save(host);

	omap_hsmmc_context_save(host);





	mmc->caps |= MMC_CAP_DISABLE;

	mmc->caps |= MMC_CAP_DISABLE;

	mmc_set_disable_delay(mmc, OMAP_MMC_DISABLED_TIMEOUT);

	/* we start off in DISABLED state */

	host->dpm_state = DISABLED;





	if (clk_enable(host->iclk) != 0) {

	if (clk_enable(host->iclk) != 0) {

		clk_put(host->iclk);

		clk_put(host->iclk);
@@ -2319,8 +2081,6 @@ static int __init omap_hsmmc_probe(struct platform_device *pdev) 




	omap_hsmmc_disable_irq(host);

	omap_hsmmc_disable_irq(host);





	mmc_host_lazy_disable(host->mmc);



	omap_hsmmc_protect_card(host);

	omap_hsmmc_protect_card(host);





	mmc_add_host(mmc);

	mmc_add_host(mmc);
@@ -2499,8 +2259,6 @@ static int omap_hsmmc_resume(struct device *dev) 
		ret = mmc_resume_host(host->mmc);

		ret = mmc_resume_host(host->mmc);

		if (ret == 0)

		if (ret == 0)

			host->suspended = 0;

			host->suspended = 0;



		mmc_host_lazy_disable(host->mmc);

	}

	}





	return ret;

	return ret;