int bcmsdh_sdmmc_set_power(int on)
{
static struct sdio_func *sdio_func;
struct sdhci_host *host;
if (gfunc) {
sdio_func = gfunc;
host = (struct sdhci_host *)sdio_func->card->host;
if (on)
mmc_power_restore_host(sdio_func->card->host);
else
mmc_power_save_host(sdio_func->card->host);
}
return 0;
}
static int wl1271_sdio_power_on(struct wl1271 *wl)
{
struct sdio_func *func = wl_to_func(wl);
int ret;
/* Make sure the card will not be powered off by runtime PM */
ret = pm_runtime_get_sync(&func->dev);
if (ret < 0)
goto out;
/* Runtime PM might be disabled, so power up the card manually */
ret = mmc_power_restore_host(func->card->host);
if (ret < 0)
goto out;
sdio_claim_host(func);
sdio_enable_func(func);
out:
return ret;
}
static int sdhci_kona_off_to_enabled(struct sdio_dev *dev)
{
/* TODO:
* Once clk mgmt is introduced we need to turn ON the clocks here too
*/
/* Note that the sequence triggered by mmc_power_restore_host changes
* the regulator voltage setting etc. But the regulator should be
* enabled in first place.
*/
sdhci_kona_sdio_regulator_power(dev, 1);
/*
* This is key, we are calling mmc_power_restore_host, which if needed
* would re-trigger the protocol handshake with the card.
*/
if ((dev->devtype == SDIO_DEV_TYPE_SDMMC) && (dev->suspended != 1))
mmc_power_restore_host(dev->host->mmc);
dev->dpm_state = ENABLED;
pr_info("OFF --> Enabled \r\n");
return 0;
}
static int wl1271_sdio_power_on(struct wl1271 *wl)
{
struct sdio_func *func = wl_to_func(wl);
int ret;
printk("%s: function entered \n", __FUNCTION__);
#if 1
/* Make sure the card will not be powered off by runtime PM */
#if 0 // Added Michael Carrier
printk("%s: Calling pm_runtime_get_sync\n", __FUNCTION__);
ret = pm_runtime_get_sync(&func->dev);
printk("%s: pm_runtime_get_sync returned %d\n", __FUNCTION__, ret);
if (ret < 0)
goto out;
/* Runtime PM might be disabled, so power up the card manually */
#endif
printk("%s: Calling mmc_power_restore_host\n", __FUNCTION__);
ret = mmc_power_restore_host(func->card->host);
printk("%s: mmc_power_restore_host() returned %d\n", __FUNCTION__, ret);
if (ret < 0)
goto out;
#else
//wl1271_setpower(1);
#endif
/* if the power is already on (WHY?) ret == 1 */
ret = 0;
sdio_claim_host(func);
sdio_enable_func(func);
/* Set the default block size in case it was modified */
sdio_set_block_size(func, 0);
out:
return ret;
}
/**
* 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)
{
int ret;
DECLARE_COMPLETION_ONSTACK(complete);
mrq->done_data = &complete;
mrq->done = mmc_wait_done;
mmc_start_request(host, mrq);
if (!wait_for_completion_timeout(&complete,
msecs_to_jiffies(10000))) {
host->ops->dump_regs(host);
dump_mmc_ios(host);
#ifdef MMC_HOST_DEBUGGING
extern void dump(void);
dump();
#endif
if (host->ops->abort_request) {
/* Power off */
ret = mmc_power_save_host(host);
if (ret)
pr_err("%s: mmc_power_save_host : error %d\n",
mmc_hostname(host), ret);
/* Reset host */
host->ops->abort_request(host);
/* Reinitialize the host and card */
ret = mmc_power_restore_host(host);
if (ret)
pr_err("%s: mmc_power_restore_host : error %d\n",
mmc_hostname(host), ret);
} else {
printk(KERN_ERR"[MMC]Timeout Timer Handler Error\n");
}
}
}
static int wl1271_sdio_power_on(struct wl1271 *wl)
{
struct sdio_func *func = wl_to_func(wl);
int ret;
/* If enabled, tell runtime PM not to power off the card */
if (pm_runtime_enabled(&func->dev)) {
ret = pm_runtime_get_sync(&func->dev);
if (ret < 0)
goto out;
} else {
/* Runtime PM is disabled: power up the card manually */
ret = mmc_power_restore_host(func->card->host);
if (ret < 0)
goto out;
}
sdio_claim_host(func);
sdio_enable_func(func);
out:
return ret;
}
static int mmc_runtime_resume(struct device *dev)
{
struct mmc_card *card = mmc_dev_to_card(dev);
return mmc_power_restore_host(card->host);
}