static int tegra30_ahub_suspend(struct device *dev) { regcache_mark_dirty(ahub->regmap_ahub); regcache_mark_dirty(ahub->regmap_apbif); return 0; }
static int ak4613_resume(struct snd_soc_codec *codec) { struct regmap *regmap = dev_get_regmap(codec->dev, NULL); regcache_mark_dirty(regmap); return regcache_sync(regmap); }
static int adau1977_power_disable(struct adau1977 *adau1977) { int ret = 0; if (!adau1977->enabled) return 0; ret = regmap_update_bits(adau1977->regmap, ADAU1977_REG_POWER, ADAU1977_POWER_PWUP, 0); if (ret) return ret; regcache_mark_dirty(adau1977->regmap); if (adau1977->reset_gpio) gpiod_set_value_cansleep(adau1977->reset_gpio, 0); regcache_cache_only(adau1977->regmap, true); regulator_disable(adau1977->avdd_reg); if (adau1977->dvdd_reg) regulator_disable(adau1977->dvdd_reg); adau1977->enabled = false; return 0; }
static int es8328_resume(struct snd_soc_codec *codec) { struct regmap *regmap = dev_get_regmap(codec->dev, NULL); struct es8328_priv *es8328; int ret; es8328 = snd_soc_codec_get_drvdata(codec); ret = clk_prepare_enable(es8328->clk); if (ret) { dev_err(codec->dev, "unable to enable clock\n"); return ret; } ret = regulator_bulk_enable(ARRAY_SIZE(es8328->supplies), es8328->supplies); if (ret) { dev_err(codec->dev, "unable to enable regulators\n"); return ret; } regcache_mark_dirty(regmap); ret = regcache_sync(regmap); if (ret) { dev_err(codec->dev, "unable to sync regcache\n"); return ret; } return 0; }
static int uda134x_set_bias_level(struct snd_soc_codec *codec, enum snd_soc_bias_level level) { struct uda134x_priv *uda134x = snd_soc_codec_get_drvdata(codec); struct uda134x_platform_data *pd = uda134x->pd; pr_debug("%s bias level %d\n", __func__, level); switch (level) { case SND_SOC_BIAS_ON: break; case SND_SOC_BIAS_PREPARE: /* power on */ if (pd->power) { pd->power(1); regcache_sync(uda134x->regmap); } break; case SND_SOC_BIAS_STANDBY: break; case SND_SOC_BIAS_OFF: /* power off */ if (pd->power) { pd->power(0); regcache_mark_dirty(uda134x->regmap); } break; } return 0; }
static int mt8183_afe_runtime_suspend(struct device *dev) { struct mtk_base_afe *afe = dev_get_drvdata(dev); struct mt8183_afe_private *afe_priv = afe->platform_priv; unsigned int value; int ret; if (!afe->regmap || afe_priv->pm_runtime_bypass_reg_ctl) goto skip_regmap; /* disable AFE */ regmap_update_bits(afe->regmap, AFE_DAC_CON0, AFE_ON_MASK_SFT, 0x0); ret = regmap_read_poll_timeout(afe->regmap, AFE_DAC_MON, value, (value & AFE_ON_RETM_MASK_SFT) == 0, 20, 1 * 1000 * 1000); if (ret) dev_warn(afe->dev, "%s(), ret %d\n", __func__, ret); /* make sure all irq status are cleared, twice intended */ regmap_update_bits(afe->regmap, AFE_IRQ_MCU_CLR, 0xffff, 0xffff); regmap_update_bits(afe->regmap, AFE_IRQ_MCU_CLR, 0xffff, 0xffff); /* cache only */ regcache_cache_only(afe->regmap, true); regcache_mark_dirty(afe->regmap); skip_regmap: return mt8183_afe_disable_clock(afe); }
static int arizona_runtime_suspend(struct device *dev) { struct arizona *arizona = dev_get_drvdata(dev); int ret; dev_dbg(arizona->dev, "Entering AoD mode\n"); if (arizona->external_dcvdd) { ret = regmap_update_bits(arizona->regmap, ARIZONA_ISOLATION_CONTROL, ARIZONA_ISOLATE_DCVDD1, ARIZONA_ISOLATE_DCVDD1); if (ret != 0) { dev_err(arizona->dev, "Failed to isolate DCVDD: %d\n", ret); return ret; } } regcache_cache_only(arizona->regmap, true); regcache_mark_dirty(arizona->regmap); regulator_disable(arizona->dcvdd); return 0; }
static int ak4642_suspend(struct snd_soc_component *component) { struct regmap *regmap = dev_get_regmap(component->dev, NULL); regcache_cache_only(regmap, true); regcache_mark_dirty(regmap); return 0; }
static int ak4613_suspend(struct snd_soc_codec *codec) { struct regmap *regmap = dev_get_regmap(codec->dev, NULL); regcache_cache_only(regmap, true); regcache_mark_dirty(regmap); return 0; }
static int wm8988_suspend(struct snd_soc_codec *codec) { struct wm8988_priv *wm8988 = snd_soc_codec_get_drvdata(codec); wm8988_set_bias_level(codec, SND_SOC_BIAS_OFF); regcache_mark_dirty(wm8988->regmap); return 0; }
static int max98373_suspend(struct device *dev) { struct max98373_priv *max98373 = dev_get_drvdata(dev); regcache_cache_only(max98373->regmap, true); regcache_mark_dirty(max98373->regmap); return 0; }
static int tegra30_i2s_suspend(struct device *dev) { struct tegra30_i2s *i2s = dev_get_drvdata(dev); regcache_mark_dirty(i2s->regmap); return 0; }
static int stm32_i2s_suspend(struct device *dev) { struct stm32_i2s_data *i2s = dev_get_drvdata(dev); regcache_cache_only(i2s->regmap, true); regcache_mark_dirty(i2s->regmap); return 0; }
static int rt5616_suspend(struct snd_soc_codec *codec) { struct rt5616_priv *rt5616 = snd_soc_codec_get_drvdata(codec); regcache_cache_only(rt5616->regmap, true); regcache_mark_dirty(rt5616->regmap); return 0; }
static int fsl_asrc_suspend(struct device *dev) { struct fsl_asrc *asrc_priv = dev_get_drvdata(dev); regcache_cache_only(asrc_priv->regmap, true); regcache_mark_dirty(asrc_priv->regmap); return 0; }
static int fsl_esai_suspend(struct device *dev) { struct fsl_esai *esai = dev_get_drvdata(dev); regcache_cache_only(esai->regmap, true); regcache_mark_dirty(esai->regmap); return 0; }
/* *Here is ESAI underrun reset step: *1. Read "TUE" and got TUE=1 *2. stop DMA. *3. stop ESAI TX section. *4. Set the transmitter section individual reset "TPR=1" *5. Reset the ESAI Transmit FIFO (set ESAI_TFCR[1]=1). *6. Config the control registers ESAI_TCCR and ESAI_TCR.config the Transmit FIFO register. *7. clear "TPR" *8. read "TUE" *9. Prefill ESAI TX FIFO. *10.Start DMA. *11 Enable the ESAI */ static void fsl_esai_reset(struct snd_pcm_substream *substream, bool stop) { struct snd_soc_pcm_runtime *rtd = substream->private_data; struct snd_soc_dai *cpu_dai = rtd->cpu_dai; struct fsl_esai *esai_priv = snd_soc_dai_get_drvdata(cpu_dai); u32 saisr; if (stop) { stop_lock_stream(esai_priv->substream[0]); stop_lock_stream(esai_priv->substream[1]); } regmap_update_bits(esai_priv->regmap, REG_ESAI_ECR, ESAI_ECR_ESAIEN_MASK | ESAI_ECR_ERST_MASK, ESAI_ECR_ESAIEN | ESAI_ECR_ERST); regmap_update_bits(esai_priv->regmap, REG_ESAI_ECR, ESAI_ECR_ESAIEN_MASK | ESAI_ECR_ERST_MASK, ESAI_ECR_ESAIEN); regmap_update_bits(esai_priv->regmap, REG_ESAI_TCR, ESAI_xCR_xPR_MASK, ESAI_xCR_xPR); regmap_update_bits(esai_priv->regmap, REG_ESAI_RCR, ESAI_xCR_xPR_MASK, ESAI_xCR_xPR); regmap_update_bits(esai_priv->regmap, REG_ESAI_PRRC, ESAI_PRRC_PDC_MASK, 0); regmap_update_bits(esai_priv->regmap, REG_ESAI_PCRC, ESAI_PCRC_PC_MASK, 0); /* * Add fifo reset here, because the regcache_sync will write one more data to ETDR. * Which will cause channel shift. */ regmap_update_bits(esai_priv->regmap, REG_ESAI_TFCR, ESAI_xFCR_xFR_MASK, ESAI_xFCR_xFR); regmap_update_bits(esai_priv->regmap, REG_ESAI_RFCR, ESAI_xFCR_xFR_MASK, ESAI_xFCR_xFR); regcache_mark_dirty(esai_priv->regmap); regcache_sync(esai_priv->regmap); regmap_update_bits(esai_priv->regmap, REG_ESAI_TFCR, ESAI_xFCR_xFR_MASK, 0); regmap_update_bits(esai_priv->regmap, REG_ESAI_RFCR, ESAI_xFCR_xFR_MASK, 0); regmap_update_bits(esai_priv->regmap, REG_ESAI_TCR, ESAI_xCR_xPR_MASK, 0); regmap_update_bits(esai_priv->regmap, REG_ESAI_RCR, ESAI_xCR_xPR_MASK, 0); regmap_update_bits(esai_priv->regmap, REG_ESAI_PRRC, ESAI_PRRC_PDC_MASK, ESAI_PRRC_PDC(ESAI_GPIO)); regmap_update_bits(esai_priv->regmap, REG_ESAI_PCRC, ESAI_PCRC_PC_MASK, ESAI_PCRC_PC(ESAI_GPIO)); regmap_read(esai_priv->regmap, REG_ESAI_SAISR, &saisr); if (stop) { start_unlock_stream(esai_priv->substream[1]); start_unlock_stream(esai_priv->substream[0]); } }
static int __maybe_unused ak5558_runtime_resume(struct device *dev) { struct ak5558_priv *ak5558 = dev_get_drvdata(dev); ak5558_power_off(ak5558); ak5558_power_on(ak5558); regcache_cache_only(ak5558->regmap, false); regcache_mark_dirty(ak5558->regmap); return regcache_sync(ak5558->regmap); }
static int sun8i_codec_runtime_suspend(struct device *dev) { struct sun8i_codec *scodec = dev_get_drvdata(dev); regcache_cache_only(scodec->regmap, true); regcache_mark_dirty(scodec->regmap); clk_disable_unprepare(scodec->clk_module); clk_disable_unprepare(scodec->clk_bus); return 0; }
static int arizona_runtime_suspend(struct device *dev) { struct arizona *arizona = dev_get_drvdata(dev); dev_dbg(arizona->dev, "Entering AoD mode\n"); regulator_disable(arizona->dcvdd); regcache_cache_only(arizona->regmap, true); regcache_mark_dirty(arizona->regmap); return 0; }
static int arizona_runtime_suspend(struct device *dev) { struct arizona *arizona = dev_get_drvdata(dev); if (arizona->pdata.ldoena) { gpio_set_value_cansleep(arizona->pdata.ldoena, 0); regcache_cache_only(arizona->regmap, true); regcache_mark_dirty(arizona->regmap); } return 0; }
static int cs4271_codec_remove(struct snd_soc_codec *codec) { struct cs4271_private *cs4271 = snd_soc_codec_get_drvdata(codec); if (gpio_is_valid(cs4271->gpio_nreset)) /* Set codec to the reset state */ gpio_set_value(cs4271->gpio_nreset, 0); regcache_mark_dirty(cs4271->regmap); regulator_bulk_disable(ARRAY_SIZE(cs4271->supplies), cs4271->supplies); return 0; };
static int __maybe_unused cs35l34_runtime_suspend(struct device *dev) { struct cs35l34_private *cs35l34 = dev_get_drvdata(dev); regcache_cache_only(cs35l34->regmap, true); regcache_mark_dirty(cs35l34->regmap); gpiod_set_value_cansleep(cs35l34->reset_gpio, 0); regulator_bulk_disable(cs35l34->num_core_supplies, cs35l34->core_supplies); return 0; }
static int fsl_dcu_drm_pm_suspend(struct device *dev) { struct fsl_dcu_drm_device *fsl_dev = dev_get_drvdata(dev); if (!fsl_dev) return 0; drm_kms_helper_poll_disable(fsl_dev->drm); regcache_cache_only(fsl_dev->regmap, true); regcache_mark_dirty(fsl_dev->regmap); clk_disable(fsl_dev->clk); clk_unprepare(fsl_dev->clk); return 0; }
static int tas5720_suspend(struct snd_soc_codec *codec) { struct tas5720_data *tas5720 = snd_soc_codec_get_drvdata(codec); int ret; regcache_cache_only(tas5720->regmap, true); regcache_mark_dirty(tas5720->regmap); ret = regulator_bulk_disable(ARRAY_SIZE(tas5720->supplies), tas5720->supplies); if (ret < 0) dev_err(codec->dev, "failed to disable supplies: %d\n", ret); return ret; }
static int jz4740_codec_set_bias_level(struct snd_soc_codec *codec, enum snd_soc_bias_level level) { struct jz4740_codec *jz4740_codec = snd_soc_codec_get_drvdata(codec); struct regmap *regmap = jz4740_codec->regmap; unsigned int mask; unsigned int value; switch (level) { case SND_SOC_BIAS_ON: break; case SND_SOC_BIAS_PREPARE: mask = JZ4740_CODEC_1_VREF_DISABLE | JZ4740_CODEC_1_VREF_AMP_DISABLE | JZ4740_CODEC_1_HEADPHONE_POWERDOWN_M; value = 0; regmap_update_bits(regmap, JZ4740_REG_CODEC_1, mask, value); break; case SND_SOC_BIAS_STANDBY: /* The only way to clear the suspend flag is to reset the codec */ if (codec->dapm.bias_level == SND_SOC_BIAS_OFF) jz4740_codec_wakeup(regmap); mask = JZ4740_CODEC_1_VREF_DISABLE | JZ4740_CODEC_1_VREF_AMP_DISABLE | JZ4740_CODEC_1_HEADPHONE_POWERDOWN_M; value = JZ4740_CODEC_1_VREF_DISABLE | JZ4740_CODEC_1_VREF_AMP_DISABLE | JZ4740_CODEC_1_HEADPHONE_POWERDOWN_M; regmap_update_bits(regmap, JZ4740_REG_CODEC_1, mask, value); break; case SND_SOC_BIAS_OFF: mask = JZ4740_CODEC_1_SUSPEND; value = JZ4740_CODEC_1_SUSPEND; regmap_update_bits(regmap, JZ4740_REG_CODEC_1, mask, value); regcache_mark_dirty(regmap); break; default: break; } codec->dapm.bias_level = level; return 0; }
static int __maybe_unused cs35l33_runtime_suspend(struct device *dev) { struct cs35l33_private *cs35l33 = dev_get_drvdata(dev); dev_dbg(dev, "%s\n", __func__); /* redo the calibration in next power up */ cs35l33->amp_cal = false; regcache_cache_only(cs35l33->regmap, true); regcache_mark_dirty(cs35l33->regmap); regulator_bulk_disable(cs35l33->num_core_supplies, cs35l33->core_supplies); return 0; }
static int cs4271_soc_suspend(struct snd_soc_codec *codec) { int ret; struct cs4271_private *cs4271 = snd_soc_codec_get_drvdata(codec); /* Set power-down bit */ ret = regmap_update_bits(cs4271->regmap, CS4271_MODE2, CS4271_MODE2_PDN, CS4271_MODE2_PDN); if (ret < 0) return ret; regcache_mark_dirty(cs4271->regmap); regulator_bulk_disable(ARRAY_SIZE(cs4271->supplies), cs4271->supplies); return 0; }
static int ak4641_set_bias_level(struct snd_soc_codec *codec, enum snd_soc_bias_level level) { struct ak4641_priv *ak4641 = snd_soc_codec_get_drvdata(codec); struct ak4641_platform_data *pdata = codec->dev->platform_data; int ret; switch (level) { case SND_SOC_BIAS_ON: /* unmute */ snd_soc_update_bits(codec, AK4641_DAC, 0x20, 0); break; case SND_SOC_BIAS_PREPARE: /* mute */ snd_soc_update_bits(codec, AK4641_DAC, 0x20, 0x20); break; case SND_SOC_BIAS_STANDBY: if (codec->dapm.bias_level == SND_SOC_BIAS_OFF) { if (pdata && gpio_is_valid(pdata->gpio_power)) gpio_set_value(pdata->gpio_power, 1); mdelay(1); if (pdata && gpio_is_valid(pdata->gpio_npdn)) gpio_set_value(pdata->gpio_npdn, 1); mdelay(1); ret = regcache_sync(ak4641->regmap); if (ret) { dev_err(codec->dev, "Failed to sync cache: %d\n", ret); return ret; } } snd_soc_update_bits(codec, AK4641_PM1, 0x80, 0x80); snd_soc_update_bits(codec, AK4641_PM2, 0x80, 0); break; case SND_SOC_BIAS_OFF: snd_soc_update_bits(codec, AK4641_PM1, 0x80, 0); if (pdata && gpio_is_valid(pdata->gpio_npdn)) gpio_set_value(pdata->gpio_npdn, 0); if (pdata && gpio_is_valid(pdata->gpio_power)) gpio_set_value(pdata->gpio_power, 0); regcache_mark_dirty(ak4641->regmap); break; } codec->dapm.bias_level = level; return 0; }
static int cs35l32_runtime_suspend(struct device *dev) { struct cs35l32_private *cs35l32 = dev_get_drvdata(dev); regcache_cache_only(cs35l32->regmap, true); regcache_mark_dirty(cs35l32->regmap); /* Hold down reset */ if (cs35l32->reset_gpio) gpiod_set_value_cansleep(cs35l32->reset_gpio, 0); /* remove power */ regulator_bulk_disable(ARRAY_SIZE(cs35l32->supplies), cs35l32->supplies); return 0; }