diff --git a/sound/soc/codecs/wm2200.c b/sound/soc/codecs/wm2200.c index 5c2f5727244d..d5f4bbf27182 100644 --- a/sound/soc/codecs/wm2200.c +++ b/sound/soc/codecs/wm2200.c @@ -87,7 +87,7 @@ struct wm2200_priv { struct wm_adsp dsp[2]; struct regmap *regmap; struct device *dev; - struct snd_soc_codec *codec; + struct snd_soc_component *component; struct wm2200_pdata pdata; struct regulator_bulk_data core_supplies[WM2200_NUM_CORE_SUPPLIES]; @@ -1550,14 +1550,14 @@ static const struct snd_soc_dapm_route wm2200_dapm_routes[] = { WM2200_MIXER_ROUTES("LHPF2", "LHPF2"), }; -static int wm2200_probe(struct snd_soc_codec *codec) +static int wm2200_probe(struct snd_soc_component *component) { - struct wm2200_priv *wm2200 = snd_soc_codec_get_drvdata(codec); + struct wm2200_priv *wm2200 = snd_soc_component_get_drvdata(component); int ret; - wm2200->codec = codec; + wm2200->component = component; - ret = snd_soc_add_codec_controls(codec, wm_adsp_fw_controls, 2); + ret = snd_soc_add_component_controls(component, wm_adsp_fw_controls, 2); if (ret != 0) return ret; @@ -1566,7 +1566,7 @@ static int wm2200_probe(struct snd_soc_codec *codec) static int wm2200_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) { - struct snd_soc_codec *codec = dai->codec; + struct snd_soc_component *component = dai->component; int lrclk, bclk, fmt_val; lrclk = 0; @@ -1580,7 +1580,7 @@ static int wm2200_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) fmt_val = 2; break; default: - dev_err(codec->dev, "Unsupported DAI format %d\n", + dev_err(component->dev, "Unsupported DAI format %d\n", fmt & SND_SOC_DAIFMT_FORMAT_MASK); return -EINVAL; } @@ -1599,7 +1599,7 @@ static int wm2200_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) bclk |= WM2200_AIF1_BCLK_MSTR; break; default: - dev_err(codec->dev, "Unsupported master mode %d\n", + dev_err(component->dev, "Unsupported master mode %d\n", fmt & SND_SOC_DAIFMT_MASTER_MASK); return -EINVAL; } @@ -1621,15 +1621,15 @@ static int wm2200_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) return -EINVAL; } - snd_soc_update_bits(codec, WM2200_AUDIO_IF_1_1, WM2200_AIF1_BCLK_MSTR | + snd_soc_component_update_bits(component, WM2200_AUDIO_IF_1_1, WM2200_AIF1_BCLK_MSTR | WM2200_AIF1_BCLK_INV, bclk); - snd_soc_update_bits(codec, WM2200_AUDIO_IF_1_2, + snd_soc_component_update_bits(component, WM2200_AUDIO_IF_1_2, WM2200_AIF1TX_LRCLK_MSTR | WM2200_AIF1TX_LRCLK_INV, lrclk); - snd_soc_update_bits(codec, WM2200_AUDIO_IF_1_3, + snd_soc_component_update_bits(component, WM2200_AUDIO_IF_1_3, WM2200_AIF1TX_LRCLK_MSTR | WM2200_AIF1TX_LRCLK_INV, lrclk); - snd_soc_update_bits(codec, WM2200_AUDIO_IF_1_5, + snd_soc_component_update_bits(component, WM2200_AUDIO_IF_1_5, WM2200_AIF1_FMT_MASK, fmt_val); return 0; @@ -1698,8 +1698,8 @@ static int wm2200_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { - struct snd_soc_codec *codec = dai->codec; - struct wm2200_priv *wm2200 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = dai->component; + struct wm2200_priv *wm2200 = snd_soc_component_get_drvdata(component); int i, bclk, lrclk, wl, fl, sr_code; int *bclk_rates; @@ -1711,7 +1711,7 @@ static int wm2200_hw_params(struct snd_pcm_substream *substream, if (fl < 0) return fl; - dev_dbg(codec->dev, "Word length %d bits, frame length %d bits\n", + dev_dbg(component->dev, "Word length %d bits, frame length %d bits\n", wl, fl); /* Target BCLK rate */ @@ -1720,7 +1720,7 @@ static int wm2200_hw_params(struct snd_pcm_substream *substream, return bclk; if (!wm2200->sysclk) { - dev_err(codec->dev, "SYSCLK has no rate set\n"); + dev_err(component->dev, "SYSCLK has no rate set\n"); return -EINVAL; } @@ -1728,13 +1728,13 @@ static int wm2200_hw_params(struct snd_pcm_substream *substream, if (wm2200_sr_code[i] == params_rate(params)) break; if (i == ARRAY_SIZE(wm2200_sr_code)) { - dev_err(codec->dev, "Unsupported sample rate: %dHz\n", + dev_err(component->dev, "Unsupported sample rate: %dHz\n", params_rate(params)); return -EINVAL; } sr_code = i; - dev_dbg(codec->dev, "Target BCLK is %dHz, using %dHz SYSCLK\n", + dev_dbg(component->dev, "Target BCLK is %dHz, using %dHz SYSCLK\n", bclk, wm2200->sysclk); if (wm2200->sysclk % 4000) @@ -1746,38 +1746,38 @@ static int wm2200_hw_params(struct snd_pcm_substream *substream, if (bclk_rates[i] >= bclk && (bclk_rates[i] % bclk == 0)) break; if (i == WM2200_NUM_BCLK_RATES) { - dev_err(codec->dev, + dev_err(component->dev, "No valid BCLK for %dHz found from %dHz SYSCLK\n", bclk, wm2200->sysclk); return -EINVAL; } bclk = i; - dev_dbg(codec->dev, "Setting %dHz BCLK\n", bclk_rates[bclk]); - snd_soc_update_bits(codec, WM2200_AUDIO_IF_1_1, + dev_dbg(component->dev, "Setting %dHz BCLK\n", bclk_rates[bclk]); + snd_soc_component_update_bits(component, WM2200_AUDIO_IF_1_1, WM2200_AIF1_BCLK_DIV_MASK, bclk); lrclk = bclk_rates[bclk] / params_rate(params); - dev_dbg(codec->dev, "Setting %dHz LRCLK\n", bclk_rates[bclk] / lrclk); + dev_dbg(component->dev, "Setting %dHz LRCLK\n", bclk_rates[bclk] / lrclk); if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK || wm2200->symmetric_rates) - snd_soc_update_bits(codec, WM2200_AUDIO_IF_1_7, + snd_soc_component_update_bits(component, WM2200_AUDIO_IF_1_7, WM2200_AIF1RX_BCPF_MASK, lrclk); else - snd_soc_update_bits(codec, WM2200_AUDIO_IF_1_6, + snd_soc_component_update_bits(component, WM2200_AUDIO_IF_1_6, WM2200_AIF1TX_BCPF_MASK, lrclk); i = (wl << WM2200_AIF1TX_WL_SHIFT) | wl; if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) - snd_soc_update_bits(codec, WM2200_AUDIO_IF_1_9, + snd_soc_component_update_bits(component, WM2200_AUDIO_IF_1_9, WM2200_AIF1RX_WL_MASK | WM2200_AIF1RX_SLOT_LEN_MASK, i); else - snd_soc_update_bits(codec, WM2200_AUDIO_IF_1_8, + snd_soc_component_update_bits(component, WM2200_AUDIO_IF_1_8, WM2200_AIF1TX_WL_MASK | WM2200_AIF1TX_SLOT_LEN_MASK, i); - snd_soc_update_bits(codec, WM2200_CLOCKING_4, + snd_soc_component_update_bits(component, WM2200_CLOCKING_4, WM2200_SAMPLE_RATE_1_MASK, sr_code); return 0; @@ -1788,10 +1788,10 @@ static const struct snd_soc_dai_ops wm2200_dai_ops = { .hw_params = wm2200_hw_params, }; -static int wm2200_set_sysclk(struct snd_soc_codec *codec, int clk_id, +static int wm2200_set_sysclk(struct snd_soc_component *component, int clk_id, int source, unsigned int freq, int dir) { - struct wm2200_priv *wm2200 = snd_soc_codec_get_drvdata(codec); + struct wm2200_priv *wm2200 = snd_soc_component_get_drvdata(component); int fval; switch (clk_id) { @@ -1799,7 +1799,7 @@ static int wm2200_set_sysclk(struct snd_soc_codec *codec, int clk_id, break; default: - dev_err(codec->dev, "Unknown clock %d\n", clk_id); + dev_err(component->dev, "Unknown clock %d\n", clk_id); return -EINVAL; } @@ -1810,7 +1810,7 @@ static int wm2200_set_sysclk(struct snd_soc_codec *codec, int clk_id, case WM2200_CLKSRC_BCLK1: break; default: - dev_err(codec->dev, "Invalid source %d\n", source); + dev_err(component->dev, "Invalid source %d\n", source); return -EINVAL; } @@ -1820,7 +1820,7 @@ static int wm2200_set_sysclk(struct snd_soc_codec *codec, int clk_id, fval = 2; break; default: - dev_err(codec->dev, "Invalid clock rate: %d\n", freq); + dev_err(component->dev, "Invalid clock rate: %d\n", freq); return -EINVAL; } @@ -1828,7 +1828,7 @@ static int wm2200_set_sysclk(struct snd_soc_codec *codec, int clk_id, * match. */ - snd_soc_update_bits(codec, WM2200_CLOCKING_3, WM2200_SYSCLK_FREQ_MASK | + snd_soc_component_update_bits(component, WM2200_CLOCKING_3, WM2200_SYSCLK_FREQ_MASK | WM2200_SYSCLK_SRC_MASK, fval << WM2200_SYSCLK_FREQ_SHIFT | source); @@ -1936,23 +1936,23 @@ static int fll_factors(struct _fll_div *fll_div, unsigned int Fref, return 0; } -static int wm2200_set_fll(struct snd_soc_codec *codec, int fll_id, int source, +static int wm2200_set_fll(struct snd_soc_component *component, int fll_id, int source, unsigned int Fref, unsigned int Fout) { - struct i2c_client *i2c = to_i2c_client(codec->dev); - struct wm2200_priv *wm2200 = snd_soc_codec_get_drvdata(codec); + struct i2c_client *i2c = to_i2c_client(component->dev); + struct wm2200_priv *wm2200 = snd_soc_component_get_drvdata(component); struct _fll_div factors; int ret, i, timeout; unsigned long time_left; if (!Fout) { - dev_dbg(codec->dev, "FLL disabled"); + dev_dbg(component->dev, "FLL disabled"); if (wm2200->fll_fout) - pm_runtime_put(codec->dev); + pm_runtime_put(component->dev); wm2200->fll_fout = 0; - snd_soc_update_bits(codec, WM2200_FLL_CONTROL_1, + snd_soc_component_update_bits(component, WM2200_FLL_CONTROL_1, WM2200_FLL_ENA, 0); return 0; } @@ -1963,7 +1963,7 @@ static int wm2200_set_fll(struct snd_soc_codec *codec, int fll_id, int source, case WM2200_FLL_SRC_BCLK: break; default: - dev_err(codec->dev, "Invalid FLL source %d\n", source); + dev_err(component->dev, "Invalid FLL source %d\n", source); return -EINVAL; } @@ -1972,44 +1972,44 @@ static int wm2200_set_fll(struct snd_soc_codec *codec, int fll_id, int source, return ret; /* Disable the FLL while we reconfigure */ - snd_soc_update_bits(codec, WM2200_FLL_CONTROL_1, WM2200_FLL_ENA, 0); + snd_soc_component_update_bits(component, WM2200_FLL_CONTROL_1, WM2200_FLL_ENA, 0); - snd_soc_update_bits(codec, WM2200_FLL_CONTROL_2, + snd_soc_component_update_bits(component, WM2200_FLL_CONTROL_2, WM2200_FLL_OUTDIV_MASK | WM2200_FLL_FRATIO_MASK, (factors.fll_outdiv << WM2200_FLL_OUTDIV_SHIFT) | factors.fll_fratio); if (factors.theta) { - snd_soc_update_bits(codec, WM2200_FLL_CONTROL_3, + snd_soc_component_update_bits(component, WM2200_FLL_CONTROL_3, WM2200_FLL_FRACN_ENA, WM2200_FLL_FRACN_ENA); - snd_soc_update_bits(codec, WM2200_FLL_EFS_2, + snd_soc_component_update_bits(component, WM2200_FLL_EFS_2, WM2200_FLL_EFS_ENA, WM2200_FLL_EFS_ENA); } else { - snd_soc_update_bits(codec, WM2200_FLL_CONTROL_3, + snd_soc_component_update_bits(component, WM2200_FLL_CONTROL_3, WM2200_FLL_FRACN_ENA, 0); - snd_soc_update_bits(codec, WM2200_FLL_EFS_2, + snd_soc_component_update_bits(component, WM2200_FLL_EFS_2, WM2200_FLL_EFS_ENA, 0); } - snd_soc_update_bits(codec, WM2200_FLL_CONTROL_4, WM2200_FLL_THETA_MASK, + snd_soc_component_update_bits(component, WM2200_FLL_CONTROL_4, WM2200_FLL_THETA_MASK, factors.theta); - snd_soc_update_bits(codec, WM2200_FLL_CONTROL_6, WM2200_FLL_N_MASK, + snd_soc_component_update_bits(component, WM2200_FLL_CONTROL_6, WM2200_FLL_N_MASK, factors.n); - snd_soc_update_bits(codec, WM2200_FLL_CONTROL_7, + snd_soc_component_update_bits(component, WM2200_FLL_CONTROL_7, WM2200_FLL_CLK_REF_DIV_MASK | WM2200_FLL_CLK_REF_SRC_MASK, (factors.fll_refclk_div << WM2200_FLL_CLK_REF_DIV_SHIFT) | source); - snd_soc_update_bits(codec, WM2200_FLL_EFS_1, + snd_soc_component_update_bits(component, WM2200_FLL_EFS_1, WM2200_FLL_LAMBDA_MASK, factors.lambda); /* Clear any pending completions */ try_wait_for_completion(&wm2200->fll_lock); - pm_runtime_get_sync(codec->dev); + pm_runtime_get_sync(component->dev); - snd_soc_update_bits(codec, WM2200_FLL_CONTROL_1, + snd_soc_component_update_bits(component, WM2200_FLL_CONTROL_1, WM2200_FLL_ENA, WM2200_FLL_ENA); if (i2c->irq) @@ -2017,7 +2017,7 @@ static int wm2200_set_fll(struct snd_soc_codec *codec, int fll_id, int source, else timeout = 50; - snd_soc_update_bits(codec, WM2200_CLOCKING_3, WM2200_SYSCLK_ENA, + snd_soc_component_update_bits(component, WM2200_CLOCKING_3, WM2200_SYSCLK_ENA, WM2200_SYSCLK_ENA); /* Poll for the lock; will use the interrupt to exit quickly */ @@ -2032,10 +2032,10 @@ static int wm2200_set_fll(struct snd_soc_codec *codec, int fll_id, int source, msleep(1); } - ret = snd_soc_read(codec, + ret = snd_soc_component_read32(component, WM2200_INTERRUPT_RAW_STATUS_2); if (ret < 0) { - dev_err(codec->dev, + dev_err(component->dev, "Failed to read FLL status: %d\n", ret); continue; @@ -2044,8 +2044,8 @@ static int wm2200_set_fll(struct snd_soc_codec *codec, int fll_id, int source, break; } if (i == timeout) { - dev_err(codec->dev, "FLL lock timed out\n"); - pm_runtime_put(codec->dev); + dev_err(component->dev, "FLL lock timed out\n"); + pm_runtime_put(component->dev); return -ETIMEDOUT; } @@ -2053,29 +2053,29 @@ static int wm2200_set_fll(struct snd_soc_codec *codec, int fll_id, int source, wm2200->fll_fref = Fref; wm2200->fll_fout = Fout; - dev_dbg(codec->dev, "FLL running %dHz->%dHz\n", Fref, Fout); + dev_dbg(component->dev, "FLL running %dHz->%dHz\n", Fref, Fout); return 0; } static int wm2200_dai_probe(struct snd_soc_dai *dai) { - struct snd_soc_codec *codec = dai->codec; - struct wm2200_priv *wm2200 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = dai->component; + struct wm2200_priv *wm2200 = snd_soc_component_get_drvdata(component); unsigned int val = 0; int ret; - ret = snd_soc_read(codec, WM2200_GPIO_CTRL_1); + ret = snd_soc_component_read32(component, WM2200_GPIO_CTRL_1); if (ret >= 0) { if ((ret & WM2200_GP1_FN_MASK) != 0) { wm2200->symmetric_rates = true; val = WM2200_AIF1TX_LRCLK_SRC; } } else { - dev_err(codec->dev, "Failed to read GPIO 1 config: %d\n", ret); + dev_err(component->dev, "Failed to read GPIO 1 config: %d\n", ret); } - snd_soc_update_bits(codec, WM2200_AUDIO_IF_1_2, + snd_soc_component_update_bits(component, WM2200_AUDIO_IF_1_2, WM2200_AIF1TX_LRCLK_SRC, val); return 0; @@ -2106,22 +2106,18 @@ static struct snd_soc_dai_driver wm2200_dai = { .ops = &wm2200_dai_ops, }; -static const struct snd_soc_codec_driver soc_codec_wm2200 = { - .probe = wm2200_probe, - - .idle_bias_off = true, - .ignore_pmdown_time = true, - .set_sysclk = wm2200_set_sysclk, - .set_pll = wm2200_set_fll, - - .component_driver = { - .controls = wm2200_snd_controls, - .num_controls = ARRAY_SIZE(wm2200_snd_controls), - .dapm_widgets = wm2200_dapm_widgets, - .num_dapm_widgets = ARRAY_SIZE(wm2200_dapm_widgets), - .dapm_routes = wm2200_dapm_routes, - .num_dapm_routes = ARRAY_SIZE(wm2200_dapm_routes), - }, +static const struct snd_soc_component_driver soc_component_wm2200 = { + .probe = wm2200_probe, + .set_sysclk = wm2200_set_sysclk, + .set_pll = wm2200_set_fll, + .controls = wm2200_snd_controls, + .num_controls = ARRAY_SIZE(wm2200_snd_controls), + .dapm_widgets = wm2200_dapm_widgets, + .num_dapm_widgets = ARRAY_SIZE(wm2200_dapm_widgets), + .dapm_routes = wm2200_dapm_routes, + .num_dapm_routes = ARRAY_SIZE(wm2200_dapm_routes), + .endianness = 1, + .non_legacy_dai_naming = 1, }; static irqreturn_t wm2200_irq(int irq, void *data) @@ -2408,7 +2404,7 @@ static int wm2200_i2c_probe(struct i2c_client *i2c, pm_runtime_enable(&i2c->dev); pm_request_idle(&i2c->dev); - ret = snd_soc_register_codec(&i2c->dev, &soc_codec_wm2200, + ret = devm_snd_soc_register_component(&i2c->dev, &soc_component_wm2200, &wm2200_dai, 1); if (ret != 0) { dev_err(&i2c->dev, "Failed to register CODEC: %d\n", ret); @@ -2435,7 +2431,6 @@ static int wm2200_i2c_remove(struct i2c_client *i2c) { struct wm2200_priv *wm2200 = i2c_get_clientdata(i2c); - snd_soc_unregister_codec(&i2c->dev); if (i2c->irq) free_irq(i2c->irq, wm2200); if (wm2200->pdata.reset) diff --git a/sound/soc/codecs/wm5100.c b/sound/soc/codecs/wm5100.c index 138a84efdd54..87f9a99ce978 100644 --- a/sound/soc/codecs/wm5100.c +++ b/sound/soc/codecs/wm5100.c @@ -55,7 +55,7 @@ struct wm5100_fll { struct wm5100_priv { struct device *dev; struct regmap *regmap; - struct snd_soc_codec *codec; + struct snd_soc_component *component; struct regulator_bulk_data core_supplies[WM5100_NUM_CORE_SUPPLIES]; @@ -118,16 +118,16 @@ static int wm5100_sr_regs[WM5100_SYNC_SRS] = { WM5100_CLOCKING_6, }; -static int wm5100_alloc_sr(struct snd_soc_codec *codec, int rate) +static int wm5100_alloc_sr(struct snd_soc_component *component, int rate) { - struct wm5100_priv *wm5100 = snd_soc_codec_get_drvdata(codec); + struct wm5100_priv *wm5100 = snd_soc_component_get_drvdata(component); int sr_code, sr_free, i; for (i = 0; i < ARRAY_SIZE(wm5100_sr_code); i++) if (wm5100_sr_code[i] == rate) break; if (i == ARRAY_SIZE(wm5100_sr_code)) { - dev_err(codec->dev, "Unsupported sample rate: %dHz\n", rate); + dev_err(component->dev, "Unsupported sample rate: %dHz\n", rate); return -EINVAL; } sr_code = i; @@ -140,50 +140,50 @@ static int wm5100_alloc_sr(struct snd_soc_codec *codec, int rate) sr_free = i; continue; } - if ((snd_soc_read(codec, wm5100_sr_regs[i]) & + if ((snd_soc_component_read32(component, wm5100_sr_regs[i]) & WM5100_SAMPLE_RATE_1_MASK) == sr_code) break; } if (i < ARRAY_SIZE(wm5100_sr_regs)) { wm5100->sr_ref[i]++; - dev_dbg(codec->dev, "SR %dHz, slot %d, ref %d\n", + dev_dbg(component->dev, "SR %dHz, slot %d, ref %d\n", rate, i, wm5100->sr_ref[i]); return i; } if (sr_free == -1) { - dev_err(codec->dev, "All SR slots already in use\n"); + dev_err(component->dev, "All SR slots already in use\n"); return -EBUSY; } - dev_dbg(codec->dev, "Allocating SR slot %d for %dHz\n", + dev_dbg(component->dev, "Allocating SR slot %d for %dHz\n", sr_free, rate); wm5100->sr_ref[sr_free]++; - snd_soc_update_bits(codec, wm5100_sr_regs[sr_free], + snd_soc_component_update_bits(component, wm5100_sr_regs[sr_free], WM5100_SAMPLE_RATE_1_MASK, sr_code); return sr_free; } else { - dev_err(codec->dev, + dev_err(component->dev, "SR %dHz incompatible with %dHz SYSCLK and %dHz ASYNCCLK\n", rate, wm5100->sysclk, wm5100->asyncclk); return -EINVAL; } } -static void wm5100_free_sr(struct snd_soc_codec *codec, int rate) +static void wm5100_free_sr(struct snd_soc_component *component, int rate) { - struct wm5100_priv *wm5100 = snd_soc_codec_get_drvdata(codec); + struct wm5100_priv *wm5100 = snd_soc_component_get_drvdata(component); int i, sr_code; for (i = 0; i < ARRAY_SIZE(wm5100_sr_code); i++) if (wm5100_sr_code[i] == rate) break; if (i == ARRAY_SIZE(wm5100_sr_code)) { - dev_err(codec->dev, "Unsupported sample rate: %dHz\n", rate); + dev_err(component->dev, "Unsupported sample rate: %dHz\n", rate); return; } sr_code = wm5100_sr_code[i]; @@ -192,16 +192,16 @@ static void wm5100_free_sr(struct snd_soc_codec *codec, int rate) if (!wm5100->sr_ref[i]) continue; - if ((snd_soc_read(codec, wm5100_sr_regs[i]) & + if ((snd_soc_component_read32(component, wm5100_sr_regs[i]) & WM5100_SAMPLE_RATE_1_MASK) == sr_code) break; } if (i < ARRAY_SIZE(wm5100_sr_regs)) { wm5100->sr_ref[i]--; - dev_dbg(codec->dev, "Dereference SR %dHz, count now %d\n", + dev_dbg(component->dev, "Dereference SR %dHz, count now %d\n", rate, wm5100->sr_ref[i]); } else { - dev_warn(codec->dev, "Freeing unreferenced sample rate %dHz\n", + dev_warn(component->dev, "Freeing unreferenced sample rate %dHz\n", rate); } } @@ -733,40 +733,39 @@ WM5100_MIXER_CONTROLS("LHPF3", WM5100_HPLP3MIX_INPUT_1_SOURCE), WM5100_MIXER_CONTROLS("LHPF4", WM5100_HPLP4MIX_INPUT_1_SOURCE), }; -static void wm5100_seq_notifier(struct snd_soc_dapm_context *dapm, +static void wm5100_seq_notifier(struct snd_soc_component *component, enum snd_soc_dapm_type event, int subseq) { - struct snd_soc_codec *codec = snd_soc_dapm_to_codec(dapm); - struct wm5100_priv *wm5100 = snd_soc_codec_get_drvdata(codec); + struct wm5100_priv *wm5100 = snd_soc_component_get_drvdata(component); u16 val, expect, i; /* Wait for the outputs to flag themselves as enabled */ if (wm5100->out_ena[0]) { - expect = snd_soc_read(codec, WM5100_CHANNEL_ENABLES_1); + expect = snd_soc_component_read32(component, WM5100_CHANNEL_ENABLES_1); for (i = 0; i < 200; i++) { - val = snd_soc_read(codec, WM5100_OUTPUT_STATUS_1); + val = snd_soc_component_read32(component, WM5100_OUTPUT_STATUS_1); if (val == expect) { wm5100->out_ena[0] = false; break; } } if (i == 200) { - dev_err(codec->dev, "Timeout waiting for OUTPUT1 %x\n", + dev_err(component->dev, "Timeout waiting for OUTPUT1 %x\n", expect); } } if (wm5100->out_ena[1]) { - expect = snd_soc_read(codec, WM5100_OUTPUT_ENABLES_2); + expect = snd_soc_component_read32(component, WM5100_OUTPUT_ENABLES_2); for (i = 0; i < 200; i++) { - val = snd_soc_read(codec, WM5100_OUTPUT_STATUS_2); + val = snd_soc_component_read32(component, WM5100_OUTPUT_STATUS_2); if (val == expect) { wm5100->out_ena[1] = false; break; } } if (i == 200) { - dev_err(codec->dev, "Timeout waiting for OUTPUT2 %x\n", + dev_err(component->dev, "Timeout waiting for OUTPUT2 %x\n", expect); } } @@ -776,8 +775,8 @@ static int wm5100_out_ev(struct snd_soc_dapm_widget *w, struct snd_kcontrol *kcontrol, int event) { - struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm); - struct wm5100_priv *wm5100 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm); + struct wm5100_priv *wm5100 = snd_soc_component_get_drvdata(component); switch (w->reg) { case WM5100_CHANNEL_ENABLES_1: @@ -841,17 +840,17 @@ static int wm5100_post_ev(struct snd_soc_dapm_widget *w, struct snd_kcontrol *kcontrol, int event) { - struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm); - struct wm5100_priv *wm5100 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm); + struct wm5100_priv *wm5100 = snd_soc_component_get_drvdata(component); int ret; - ret = snd_soc_read(codec, WM5100_INTERRUPT_RAW_STATUS_3); + ret = snd_soc_component_read32(component, WM5100_INTERRUPT_RAW_STATUS_3); ret &= WM5100_SPK_SHUTDOWN_WARN_STS | WM5100_SPK_SHUTDOWN_STS | WM5100_CLKGEN_ERR_STS | WM5100_CLKGEN_ERR_ASYNC_STS; wm5100_log_status3(wm5100, ret); - ret = snd_soc_read(codec, WM5100_INTERRUPT_RAW_STATUS_4); + ret = snd_soc_component_read32(component, WM5100_INTERRUPT_RAW_STATUS_4); wm5100_log_status4(wm5100, ret); return 0; @@ -1282,7 +1281,7 @@ static const struct reg_sequence wm5100_reva_patches[] = { static int wm5100_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) { - struct snd_soc_codec *codec = dai->codec; + struct snd_soc_component *component = dai->component; int lrclk, bclk, mask, base; base = dai->driver->base; @@ -1298,7 +1297,7 @@ static int wm5100_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) mask = 2; break; default: - dev_err(codec->dev, "Unsupported DAI format %d\n", + dev_err(component->dev, "Unsupported DAI format %d\n", fmt & SND_SOC_DAIFMT_FORMAT_MASK); return -EINVAL; } @@ -1317,7 +1316,7 @@ static int wm5100_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) bclk |= WM5100_AIF1_BCLK_MSTR; break; default: - dev_err(codec->dev, "Unsupported master mode %d\n", + dev_err(component->dev, "Unsupported master mode %d\n", fmt & SND_SOC_DAIFMT_MASTER_MASK); return -EINVAL; } @@ -1339,13 +1338,13 @@ static int wm5100_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) return -EINVAL; } - snd_soc_update_bits(codec, base + 1, WM5100_AIF1_BCLK_MSTR | + snd_soc_component_update_bits(component, base + 1, WM5100_AIF1_BCLK_MSTR | WM5100_AIF1_BCLK_INV, bclk); - snd_soc_update_bits(codec, base + 2, WM5100_AIF1TX_LRCLK_MSTR | + snd_soc_component_update_bits(component, base + 2, WM5100_AIF1TX_LRCLK_MSTR | WM5100_AIF1TX_LRCLK_INV, lrclk); - snd_soc_update_bits(codec, base + 3, WM5100_AIF1TX_LRCLK_MSTR | + snd_soc_component_update_bits(component, base + 3, WM5100_AIF1TX_LRCLK_MSTR | WM5100_AIF1TX_LRCLK_INV, lrclk); - snd_soc_update_bits(codec, base + 5, WM5100_AIF1_FMT_MASK, mask); + snd_soc_component_update_bits(component, base + 5, WM5100_AIF1_FMT_MASK, mask); return 0; } @@ -1400,8 +1399,8 @@ static int wm5100_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { - struct snd_soc_codec *codec = dai->codec; - struct wm5100_priv *wm5100 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = dai->component; + struct wm5100_priv *wm5100 = snd_soc_component_get_drvdata(component); bool async = wm5100->aif_async[dai->id]; int i, base, bclk, aif_rate, lrclk, wl, fl, sr; int *bclk_rates; @@ -1416,7 +1415,7 @@ static int wm5100_hw_params(struct snd_pcm_substream *substream, if (fl < 0) return fl; - dev_dbg(codec->dev, "Word length %d bits, frame length %d bits\n", + dev_dbg(component->dev, "Word length %d bits, frame length %d bits\n", wl, fl); /* Target BCLK rate */ @@ -1427,7 +1426,7 @@ static int wm5100_hw_params(struct snd_pcm_substream *substream, /* Root for BCLK depends on SYS/ASYNCCLK */ if (!async) { aif_rate = wm5100->sysclk; - sr = wm5100_alloc_sr(codec, params_rate(params)); + sr = wm5100_alloc_sr(component, params_rate(params)); if (sr < 0) return sr; } else { @@ -1439,23 +1438,23 @@ static int wm5100_hw_params(struct snd_pcm_substream *substream, if (params_rate(params) == wm5100_sr_code[i]) break; if (i == ARRAY_SIZE(wm5100_sr_code)) { - dev_err(codec->dev, "Invalid rate %dHzn", + dev_err(component->dev, "Invalid rate %dHzn", params_rate(params)); return -EINVAL; } /* TODO: We should really check for symmetry */ - snd_soc_update_bits(codec, WM5100_CLOCKING_8, + snd_soc_component_update_bits(component, WM5100_CLOCKING_8, WM5100_ASYNC_SAMPLE_RATE_MASK, i); } if (!aif_rate) { - dev_err(codec->dev, "%s has no rate set\n", + dev_err(component->dev, "%s has no rate set\n", async ? "ASYNCCLK" : "SYSCLK"); return -EINVAL; } - dev_dbg(codec->dev, "Target BCLK is %dHz, using %dHz %s\n", + dev_dbg(component->dev, "Target BCLK is %dHz, using %dHz %s\n", bclk, aif_rate, async ? "ASYNCCLK" : "SYSCLK"); if (aif_rate % 4000) @@ -1467,37 +1466,37 @@ static int wm5100_hw_params(struct snd_pcm_substream *substream, if (bclk_rates[i] >= bclk && (bclk_rates[i] % bclk == 0)) break; if (i == WM5100_NUM_BCLK_RATES) { - dev_err(codec->dev, + dev_err(component->dev, "No valid BCLK for %dHz found from %dHz %s\n", bclk, aif_rate, async ? "ASYNCCLK" : "SYSCLK"); return -EINVAL; } bclk = i; - dev_dbg(codec->dev, "Setting %dHz BCLK\n", bclk_rates[bclk]); - snd_soc_update_bits(codec, base + 1, WM5100_AIF1_BCLK_FREQ_MASK, bclk); + dev_dbg(component->dev, "Setting %dHz BCLK\n", bclk_rates[bclk]); + snd_soc_component_update_bits(component, base + 1, WM5100_AIF1_BCLK_FREQ_MASK, bclk); lrclk = bclk_rates[bclk] / params_rate(params); - dev_dbg(codec->dev, "Setting %dHz LRCLK\n", bclk_rates[bclk] / lrclk); + dev_dbg(component->dev, "Setting %dHz LRCLK\n", bclk_rates[bclk] / lrclk); if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK || wm5100->aif_symmetric[dai->id]) - snd_soc_update_bits(codec, base + 7, + snd_soc_component_update_bits(component, base + 7, WM5100_AIF1RX_BCPF_MASK, lrclk); else - snd_soc_update_bits(codec, base + 6, + snd_soc_component_update_bits(component, base + 6, WM5100_AIF1TX_BCPF_MASK, lrclk); i = (wl << WM5100_AIF1TX_WL_SHIFT) | fl; if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) - snd_soc_update_bits(codec, base + 9, + snd_soc_component_update_bits(component, base + 9, WM5100_AIF1RX_WL_MASK | WM5100_AIF1RX_SLOT_LEN_MASK, i); else - snd_soc_update_bits(codec, base + 8, + snd_soc_component_update_bits(component, base + 8, WM5100_AIF1TX_WL_MASK | WM5100_AIF1TX_SLOT_LEN_MASK, i); - snd_soc_update_bits(codec, base + 4, WM5100_AIF1_RATE_MASK, sr); + snd_soc_component_update_bits(component, base + 4, WM5100_AIF1_RATE_MASK, sr); return 0; } @@ -1507,10 +1506,10 @@ static const struct snd_soc_dai_ops wm5100_dai_ops = { .hw_params = wm5100_hw_params, }; -static int wm5100_set_sysclk(struct snd_soc_codec *codec, int clk_id, +static int wm5100_set_sysclk(struct snd_soc_component *component, int clk_id, int source, unsigned int freq, int dir) { - struct wm5100_priv *wm5100 = snd_soc_codec_get_drvdata(codec); + struct wm5100_priv *wm5100 = snd_soc_component_get_drvdata(component); int *rate_store; int fval, audio_rate, ret, reg; @@ -1529,7 +1528,7 @@ static int wm5100_set_sysclk(struct snd_soc_codec *codec, int clk_id, case WM5100_CLKSRC_MCLK1: case WM5100_CLKSRC_MCLK2: case WM5100_CLKSRC_SYSCLK: - snd_soc_update_bits(codec, WM5100_CLOCKING_1, + snd_soc_component_update_bits(component, WM5100_CLOCKING_1, WM5100_CLK_32K_SRC_MASK, source); break; @@ -1550,7 +1549,7 @@ static int wm5100_set_sysclk(struct snd_soc_codec *codec, int clk_id, wm5100->aif_async[clk_id - 1] = true; break; default: - dev_err(codec->dev, "Invalid source %d\n", source); + dev_err(component->dev, "Invalid source %d\n", source); return -EINVAL; } return 0; @@ -1559,35 +1558,35 @@ static int wm5100_set_sysclk(struct snd_soc_codec *codec, int clk_id, switch (freq) { case 5644800: case 6144000: - snd_soc_update_bits(codec, WM5100_MISC_GPIO_1, + snd_soc_component_update_bits(component, WM5100_MISC_GPIO_1, WM5100_OPCLK_SEL_MASK, 0); break; case 11289600: case 12288000: - snd_soc_update_bits(codec, WM5100_MISC_GPIO_1, + snd_soc_component_update_bits(component, WM5100_MISC_GPIO_1, WM5100_OPCLK_SEL_MASK, 0); break; case 22579200: case 24576000: - snd_soc_update_bits(codec, WM5100_MISC_GPIO_1, + snd_soc_component_update_bits(component, WM5100_MISC_GPIO_1, WM5100_OPCLK_SEL_MASK, 0); break; default: - dev_err(codec->dev, "Unsupported OPCLK %dHz\n", + dev_err(component->dev, "Unsupported OPCLK %dHz\n", freq); return -EINVAL; } return 0; default: - dev_err(codec->dev, "Unknown clock %d\n", clk_id); + dev_err(component->dev, "Unknown clock %d\n", clk_id); return -EINVAL; } switch (source) { case WM5100_CLKSRC_SYSCLK: case WM5100_CLKSRC_ASYNCCLK: - dev_err(codec->dev, "Invalid source %d\n", source); + dev_err(component->dev, "Invalid source %d\n", source); return -EINVAL; } @@ -1605,7 +1604,7 @@ static int wm5100_set_sysclk(struct snd_soc_codec *codec, int clk_id, fval = 2; break; default: - dev_err(codec->dev, "Invalid clock rate: %d\n", freq); + dev_err(component->dev, "Invalid clock rate: %d\n", freq); return -EINVAL; } @@ -1632,7 +1631,7 @@ static int wm5100_set_sysclk(struct snd_soc_codec *codec, int clk_id, * match. */ - snd_soc_update_bits(codec, reg, WM5100_SYSCLK_FREQ_MASK | + snd_soc_component_update_bits(component, reg, WM5100_SYSCLK_FREQ_MASK | WM5100_SYSCLK_SRC_MASK, fval << WM5100_SYSCLK_FREQ_SHIFT | source); @@ -1641,13 +1640,13 @@ static int wm5100_set_sysclk(struct snd_soc_codec *codec, int clk_id, * this clock rate. */ if (clk_id == WM5100_CLK_SYSCLK) { - dev_dbg(codec->dev, "Setting primary audio rate to %dHz", + dev_dbg(component->dev, "Setting primary audio rate to %dHz", audio_rate); if (0 && *rate_store) - wm5100_free_sr(codec, audio_rate); - ret = wm5100_alloc_sr(codec, audio_rate); + wm5100_free_sr(component, audio_rate); + ret = wm5100_alloc_sr(component, audio_rate); if (ret != 0) - dev_warn(codec->dev, "Primary audio slot is %d\n", + dev_warn(component->dev, "Primary audio slot is %d\n", ret); } @@ -1755,11 +1754,11 @@ static int fll_factors(struct _fll_div *fll_div, unsigned int Fref, return 0; } -static int wm5100_set_fll(struct snd_soc_codec *codec, int fll_id, int source, +static int wm5100_set_fll(struct snd_soc_component *component, int fll_id, int source, unsigned int Fref, unsigned int Fout) { - struct i2c_client *i2c = to_i2c_client(codec->dev); - struct wm5100_priv *wm5100 = snd_soc_codec_get_drvdata(codec); + struct i2c_client *i2c = to_i2c_client(component->dev); + struct wm5100_priv *wm5100 = snd_soc_component_get_drvdata(component); struct _fll_div factors; struct wm5100_fll *fll; int ret, base, lock, i, timeout; @@ -1777,16 +1776,16 @@ static int wm5100_set_fll(struct snd_soc_codec *codec, int fll_id, int source, lock = WM5100_FLL2_LOCK_STS; break; default: - dev_err(codec->dev, "Unknown FLL %d\n",fll_id); + dev_err(component->dev, "Unknown FLL %d\n",fll_id); return -EINVAL; } if (!Fout) { - dev_dbg(codec->dev, "FLL%d disabled", fll_id); + dev_dbg(component->dev, "FLL%d disabled", fll_id); if (fll->fout) - pm_runtime_put(codec->dev); + pm_runtime_put(component->dev); fll->fout = 0; - snd_soc_update_bits(codec, base + 1, WM5100_FLL1_ENA, 0); + snd_soc_component_update_bits(component, base + 1, WM5100_FLL1_ENA, 0); return 0; } @@ -1800,7 +1799,7 @@ static int wm5100_set_fll(struct snd_soc_codec *codec, int fll_id, int source, case WM5100_FLL_SRC_AIF3BCLK: break; default: - dev_err(codec->dev, "Invalid FLL source %d\n", source); + dev_err(component->dev, "Invalid FLL source %d\n", source); return -EINVAL; } @@ -1809,36 +1808,36 @@ static int wm5100_set_fll(struct snd_soc_codec *codec, int fll_id, int source, return ret; /* Disable the FLL while we reconfigure */ - snd_soc_update_bits(codec, base + 1, WM5100_FLL1_ENA, 0); + snd_soc_component_update_bits(component, base + 1, WM5100_FLL1_ENA, 0); - snd_soc_update_bits(codec, base + 2, + snd_soc_component_update_bits(component, base + 2, WM5100_FLL1_OUTDIV_MASK | WM5100_FLL1_FRATIO_MASK, (factors.fll_outdiv << WM5100_FLL1_OUTDIV_SHIFT) | factors.fll_fratio); - snd_soc_update_bits(codec, base + 3, WM5100_FLL1_THETA_MASK, + snd_soc_component_update_bits(component, base + 3, WM5100_FLL1_THETA_MASK, factors.theta); - snd_soc_update_bits(codec, base + 5, WM5100_FLL1_N_MASK, factors.n); - snd_soc_update_bits(codec, base + 6, + snd_soc_component_update_bits(component, base + 5, WM5100_FLL1_N_MASK, factors.n); + snd_soc_component_update_bits(component, base + 6, WM5100_FLL1_REFCLK_DIV_MASK | WM5100_FLL1_REFCLK_SRC_MASK, (factors.fll_refclk_div << WM5100_FLL1_REFCLK_DIV_SHIFT) | source); - snd_soc_update_bits(codec, base + 7, WM5100_FLL1_LAMBDA_MASK, + snd_soc_component_update_bits(component, base + 7, WM5100_FLL1_LAMBDA_MASK, factors.lambda); /* Clear any pending completions */ try_wait_for_completion(&fll->lock); - pm_runtime_get_sync(codec->dev); + pm_runtime_get_sync(component->dev); - snd_soc_update_bits(codec, base + 1, WM5100_FLL1_ENA, WM5100_FLL1_ENA); + snd_soc_component_update_bits(component, base + 1, WM5100_FLL1_ENA, WM5100_FLL1_ENA); if (i2c->irq) timeout = 2; else timeout = 50; - snd_soc_update_bits(codec, WM5100_CLOCKING_3, WM5100_SYSCLK_ENA, + snd_soc_component_update_bits(component, WM5100_CLOCKING_3, WM5100_SYSCLK_ENA, WM5100_SYSCLK_ENA); /* Poll for the lock; will use interrupt when we can test */ @@ -1852,10 +1851,10 @@ static int wm5100_set_fll(struct snd_soc_codec *codec, int fll_id, int source, msleep(1); } - ret = snd_soc_read(codec, + ret = snd_soc_component_read32(component, WM5100_INTERRUPT_RAW_STATUS_3); if (ret < 0) { - dev_err(codec->dev, + dev_err(component->dev, "Failed to read FLL status: %d\n", ret); continue; @@ -1864,8 +1863,8 @@ static int wm5100_set_fll(struct snd_soc_codec *codec, int fll_id, int source, break; } if (i == timeout) { - dev_err(codec->dev, "FLL%d lock timed out\n", fll_id); - pm_runtime_put(codec->dev); + dev_err(component->dev, "FLL%d lock timed out\n", fll_id); + pm_runtime_put(component->dev); return -ETIMEDOUT; } @@ -1873,7 +1872,7 @@ static int wm5100_set_fll(struct snd_soc_codec *codec, int fll_id, int source, fll->fref = Fref; fll->fout = Fout; - dev_dbg(codec->dev, "FLL%d running %dHz->%dHz\n", fll_id, + dev_dbg(component->dev, "FLL%d running %dHz->%dHz\n", fll_id, Fref, Fout); return 0; @@ -2099,10 +2098,10 @@ static void wm5100_micd_irq(struct wm5100_priv *wm5100) } } -int wm5100_detect(struct snd_soc_codec *codec, struct snd_soc_jack *jack) +int wm5100_detect(struct snd_soc_component *component, struct snd_soc_jack *jack) { - struct wm5100_priv *wm5100 = snd_soc_codec_get_drvdata(codec); - struct snd_soc_dapm_context *dapm = snd_soc_codec_get_dapm(codec); + struct wm5100_priv *wm5100 = snd_soc_component_get_drvdata(component); + struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component); if (jack) { wm5100->jack = jack; @@ -2113,7 +2112,7 @@ int wm5100_detect(struct snd_soc_codec *codec, struct snd_soc_jack *jack) /* Slowest detection rate, gives debounce for initial * detection */ - snd_soc_update_bits(codec, WM5100_MIC_DETECT_1, + snd_soc_component_update_bits(component, WM5100_MIC_DETECT_1, WM5100_ACCDET_BIAS_STARTTIME_MASK | WM5100_ACCDET_RATE_MASK, (7 << WM5100_ACCDET_BIAS_STARTTIME_SHIFT) | @@ -2132,18 +2131,18 @@ int wm5100_detect(struct snd_soc_codec *codec, struct snd_soc_jack *jack) /* We start off just enabling microphone detection - even a * plain headphone will trigger detection. */ - snd_soc_update_bits(codec, WM5100_MIC_DETECT_1, + snd_soc_component_update_bits(component, WM5100_MIC_DETECT_1, WM5100_ACCDET_ENA, WM5100_ACCDET_ENA); - snd_soc_update_bits(codec, WM5100_INTERRUPT_STATUS_3_MASK, + snd_soc_component_update_bits(component, WM5100_INTERRUPT_STATUS_3_MASK, WM5100_IM_ACCDET_EINT, 0); } else { - snd_soc_update_bits(codec, WM5100_INTERRUPT_STATUS_3_MASK, + snd_soc_component_update_bits(component, WM5100_INTERRUPT_STATUS_3_MASK, WM5100_IM_HPDET_EINT | WM5100_IM_ACCDET_EINT, WM5100_IM_HPDET_EINT | WM5100_IM_ACCDET_EINT); - snd_soc_update_bits(codec, WM5100_MIC_DETECT_1, + snd_soc_component_update_bits(component, WM5100_MIC_DETECT_1, WM5100_ACCDET_ENA, 0); wm5100->jack = NULL; } @@ -2330,22 +2329,22 @@ static void wm5100_free_gpio(struct i2c_client *i2c) } #endif -static int wm5100_probe(struct snd_soc_codec *codec) +static int wm5100_probe(struct snd_soc_component *component) { - struct snd_soc_dapm_context *dapm = snd_soc_codec_get_dapm(codec); - struct i2c_client *i2c = to_i2c_client(codec->dev); - struct wm5100_priv *wm5100 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component); + struct i2c_client *i2c = to_i2c_client(component->dev); + struct wm5100_priv *wm5100 = snd_soc_component_get_drvdata(component); int ret, i; - wm5100->codec = codec; + wm5100->component = component; for (i = 0; i < ARRAY_SIZE(wm5100_dig_vu); i++) - snd_soc_update_bits(codec, wm5100_dig_vu[i], WM5100_OUT_VU, + snd_soc_component_update_bits(component, wm5100_dig_vu[i], WM5100_OUT_VU, WM5100_OUT_VU); /* Don't debounce interrupts to support use of SYSCLK only */ - snd_soc_write(codec, WM5100_IRQ_DEBOUNCE_1, 0); - snd_soc_write(codec, WM5100_IRQ_DEBOUNCE_2, 0); + snd_soc_component_write(component, WM5100_IRQ_DEBOUNCE_1, 0); + snd_soc_component_write(component, WM5100_IRQ_DEBOUNCE_2, 0); /* TODO: check if we're symmetric */ @@ -2370,34 +2369,30 @@ static int wm5100_probe(struct snd_soc_codec *codec) return ret; } -static int wm5100_remove(struct snd_soc_codec *codec) +static void wm5100_remove(struct snd_soc_component *component) { - struct wm5100_priv *wm5100 = snd_soc_codec_get_drvdata(codec); + struct wm5100_priv *wm5100 = snd_soc_component_get_drvdata(component); if (wm5100->pdata.hp_pol) { gpio_free(wm5100->pdata.hp_pol); } - - return 0; } -static const struct snd_soc_codec_driver soc_codec_dev_wm5100 = { - .probe = wm5100_probe, - .remove = wm5100_remove, - - .set_sysclk = wm5100_set_sysclk, - .set_pll = wm5100_set_fll, - .idle_bias_off = 1, - - .seq_notifier = wm5100_seq_notifier, - .component_driver = { - .controls = wm5100_snd_controls, - .num_controls = ARRAY_SIZE(wm5100_snd_controls), - .dapm_widgets = wm5100_dapm_widgets, - .num_dapm_widgets = ARRAY_SIZE(wm5100_dapm_widgets), - .dapm_routes = wm5100_dapm_routes, - .num_dapm_routes = ARRAY_SIZE(wm5100_dapm_routes), - }, +static const struct snd_soc_component_driver soc_component_dev_wm5100 = { + .probe = wm5100_probe, + .remove = wm5100_remove, + .set_sysclk = wm5100_set_sysclk, + .set_pll = wm5100_set_fll, + .seq_notifier = wm5100_seq_notifier, + .controls = wm5100_snd_controls, + .num_controls = ARRAY_SIZE(wm5100_snd_controls), + .dapm_widgets = wm5100_dapm_widgets, + .num_dapm_widgets = ARRAY_SIZE(wm5100_dapm_widgets), + .dapm_routes = wm5100_dapm_routes, + .num_dapm_routes = ARRAY_SIZE(wm5100_dapm_routes), + .use_pmdown_time = 1, + .endianness = 1, + .non_legacy_dai_naming = 1, }; static const struct regmap_config wm5100_regmap = { @@ -2614,8 +2609,8 @@ static int wm5100_i2c_probe(struct i2c_client *i2c, pm_runtime_enable(&i2c->dev); pm_request_idle(&i2c->dev); - ret = snd_soc_register_codec(&i2c->dev, - &soc_codec_dev_wm5100, wm5100_dai, + ret = devm_snd_soc_register_component(&i2c->dev, + &soc_component_dev_wm5100, wm5100_dai, ARRAY_SIZE(wm5100_dai)); if (ret < 0) { dev_err(&i2c->dev, "Failed to register WM5100: %d\n", ret); @@ -2648,7 +2643,6 @@ static int wm5100_i2c_remove(struct i2c_client *i2c) { struct wm5100_priv *wm5100 = i2c_get_clientdata(i2c); - snd_soc_unregister_codec(&i2c->dev); if (i2c->irq) free_irq(i2c->irq, wm5100); wm5100_free_gpio(i2c); diff --git a/sound/soc/codecs/wm5100.h b/sound/soc/codecs/wm5100.h index 935a9b7fb274..6076493cfd67 100644 --- a/sound/soc/codecs/wm5100.h +++ b/sound/soc/codecs/wm5100.h @@ -17,7 +17,7 @@ #include #include -int wm5100_detect(struct snd_soc_codec *codec, struct snd_soc_jack *jack); +int wm5100_detect(struct snd_soc_component *component, struct snd_soc_jack *jack); #define WM5100_CLK_AIF1 1 #define WM5100_CLK_AIF2 2 diff --git a/sound/soc/codecs/wm8350.c b/sound/soc/codecs/wm8350.c index fc79c6725d06..e92ebe52d485 100644 --- a/sound/soc/codecs/wm8350.c +++ b/sound/soc/codecs/wm8350.c @@ -256,8 +256,8 @@ static void wm8350_pga_work(struct work_struct *work) static int pga_event(struct snd_soc_dapm_widget *w, struct snd_kcontrol *kcontrol, int event) { - struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm); - struct wm8350_data *wm8350_data = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm); + struct wm8350_data *wm8350_data = snd_soc_component_get_drvdata(component); struct wm8350_output *out; switch (w->shift) { @@ -299,8 +299,8 @@ static int pga_event(struct snd_soc_dapm_widget *w, static int wm8350_put_volsw_2r_vu(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); - struct wm8350_data *wm8350_priv = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); + struct wm8350_data *wm8350_priv = snd_soc_component_get_drvdata(component); struct wm8350_output *out = NULL; struct soc_mixer_control *mc = (struct soc_mixer_control *)kcontrol->private_value; @@ -334,16 +334,16 @@ static int wm8350_put_volsw_2r_vu(struct snd_kcontrol *kcontrol, return ret; /* now hit the volume update bits (always bit 8) */ - val = snd_soc_read(codec, reg); - snd_soc_write(codec, reg, val | WM8350_OUT1_VU); + val = snd_soc_component_read32(component, reg); + snd_soc_component_write(component, reg, val | WM8350_OUT1_VU); return 1; } static int wm8350_get_volsw_2r(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); - struct wm8350_data *wm8350_priv = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); + struct wm8350_data *wm8350_priv = snd_soc_component_get_drvdata(component); struct wm8350_output *out1 = &wm8350_priv->out1; struct wm8350_output *out2 = &wm8350_priv->out2; struct soc_mixer_control *mc = @@ -753,8 +753,8 @@ static const struct snd_soc_dapm_route wm8350_dapm_routes[] = { static int wm8350_set_dai_sysclk(struct snd_soc_dai *codec_dai, int clk_id, unsigned int freq, int dir) { - struct snd_soc_codec *codec = codec_dai->codec; - struct wm8350_data *wm8350_data = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = codec_dai->component; + struct wm8350_data *wm8350_data = snd_soc_component_get_drvdata(component); struct wm8350 *wm8350 = wm8350_data->wm8350; u16 fll_4; @@ -769,9 +769,9 @@ static int wm8350_set_dai_sysclk(struct snd_soc_dai *codec_dai, case WM8350_MCLK_SEL_PLL_32K: wm8350_set_bits(wm8350, WM8350_CLOCK_CONTROL_1, WM8350_MCLK_SEL); - fll_4 = snd_soc_read(codec, WM8350_FLL_CONTROL_4) & + fll_4 = snd_soc_component_read32(component, WM8350_FLL_CONTROL_4) & ~WM8350_FLL_CLK_SRC_MASK; - snd_soc_write(codec, WM8350_FLL_CONTROL_4, fll_4 | clk_id); + snd_soc_component_write(component, WM8350_FLL_CONTROL_4, fll_4 | clk_id); break; } @@ -788,44 +788,44 @@ static int wm8350_set_dai_sysclk(struct snd_soc_dai *codec_dai, static int wm8350_set_clkdiv(struct snd_soc_dai *codec_dai, int div_id, int div) { - struct snd_soc_codec *codec = codec_dai->codec; + struct snd_soc_component *component = codec_dai->component; u16 val; switch (div_id) { case WM8350_ADC_CLKDIV: - val = snd_soc_read(codec, WM8350_ADC_DIVIDER) & + val = snd_soc_component_read32(component, WM8350_ADC_DIVIDER) & ~WM8350_ADC_CLKDIV_MASK; - snd_soc_write(codec, WM8350_ADC_DIVIDER, val | div); + snd_soc_component_write(component, WM8350_ADC_DIVIDER, val | div); break; case WM8350_DAC_CLKDIV: - val = snd_soc_read(codec, WM8350_DAC_CLOCK_CONTROL) & + val = snd_soc_component_read32(component, WM8350_DAC_CLOCK_CONTROL) & ~WM8350_DAC_CLKDIV_MASK; - snd_soc_write(codec, WM8350_DAC_CLOCK_CONTROL, val | div); + snd_soc_component_write(component, WM8350_DAC_CLOCK_CONTROL, val | div); break; case WM8350_BCLK_CLKDIV: - val = snd_soc_read(codec, WM8350_CLOCK_CONTROL_1) & + val = snd_soc_component_read32(component, WM8350_CLOCK_CONTROL_1) & ~WM8350_BCLK_DIV_MASK; - snd_soc_write(codec, WM8350_CLOCK_CONTROL_1, val | div); + snd_soc_component_write(component, WM8350_CLOCK_CONTROL_1, val | div); break; case WM8350_OPCLK_CLKDIV: - val = snd_soc_read(codec, WM8350_CLOCK_CONTROL_1) & + val = snd_soc_component_read32(component, WM8350_CLOCK_CONTROL_1) & ~WM8350_OPCLK_DIV_MASK; - snd_soc_write(codec, WM8350_CLOCK_CONTROL_1, val | div); + snd_soc_component_write(component, WM8350_CLOCK_CONTROL_1, val | div); break; case WM8350_SYS_CLKDIV: - val = snd_soc_read(codec, WM8350_CLOCK_CONTROL_1) & + val = snd_soc_component_read32(component, WM8350_CLOCK_CONTROL_1) & ~WM8350_MCLK_DIV_MASK; - snd_soc_write(codec, WM8350_CLOCK_CONTROL_1, val | div); + snd_soc_component_write(component, WM8350_CLOCK_CONTROL_1, val | div); break; case WM8350_DACLR_CLKDIV: - val = snd_soc_read(codec, WM8350_DAC_LR_RATE) & + val = snd_soc_component_read32(component, WM8350_DAC_LR_RATE) & ~WM8350_DACLRC_RATE_MASK; - snd_soc_write(codec, WM8350_DAC_LR_RATE, val | div); + snd_soc_component_write(component, WM8350_DAC_LR_RATE, val | div); break; case WM8350_ADCLR_CLKDIV: - val = snd_soc_read(codec, WM8350_ADC_LR_RATE) & + val = snd_soc_component_read32(component, WM8350_ADC_LR_RATE) & ~WM8350_ADCLRC_RATE_MASK; - snd_soc_write(codec, WM8350_ADC_LR_RATE, val | div); + snd_soc_component_write(component, WM8350_ADC_LR_RATE, val | div); break; default: return -EINVAL; @@ -836,14 +836,14 @@ static int wm8350_set_clkdiv(struct snd_soc_dai *codec_dai, int div_id, int div) static int wm8350_set_dai_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt) { - struct snd_soc_codec *codec = codec_dai->codec; - u16 iface = snd_soc_read(codec, WM8350_AI_FORMATING) & + struct snd_soc_component *component = codec_dai->component; + u16 iface = snd_soc_component_read32(component, WM8350_AI_FORMATING) & ~(WM8350_AIF_BCLK_INV | WM8350_AIF_LRCLK_INV | WM8350_AIF_FMT_MASK); - u16 master = snd_soc_read(codec, WM8350_AI_DAC_CONTROL) & + u16 master = snd_soc_component_read32(component, WM8350_AI_DAC_CONTROL) & ~WM8350_BCLK_MSTR; - u16 dac_lrc = snd_soc_read(codec, WM8350_DAC_LR_RATE) & + u16 dac_lrc = snd_soc_component_read32(component, WM8350_DAC_LR_RATE) & ~WM8350_DACLRC_ENA; - u16 adc_lrc = snd_soc_read(codec, WM8350_ADC_LR_RATE) & + u16 adc_lrc = snd_soc_component_read32(component, WM8350_ADC_LR_RATE) & ~WM8350_ADCLRC_ENA; /* set master/slave audio interface */ @@ -896,10 +896,10 @@ static int wm8350_set_dai_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt) return -EINVAL; } - snd_soc_write(codec, WM8350_AI_FORMATING, iface); - snd_soc_write(codec, WM8350_AI_DAC_CONTROL, master); - snd_soc_write(codec, WM8350_DAC_LR_RATE, dac_lrc); - snd_soc_write(codec, WM8350_ADC_LR_RATE, adc_lrc); + snd_soc_component_write(component, WM8350_AI_FORMATING, iface); + snd_soc_component_write(component, WM8350_AI_DAC_CONTROL, master); + snd_soc_component_write(component, WM8350_DAC_LR_RATE, dac_lrc); + snd_soc_component_write(component, WM8350_ADC_LR_RATE, adc_lrc); return 0; } @@ -907,10 +907,10 @@ static int wm8350_pcm_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *codec_dai) { - struct snd_soc_codec *codec = codec_dai->codec; - struct wm8350_data *wm8350_data = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = codec_dai->component; + struct wm8350_data *wm8350_data = snd_soc_component_get_drvdata(component); struct wm8350 *wm8350 = wm8350_data->wm8350; - u16 iface = snd_soc_read(codec, WM8350_AI_FORMATING) & + u16 iface = snd_soc_component_read32(component, WM8350_AI_FORMATING) & ~WM8350_AIF_WL_MASK; /* bit size */ @@ -928,7 +928,7 @@ static int wm8350_pcm_hw_params(struct snd_pcm_substream *substream, break; } - snd_soc_write(codec, WM8350_AI_FORMATING, iface); + snd_soc_component_write(component, WM8350_AI_FORMATING, iface); /* The sloping stopband filter is recommended for use with * lower sample rates to improve performance. @@ -947,7 +947,7 @@ static int wm8350_pcm_hw_params(struct snd_pcm_substream *substream, static int wm8350_mute(struct snd_soc_dai *dai, int mute) { - struct snd_soc_codec *codec = dai->codec; + struct snd_soc_component *component = dai->component; unsigned int val; if (mute) @@ -955,7 +955,7 @@ static int wm8350_mute(struct snd_soc_dai *dai, int mute) else val = 0; - snd_soc_update_bits(codec, WM8350_DAC_MUTE, WM8350_DAC_MUTE_ENA, val); + snd_soc_component_update_bits(component, WM8350_DAC_MUTE, WM8350_DAC_MUTE_ENA, val); return 0; } @@ -1024,8 +1024,8 @@ static int wm8350_set_fll(struct snd_soc_dai *codec_dai, int pll_id, int source, unsigned int freq_in, unsigned int freq_out) { - struct snd_soc_codec *codec = codec_dai->codec; - struct wm8350_data *priv = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = codec_dai->component; + struct wm8350_data *priv = snd_soc_component_get_drvdata(component); struct wm8350 *wm8350 = priv->wm8350; struct _fll_div fll_div; int ret = 0; @@ -1050,17 +1050,17 @@ static int wm8350_set_fll(struct snd_soc_dai *codec_dai, fll_div.ratio); /* set up N.K & dividers */ - fll_1 = snd_soc_read(codec, WM8350_FLL_CONTROL_1) & + fll_1 = snd_soc_component_read32(component, WM8350_FLL_CONTROL_1) & ~(WM8350_FLL_OUTDIV_MASK | WM8350_FLL_RSP_RATE_MASK | 0xc000); - snd_soc_write(codec, WM8350_FLL_CONTROL_1, + snd_soc_component_write(component, WM8350_FLL_CONTROL_1, fll_1 | (fll_div.div << 8) | 0x50); - snd_soc_write(codec, WM8350_FLL_CONTROL_2, + snd_soc_component_write(component, WM8350_FLL_CONTROL_2, (fll_div.ratio << 11) | (fll_div. n & WM8350_FLL_N_MASK)); - snd_soc_write(codec, WM8350_FLL_CONTROL_3, fll_div.k); - fll_4 = snd_soc_read(codec, WM8350_FLL_CONTROL_4) & + snd_soc_component_write(component, WM8350_FLL_CONTROL_3, fll_div.k); + fll_4 = snd_soc_component_read32(component, WM8350_FLL_CONTROL_4) & ~(WM8350_FLL_FRAC | WM8350_FLL_SLOW_LOCK_REF); - snd_soc_write(codec, WM8350_FLL_CONTROL_4, + snd_soc_component_write(component, WM8350_FLL_CONTROL_4, fll_4 | (fll_div.k ? WM8350_FLL_FRAC : 0) | (fll_div.ratio == 8 ? WM8350_FLL_SLOW_LOCK_REF : 0)); @@ -1074,10 +1074,10 @@ static int wm8350_set_fll(struct snd_soc_dai *codec_dai, return 0; } -static int wm8350_set_bias_level(struct snd_soc_codec *codec, +static int wm8350_set_bias_level(struct snd_soc_component *component, enum snd_soc_bias_level level) { - struct wm8350_data *priv = snd_soc_codec_get_drvdata(codec); + struct wm8350_data *priv = snd_soc_component_get_drvdata(component); struct wm8350 *wm8350 = priv->wm8350; struct wm8350_audio_platform_data *platform = wm8350->codec.platform_data; @@ -1101,7 +1101,7 @@ static int wm8350_set_bias_level(struct snd_soc_codec *codec, break; case SND_SOC_BIAS_STANDBY: - if (snd_soc_codec_get_bias_level(codec) == SND_SOC_BIAS_OFF) { + if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_OFF) { ret = regulator_bulk_enable(ARRAY_SIZE(priv->supplies), priv->supplies); if (ret != 0) @@ -1310,7 +1310,7 @@ static irqreturn_t wm8350_hpr_jack_handler(int irq, void *data) /** * wm8350_hp_jack_detect - Enable headphone jack detection. * - * @codec: WM8350 codec + * @component: WM8350 component * @which: left or right jack detect signal * @jack: jack to report detection events on * @report: value to report @@ -1318,10 +1318,10 @@ static irqreturn_t wm8350_hpr_jack_handler(int irq, void *data) * Enables the headphone jack detection of the WM8350. If no report * is specified then detection is disabled. */ -int wm8350_hp_jack_detect(struct snd_soc_codec *codec, enum wm8350_jack which, +int wm8350_hp_jack_detect(struct snd_soc_component *component, enum wm8350_jack which, struct snd_soc_jack *jack, int report) { - struct wm8350_data *priv = snd_soc_codec_get_drvdata(codec); + struct wm8350_data *priv = snd_soc_component_get_drvdata(component); struct wm8350 *wm8350 = priv->wm8350; int ena; @@ -1389,7 +1389,7 @@ static irqreturn_t wm8350_mic_handler(int irq, void *data) /** * wm8350_mic_jack_detect - Enable microphone jack detection. * - * @codec: WM8350 codec + * @component: WM8350 component * @jack: jack to report detection events on * @detect_report: value to report when presence detected * @short_report: value to report when microphone short detected @@ -1397,11 +1397,11 @@ static irqreturn_t wm8350_mic_handler(int irq, void *data) * Enables the microphone jack detection of the WM8350. If both reports * are specified as zero then detection is disabled. */ -int wm8350_mic_jack_detect(struct snd_soc_codec *codec, +int wm8350_mic_jack_detect(struct snd_soc_component *component, struct snd_soc_jack *jack, int detect_report, int short_report) { - struct wm8350_data *priv = snd_soc_codec_get_drvdata(codec); + struct wm8350_data *priv = snd_soc_component_get_drvdata(component); struct wm8350 *wm8350 = priv->wm8350; priv->mic.jack = jack; @@ -1455,26 +1455,26 @@ static struct snd_soc_dai_driver wm8350_dai = { .ops = &wm8350_dai_ops, }; -static int wm8350_codec_probe(struct snd_soc_codec *codec) +static int wm8350_component_probe(struct snd_soc_component *component) { - struct wm8350 *wm8350 = dev_get_platdata(codec->dev); + struct wm8350 *wm8350 = dev_get_platdata(component->dev); struct wm8350_data *priv; struct wm8350_output *out1; struct wm8350_output *out2; int ret, i; if (wm8350->codec.platform_data == NULL) { - dev_err(codec->dev, "No audio platform data supplied\n"); + dev_err(component->dev, "No audio platform data supplied\n"); return -EINVAL; } - priv = devm_kzalloc(codec->dev, sizeof(struct wm8350_data), + priv = devm_kzalloc(component->dev, sizeof(struct wm8350_data), GFP_KERNEL); if (priv == NULL) return -ENOMEM; - snd_soc_codec_init_regmap(codec, wm8350->regmap); - snd_soc_codec_set_drvdata(codec, priv); + snd_soc_component_init_regmap(component, wm8350->regmap); + snd_soc_component_set_drvdata(component, priv); priv->wm8350 = wm8350; @@ -1497,9 +1497,9 @@ static int wm8350_codec_probe(struct snd_soc_codec *codec) wm8350_set_bits(wm8350, WM8350_POWER_MGMT_5, WM8350_CODEC_ENA); /* Enable robust clocking mode in ADC */ - snd_soc_write(codec, WM8350_SECURITY, 0xa7); - snd_soc_write(codec, 0xde, 0x13); - snd_soc_write(codec, WM8350_SECURITY, 0); + snd_soc_component_write(component, WM8350_SECURITY, 0xa7); + snd_soc_component_write(component, 0xde, 0x13); + snd_soc_component_write(component, WM8350_SECURITY, 0); /* read OUT1 & OUT2 volumes */ out1 = &priv->out1; @@ -1552,10 +1552,10 @@ static int wm8350_codec_probe(struct snd_soc_codec *codec) return 0; } -static int wm8350_codec_remove(struct snd_soc_codec *codec) +static void wm8350_component_remove(struct snd_soc_component *component) { - struct wm8350_data *priv = snd_soc_codec_get_drvdata(codec); - struct wm8350 *wm8350 = dev_get_platdata(codec->dev); + struct wm8350_data *priv = snd_soc_component_get_drvdata(component); + struct wm8350 *wm8350 = dev_get_platdata(component->dev); wm8350_clear_bits(wm8350, WM8350_JACK_DETECT, WM8350_JDL_ENA | WM8350_JDR_ENA); @@ -1578,44 +1578,37 @@ static int wm8350_codec_remove(struct snd_soc_codec *codec) flush_delayed_work(&priv->pga_work); wm8350_clear_bits(wm8350, WM8350_POWER_MGMT_5, WM8350_CODEC_ENA); - - return 0; } -static const struct snd_soc_codec_driver soc_codec_dev_wm8350 = { - .probe = wm8350_codec_probe, - .remove = wm8350_codec_remove, - .set_bias_level = wm8350_set_bias_level, - .suspend_bias_off = true, - - .component_driver = { - .controls = wm8350_snd_controls, - .num_controls = ARRAY_SIZE(wm8350_snd_controls), - .dapm_widgets = wm8350_dapm_widgets, - .num_dapm_widgets = ARRAY_SIZE(wm8350_dapm_widgets), - .dapm_routes = wm8350_dapm_routes, - .num_dapm_routes = ARRAY_SIZE(wm8350_dapm_routes), - }, +static const struct snd_soc_component_driver soc_component_dev_wm8350 = { + .probe = wm8350_component_probe, + .remove = wm8350_component_remove, + .set_bias_level = wm8350_set_bias_level, + .controls = wm8350_snd_controls, + .num_controls = ARRAY_SIZE(wm8350_snd_controls), + .dapm_widgets = wm8350_dapm_widgets, + .num_dapm_widgets = ARRAY_SIZE(wm8350_dapm_widgets), + .dapm_routes = wm8350_dapm_routes, + .num_dapm_routes = ARRAY_SIZE(wm8350_dapm_routes), + .suspend_bias_off = 1, + .idle_bias_on = 1, + .use_pmdown_time = 1, + .endianness = 1, + .non_legacy_dai_naming = 1, }; static int wm8350_probe(struct platform_device *pdev) { - return snd_soc_register_codec(&pdev->dev, &soc_codec_dev_wm8350, + return devm_snd_soc_register_component(&pdev->dev, + &soc_component_dev_wm8350, &wm8350_dai, 1); } -static int wm8350_remove(struct platform_device *pdev) -{ - snd_soc_unregister_codec(&pdev->dev); - return 0; -} - static struct platform_driver wm8350_codec_driver = { .driver = { .name = "wm8350-codec", }, .probe = wm8350_probe, - .remove = wm8350_remove, }; module_platform_driver(wm8350_codec_driver); diff --git a/sound/soc/codecs/wm8350.h b/sound/soc/codecs/wm8350.h index 74108eb82938..1191326c4a61 100644 --- a/sound/soc/codecs/wm8350.h +++ b/sound/soc/codecs/wm8350.h @@ -20,9 +20,9 @@ enum wm8350_jack { WM8350_JDR = 2, }; -int wm8350_hp_jack_detect(struct snd_soc_codec *codec, enum wm8350_jack which, +int wm8350_hp_jack_detect(struct snd_soc_component *component, enum wm8350_jack which, struct snd_soc_jack *jack, int report); -int wm8350_mic_jack_detect(struct snd_soc_codec *codec, +int wm8350_mic_jack_detect(struct snd_soc_component *component, struct snd_soc_jack *jack, int detect_report, int short_report); diff --git a/sound/soc/codecs/wm8400.c b/sound/soc/codecs/wm8400.c index a36adf881bca..57b22065a45d 100644 --- a/sound/soc/codecs/wm8400.c +++ b/sound/soc/codecs/wm8400.c @@ -65,9 +65,9 @@ struct wm8400_priv { int fll_in, fll_out; }; -static void wm8400_codec_reset(struct snd_soc_codec *codec) +static void wm8400_component_reset(struct snd_soc_component *component) { - struct wm8400_priv *wm8400 = snd_soc_codec_get_drvdata(codec); + struct wm8400_priv *wm8400 = snd_soc_component_get_drvdata(component); wm8400_reset_codec_reg_cache(wm8400->wm8400); } @@ -91,7 +91,7 @@ static const DECLARE_TLV_DB_SCALE(out_sidetone_tlv, -3600, 0, 0); static int wm8400_outpga_put_volsw_vu(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { - struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol); + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); struct soc_mixer_control *mc = (struct soc_mixer_control *)kcontrol->private_value; int reg = mc->reg; @@ -103,8 +103,8 @@ static int wm8400_outpga_put_volsw_vu(struct snd_kcontrol *kcontrol, return ret; /* now hit the volume update bits (always bit 8) */ - val = snd_soc_read(codec, reg); - return snd_soc_write(codec, reg, val | 0x0100); + val = snd_soc_component_read32(component, reg); + return snd_soc_component_write(component, reg, val | 0x0100); } #define WM8400_OUTPGA_SINGLE_R_TLV(xname, reg, shift, max, invert, tlv_array) \ @@ -324,7 +324,7 @@ SOC_SINGLE("RIN34 Mute Switch", WM8400_RIGHT_LINE_INPUT_3_4_VOLUME, static int outmixer_event (struct snd_soc_dapm_widget *w, struct snd_kcontrol * kcontrol, int event) { - struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm); + struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm); struct soc_mixer_control *mc = (struct soc_mixer_control *)kcontrol->private_value; u32 reg_shift = mc->shift; @@ -333,7 +333,7 @@ static int outmixer_event (struct snd_soc_dapm_widget *w, switch (reg_shift) { case WM8400_SPEAKER_MIXER | (WM8400_LDSPK << 8) : - reg = snd_soc_read(codec, WM8400_OUTPUT_MIXER1); + reg = snd_soc_component_read32(component, WM8400_OUTPUT_MIXER1); if (reg & WM8400_LDLO) { printk(KERN_WARNING "Cannot set as Output Mixer 1 LDLO Set\n"); @@ -341,7 +341,7 @@ static int outmixer_event (struct snd_soc_dapm_widget *w, } break; case WM8400_SPEAKER_MIXER | (WM8400_RDSPK << 8): - reg = snd_soc_read(codec, WM8400_OUTPUT_MIXER2); + reg = snd_soc_component_read32(component, WM8400_OUTPUT_MIXER2); if (reg & WM8400_RDRO) { printk(KERN_WARNING "Cannot set as Output Mixer 2 RDRO Set\n"); @@ -349,7 +349,7 @@ static int outmixer_event (struct snd_soc_dapm_widget *w, } break; case WM8400_OUTPUT_MIXER1 | (WM8400_LDLO << 8): - reg = snd_soc_read(codec, WM8400_SPEAKER_MIXER); + reg = snd_soc_component_read32(component, WM8400_SPEAKER_MIXER); if (reg & WM8400_LDSPK) { printk(KERN_WARNING "Cannot set as Speaker Mixer LDSPK Set\n"); @@ -357,7 +357,7 @@ static int outmixer_event (struct snd_soc_dapm_widget *w, } break; case WM8400_OUTPUT_MIXER2 | (WM8400_RDRO << 8): - reg = snd_soc_read(codec, WM8400_SPEAKER_MIXER); + reg = snd_soc_component_read32(component, WM8400_SPEAKER_MIXER); if (reg & WM8400_RDSPK) { printk(KERN_WARNING "Cannot set as Speaker Mixer RDSPK Set\n"); @@ -849,8 +849,8 @@ static const struct snd_soc_dapm_route wm8400_dapm_routes[] = { static int wm8400_set_dai_sysclk(struct snd_soc_dai *codec_dai, int clk_id, unsigned int freq, int dir) { - struct snd_soc_codec *codec = codec_dai->codec; - struct wm8400_priv *wm8400 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = codec_dai->component; + struct wm8400_priv *wm8400 = snd_soc_component_get_drvdata(component); wm8400->sysclk = freq; return 0; @@ -938,8 +938,8 @@ static int wm8400_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id, int source, unsigned int freq_in, unsigned int freq_out) { - struct snd_soc_codec *codec = codec_dai->codec; - struct wm8400_priv *wm8400 = snd_soc_codec_get_drvdata(codec); + struct snd_soc_component *component = codec_dai->component; + struct wm8400_priv *wm8400 = snd_soc_component_get_drvdata(component); struct fll_factors factors; int ret; u16 reg; @@ -962,13 +962,13 @@ static int wm8400_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id, wm8400->fll_in = freq_in; /* We *must* disable the FLL before any changes */ - reg = snd_soc_read(codec, WM8400_POWER_MANAGEMENT_2); + reg = snd_soc_component_read32(component, WM8400_POWER_MANAGEMENT_2); reg &= ~WM8400_FLL_ENA; - snd_soc_write(codec, WM8400_POWER_MANAGEMENT_2, reg); + snd_soc_component_write(component, WM8400_POWER_MANAGEMENT_2, reg); - reg = snd_soc_read(codec, WM8400_FLL_CONTROL_1); + reg = snd_soc_component_read32(component, WM8400_FLL_CONTROL_1); reg &= ~WM8400_FLL_OSC_ENA; - snd_soc_write(codec, WM8400_FLL_CONTROL_1, reg); + snd_soc_component_write(component, WM8400_FLL_CONTROL_1, reg); if (!freq_out) return 0; @@ -976,15 +976,15 @@ static int wm8400_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id, reg &= ~(WM8400_FLL_REF_FREQ | WM8400_FLL_FRATIO_MASK); reg |= WM8400_FLL_FRAC | factors.fratio; reg |= factors.freq_ref << WM8400_FLL_REF_FREQ_SHIFT; - snd_soc_write(codec, WM8400_FLL_CONTROL_1, reg); + snd_soc_component_write(component, WM8400_FLL_CONTROL_1, reg); - snd_soc_write(codec, WM8400_FLL_CONTROL_2, factors.k); - snd_soc_write(codec, WM8400_FLL_CONTROL_3, factors.n); + snd_soc_component_write(component, WM8400_FLL_CONTROL_2, factors.k); + snd_soc_component_write(component, WM8400_FLL_CONTROL_3, factors.n); - reg = snd_soc_read(codec, WM8400_FLL_CONTROL_4); + reg = snd_soc_component_read32(component, WM8400_FLL_CONTROL_4); reg &= ~WM8400_FLL_OUTDIV_MASK; reg |= factors.outdiv; - snd_soc_write(codec, WM8400_FLL_CONTROL_4, reg); + snd_soc_component_write(component, WM8400_FLL_CONTROL_4, reg); return 0; } @@ -995,11 +995,11 @@ static int wm8400_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id, static int wm8400_set_dai_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt) { - struct snd_soc_codec *codec = codec_dai->codec; + struct snd_soc_component *component = codec_dai->component; u16 audio1, audio3; - audio1 = snd_soc_read(codec, WM8400_AUDIO_INTERFACE_1); - audio3 = snd_soc_read(codec, WM8400_AUDIO_INTERFACE_3); + audio1 = snd_soc_component_read32(component, WM8400_AUDIO_INTERFACE_1); + audio3 = snd_soc_component_read32(component, WM8400_AUDIO_INTERFACE_3); /* set master/slave audio interface */ switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { @@ -1040,37 +1040,37 @@ static int wm8400_set_dai_fmt(struct snd_soc_dai *codec_dai, return -EINVAL; } - snd_soc_write(codec, WM8400_AUDIO_INTERFACE_1, audio1); - snd_soc_write(codec, WM8400_AUDIO_INTERFACE_3, audio3); + snd_soc_component_write(component, WM8400_AUDIO_INTERFACE_1, audio1); + snd_soc_component_write(component, WM8400_AUDIO_INTERFACE_3, audio3); return 0; } static int wm8400_set_dai_clkdiv(struct snd_soc_dai *codec_dai, int div_id, int div) { - struct snd_soc_codec *codec = codec_dai->codec; + struct snd_soc_component *component = codec_dai->component; u16 reg; switch (div_id) { case WM8400_MCLK_DIV: - reg = snd_soc_read(codec, WM8400_CLOCKING_2) & + reg = snd_soc_component_read32(component, WM8400_CLOCKING_2) & ~WM8400_MCLK_DIV_MASK; - snd_soc_write(codec, WM8400_CLOCKING_2, reg | div); + snd_soc_component_write(component, WM8400_CLOCKING_2, reg | div); break; case WM8400_DACCLK_DIV: - reg = snd_soc_read(codec, WM8400_CLOCKING_2) & + reg = snd_soc_component_read32(component, WM8400_CLOCKING_2) & ~WM8400_DAC_CLKDIV_MASK; - snd_soc_write(codec, WM8400_CLOCKING_2, reg | div); + snd_soc_component_write(component, WM8400_CLOCKING_2, reg | div); break; case WM8400_ADCCLK_DIV: - reg = snd_soc_read(codec, WM8400_CLOCKING_2) & + reg = snd_soc_component_read32(component, WM8400_CLOCKING_2) & ~WM8400_ADC_CLKDIV_MASK; - snd_soc_write(codec, WM8400_CLOCKING_2, reg | div); + snd_soc_component_write(component, WM8400_CLOCKING_2, reg | div); break; case WM8400_BCLK_DIV: - reg = snd_soc_read(codec, WM8400_CLOCKING_1) & + reg = snd_soc_component_read32(component, WM8400_CLOCKING_1) & ~WM8400_BCLK_DIV_MASK; - snd_soc_write(codec, WM8400_CLOCKING_1, reg | div); + snd_soc_component_write(component, WM8400_CLOCKING_1, reg | div); break; default: return -EINVAL; @@ -1086,8 +1086,8 @@ static int wm8400_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { - struct snd_soc_codec *codec = dai->codec; - u16 audio1 = snd_soc_read(codec, WM8400_AUDIO_INTERFACE_1); + struct snd_soc_component *component = dai->component; + u16 audio1 = snd_soc_component_read32(component, WM8400_AUDIO_INTERFACE_1); audio1 &= ~WM8400_AIF_WL_MASK; /* bit size */ @@ -1105,28 +1105,28 @@ static int wm8400_hw_params(struct snd_pcm_substream *substream, break; } - snd_soc_write(codec, WM8400_AUDIO_INTERFACE_1, audio1); + snd_soc_component_write(component, WM8400_AUDIO_INTERFACE_1, audio1); return 0; } static int wm8400_mute(struct snd_soc_dai *dai, int mute) { - struct snd_soc_codec *codec = dai->codec; - u16 val = snd_soc_read(codec, WM8400_DAC_CTRL) & ~WM8400_DAC_MUTE; + struct snd_soc_component *component = dai->component; + u16 val = snd_soc_component_read32(component, WM8400_DAC_CTRL) & ~WM8400_DAC_MUTE; if (mute) - snd_soc_write(codec, WM8400_DAC_CTRL, val | WM8400_DAC_MUTE); + snd_soc_component_write(component, WM8400_DAC_CTRL, val | WM8400_DAC_MUTE); else - snd_soc_write(codec, WM8400_DAC_CTRL, val); + snd_soc_component_write(component, WM8400_DAC_CTRL, val); return 0; } /* TODO: set bias for best performance at standby */ -static int wm8400_set_bias_level(struct snd_soc_codec *codec, +static int wm8400_set_bias_level(struct snd_soc_component *component, enum snd_soc_bias_level level) { - struct wm8400_priv *wm8400 = snd_soc_codec_get_drvdata(codec); + struct wm8400_priv *wm8400 = snd_soc_component_get_drvdata(component); u16 val; int ret; @@ -1136,13 +1136,13 @@ static int wm8400_set_bias_level(struct snd_soc_codec *codec, case SND_SOC_BIAS_PREPARE: /* VMID=2*50k */ - val = snd_soc_read(codec, WM8400_POWER_MANAGEMENT_1) & + val = snd_soc_component_read32(component, WM8400_POWER_MANAGEMENT_1) & ~WM8400_VMID_MODE_MASK; - snd_soc_write(codec, WM8400_POWER_MANAGEMENT_1, val | 0x2); + snd_soc_component_write(component, WM8400_POWER_MANAGEMENT_1, val | 0x2); break; case SND_SOC_BIAS_STANDBY: - if (snd_soc_codec_get_bias_level(codec) == SND_SOC_BIAS_OFF) { + if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_OFF) { ret = regulator_bulk_enable(ARRAY_SIZE(power), &power[0]); if (ret != 0) { @@ -1152,74 +1152,74 @@ static int wm8400_set_bias_level(struct snd_soc_codec *codec, return ret; } - snd_soc_write(codec, WM8400_POWER_MANAGEMENT_1, + snd_soc_component_write(component, WM8400_POWER_MANAGEMENT_1, WM8400_CODEC_ENA | WM8400_SYSCLK_ENA); /* Enable POBCTRL, SOFT_ST, VMIDTOG and BUFDCOPEN */ - snd_soc_write(codec, WM8400_ANTIPOP2, WM8400_SOFTST | + snd_soc_component_write(component, WM8400_ANTIPOP2, WM8400_SOFTST | WM8400_BUFDCOPEN | WM8400_POBCTRL); msleep(50); /* Enable VREF & VMID at 2x50k */ - val = snd_soc_read(codec, WM8400_POWER_MANAGEMENT_1); + val = snd_soc_component_read32(component, WM8400_POWER_MANAGEMENT_1); val |= 0x2 | WM8400_VREF_ENA; - snd_soc_write(codec, WM8400_POWER_MANAGEMENT_1, val); + snd_soc_component_write(component, WM8400_POWER_MANAGEMENT_1, val); /* Enable BUFIOEN */ - snd_soc_write(codec, WM8400_ANTIPOP2, WM8400_SOFTST | + snd_soc_component_write(component, WM8400_ANTIPOP2, WM8400_SOFTST | WM8400_BUFDCOPEN | WM8400_POBCTRL | WM8400_BUFIOEN); /* disable POBCTRL, SOFT_ST and BUFDCOPEN */ - snd_soc_write(codec, WM8400_ANTIPOP2, WM8400_BUFIOEN); + snd_soc_component_write(component, WM8400_ANTIPOP2, WM8400_BUFIOEN); } /* VMID=2*300k */ - val = snd_soc_read(codec, WM8400_POWER_MANAGEMENT_1) & + val = snd_soc_component_read32(component, WM8400_POWER_MANAGEMENT_1) & ~WM8400_VMID_MODE_MASK; - snd_soc_write(codec, WM8400_POWER_MANAGEMENT_1, val | 0x4); + snd_soc_component_write(component, WM8400_POWER_MANAGEMENT_1, val | 0x4); break; case SND_SOC_BIAS_OFF: /* Enable POBCTRL and SOFT_ST */ - snd_soc_write(codec, WM8400_ANTIPOP2, WM8400_SOFTST | + snd_soc_component_write(component, WM8400_ANTIPOP2, WM8400_SOFTST | WM8400_POBCTRL | WM8400_BUFIOEN); /* Enable POBCTRL, SOFT_ST and BUFDCOPEN */ - snd_soc_write(codec, WM8400_ANTIPOP2, WM8400_SOFTST | + snd_soc_component_write(component, WM8400_ANTIPOP2, WM8400_SOFTST | WM8400_BUFDCOPEN | WM8400_POBCTRL | WM8400_BUFIOEN); /* mute DAC */ - val = snd_soc_read(codec, WM8400_DAC_CTRL); - snd_soc_write(codec, WM8400_DAC_CTRL, val | WM8400_DAC_MUTE); + val = snd_soc_component_read32(component, WM8400_DAC_CTRL); + snd_soc_component_write(component, WM8400_DAC_CTRL, val | WM8400_DAC_MUTE); /* Enable any disabled outputs */ - val = snd_soc_read(codec, WM8400_POWER_MANAGEMENT_1); + val = snd_soc_component_read32(component, WM8400_POWER_MANAGEMENT_1); val |= WM8400_SPK_ENA | WM8400_OUT3_ENA | WM8400_OUT4_ENA | WM8400_LOUT_ENA | WM8400_ROUT_ENA; - snd_soc_write(codec, WM8400_POWER_MANAGEMENT_1, val); + snd_soc_component_write(component, WM8400_POWER_MANAGEMENT_1, val); /* Disable VMID */ val &= ~WM8400_VMID_MODE_MASK; - snd_soc_write(codec, WM8400_POWER_MANAGEMENT_1, val); + snd_soc_component_write(component, WM8400_POWER_MANAGEMENT_1, val); msleep(300); /* Enable all output discharge bits */ - snd_soc_write(codec, WM8400_ANTIPOP1, WM8400_DIS_LLINE | + snd_soc_component_write(component, WM8400_ANTIPOP1, WM8400_DIS_LLINE | WM8400_DIS_RLINE | WM8400_DIS_OUT3 | WM8400_DIS_OUT4 | WM8400_DIS_LOUT | WM8400_DIS_ROUT); /* Disable VREF */ val &= ~WM8400_VREF_ENA; - snd_soc_write(codec, WM8400_POWER_MANAGEMENT_1, val); + snd_soc_component_write(component, WM8400_POWER_MANAGEMENT_1, val); /* disable POBCTRL, SOFT_ST and BUFDCOPEN */ - snd_soc_write(codec, WM8400_ANTIPOP2, 0x0); + snd_soc_component_write(component, WM8400_ANTIPOP2, 0x0); ret = regulator_bulk_disable(ARRAY_SIZE(power), &power[0]); @@ -1273,93 +1273,86 @@ static struct snd_soc_dai_driver wm8400_dai = { .ops = &wm8400_dai_ops, }; -static int wm8400_codec_probe(struct snd_soc_codec *codec) +static int wm8400_component_probe(struct snd_soc_component *component) { - struct wm8400 *wm8400 = dev_get_platdata(codec->dev); + struct wm8400 *wm8400 = dev_get_platdata(component->dev); struct wm8400_priv *priv; int ret; u16 reg; - priv = devm_kzalloc(codec->dev, sizeof(struct wm8400_priv), + priv = devm_kzalloc(component->dev, sizeof(struct wm8400_priv), GFP_KERNEL); if (priv == NULL) return -ENOMEM; - snd_soc_codec_init_regmap(codec, wm8400->regmap); - snd_soc_codec_set_drvdata(codec, priv); + snd_soc_component_init_regmap(component, wm8400->regmap); + snd_soc_component_set_drvdata(component, priv); priv->wm8400 = wm8400; ret = devm_regulator_bulk_get(wm8400->dev, ARRAY_SIZE(power), &power[0]); if (ret != 0) { - dev_err(codec->dev, "Failed to get regulators: %d\n", ret); + dev_err(component->dev, "Failed to get regulators: %d\n", ret); return ret; } - wm8400_codec_reset(codec); + wm8400_component_reset(component); - reg = snd_soc_read(codec, WM8400_POWER_MANAGEMENT_1); - snd_soc_write(codec, WM8400_POWER_MANAGEMENT_1, reg | WM8400_CODEC_ENA); + reg = snd_soc_component_read32(component, WM8400_POWER_MANAGEMENT_1); + snd_soc_component_write(component, WM8400_POWER_MANAGEMENT_1, reg | WM8400_CODEC_ENA); /* Latch volume update bits */ - reg = snd_soc_read(codec, WM8400_LEFT_LINE_INPUT_1_2_VOLUME); - snd_soc_write(codec, WM8400_LEFT_LINE_INPUT_1_2_VOLUME, + reg = snd_soc_component_read32(component, WM8400_LEFT_LINE_INPUT_1_2_VOLUME); + snd_soc_component_write(component, WM8400_LEFT_LINE_INPUT_1_2_VOLUME, reg & WM8400_IPVU); - reg = snd_soc_read(codec, WM8400_RIGHT_LINE_INPUT_1_2_VOLUME); - snd_soc_write(codec, WM8400_RIGHT_LINE_INPUT_1_2_VOLUME, + reg = snd_soc_component_read32(component, WM8400_RIGHT_LINE_INPUT_1_2_VOLUME); + snd_soc_component_write(component, WM8400_RIGHT_LINE_INPUT_1_2_VOLUME, reg & WM8400_IPVU); - snd_soc_write(codec, WM8400_LEFT_OUTPUT_VOLUME, 0x50 | (1<<8)); - snd_soc_write(codec, WM8400_RIGHT_OUTPUT_VOLUME, 0x50 | (1<<8)); + snd_soc_component_write(component, WM8400_LEFT_OUTPUT_VOLUME, 0x50 | (1<<8)); + snd_soc_component_write(component, WM8400_RIGHT_OUTPUT_VOLUME, 0x50 | (1<<8)); return 0; } -static int wm8400_codec_remove(struct snd_soc_codec *codec) +static void wm8400_component_remove(struct snd_soc_component *component) { u16 reg; - reg = snd_soc_read(codec, WM8400_POWER_MANAGEMENT_1); - snd_soc_write(codec, WM8400_POWER_MANAGEMENT_1, + reg = snd_soc_component_read32(component, WM8400_POWER_MANAGEMENT_1); + snd_soc_component_write(component, WM8400_POWER_MANAGEMENT_1, reg & (~WM8400_CODEC_ENA)); - - return 0; } -static const struct snd_soc_codec_driver soc_codec_dev_wm8400 = { - .probe = wm8400_codec_probe, - .remove = wm8400_codec_remove, - .set_bias_level = wm8400_set_bias_level, - .suspend_bias_off = true, - - .component_driver = { - .controls = wm8400_snd_controls, - .num_controls = ARRAY_SIZE(wm8400_snd_controls), - .dapm_widgets = wm8400_dapm_widgets, - .num_dapm_widgets = ARRAY_SIZE(wm8400_dapm_widgets), - .dapm_routes = wm8400_dapm_routes, - .num_dapm_routes = ARRAY_SIZE(wm8400_dapm_routes), - }, +static const struct snd_soc_component_driver soc_component_dev_wm8400 = { + .probe = wm8400_component_probe, + .remove = wm8400_component_remove, + .set_bias_level = wm8400_set_bias_level, + .controls = wm8400_snd_controls, + .num_controls = ARRAY_SIZE(wm8400_snd_controls), + .dapm_widgets = wm8400_dapm_widgets, + .num_dapm_widgets = ARRAY_SIZE(wm8400_dapm_widgets), + .dapm_routes = wm8400_dapm_routes, + .num_dapm_routes = ARRAY_SIZE(wm8400_dapm_routes), + .suspend_bias_off = 1, + .idle_bias_on = 1, + .use_pmdown_time = 1, + .endianness = 1, + .non_legacy_dai_naming = 1, }; static int wm8400_probe(struct platform_device *pdev) { - return snd_soc_register_codec(&pdev->dev, &soc_codec_dev_wm8400, + return devm_snd_soc_register_component(&pdev->dev, + &soc_component_dev_wm8400, &wm8400_dai, 1); } -static int wm8400_remove(struct platform_device *pdev) -{ - snd_soc_unregister_codec(&pdev->dev); - return 0; -} - static struct platform_driver wm8400_codec_driver = { .driver = { .name = "wm8400-codec", }, .probe = wm8400_probe, - .remove = wm8400_remove, }; module_platform_driver(wm8400_codec_driver); diff --git a/sound/soc/codecs/wm8510.c b/sound/soc/codecs/wm8510.c index 119ceac684ae..1a2412d73e35 100644 --- a/sound/soc/codecs/wm8510.c +++ b/sound/soc/codecs/wm8510.c @@ -106,7 +106,7 @@ static bool wm8510_volatile(struct device *dev, unsigned int reg) #define WM8510_POWER1_BIASEN 0x08 #define WM8510_POWER1_BUFIOEN 0x10 -#define wm8510_reset(c) snd_soc_write(c, WM8510_RESET, 0) +#define wm8510_reset(c) snd_soc_component_write(c, WM8510_RESET, 0) /* codec private data */ struct wm8510_priv { @@ -316,32 +316,32 @@ static void pll_factors(unsigned int target, unsigned int source) static int wm8510_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id, int source, unsigned int freq_in, unsigned int freq_out) { - struct snd_soc_codec *codec = codec_dai->codec; + struct snd_soc_component *component = codec_dai->component; u16 reg; if (freq_in == 0 || freq_out == 0) { /* Clock CODEC directly from MCLK */ - reg = snd_soc_read(codec, WM8510_CLOCK); - snd_soc_write(codec, WM8510_CLOCK, reg & 0x0ff); + reg = snd_soc_component_read32(component, WM8510_CLOCK); + snd_soc_component_write(component, WM8510_CLOCK, reg & 0x0ff); /* Turn off PLL */ - reg = snd_soc_read(codec, WM8510_POWER1); - snd_soc_write(codec, WM8510_POWER1, reg & 0x1df); + reg = snd_soc_component_read32(component, WM8510_POWER1); + snd_soc_component_write(component, WM8510_POWER1, reg & 0x1df); return 0; } pll_factors(freq_out*4, freq_in); - snd_soc_write(codec, WM8510_PLLN, (pll_div.pre_div << 4) | pll_div.n); - snd_soc_write(codec, WM8510_PLLK1, pll_div.k >> 18); - snd_soc_write(codec, WM8510_PLLK2, (pll_div.k >> 9) & 0x1ff); - snd_soc_write(codec, WM8510_PLLK3, pll_div.k & 0x1ff); - reg = snd_soc_read(codec, WM8510_POWER1); - snd_soc_write(codec, WM8510_POWER1, reg | 0x020); + snd_soc_component_write(component, WM8510_PLLN, (pll_div.pre_div << 4) | pll_div.n); + snd_soc_component_write(component, WM8510_PLLK1, pll_div.k >> 18); + snd_soc_component_write(component, WM8510_PLLK2, (pll_div.k >> 9) & 0x1ff); + snd_soc_component_write(component, WM8510_PLLK3, pll_div.k & 0x1ff); + reg = snd_soc_component_read32(component, WM8510_POWER1); + snd_soc_component_write(component, WM8510_POWER1, reg | 0x020); /* Run CODEC from PLL instead of MCLK */ - reg = snd_soc_read(codec, WM8510_CLOCK); - snd_soc_write(codec, WM8510_CLOCK, reg | 0x100); + reg = snd_soc_component_read32(component, WM8510_CLOCK); + snd_soc_component_write(component, WM8510_CLOCK, reg | 0x100); return 0; } @@ -352,29 +352,29 @@ static int wm8510_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id, static int wm8510_set_dai_clkdiv(struct snd_soc_dai *codec_dai, int div_id, int div) { - struct snd_soc_codec *codec = codec_dai->codec; + struct snd_soc_component *component = codec_dai->component; u16 reg; switch (div_id) { case WM8510_OPCLKDIV: - reg = snd_soc_read(codec, WM8510_GPIO) & 0x1cf; - snd_soc_write(codec, WM8510_GPIO, reg | div); + reg = snd_soc_component_read32(component, WM8510_GPIO) & 0x1cf; + snd_soc_component_write(component, WM8510_GPIO, reg | div); break; case WM8510_MCLKDIV: - reg = snd_soc_read(codec, WM8510_CLOCK) & 0x11f; - snd_soc_write(codec, WM8510_CLOCK, reg | div); + reg = snd_soc_component_read32(component, WM8510_CLOCK) & 0x11f; + snd_soc_component_write(component, WM8510_CLOCK, reg | div); break; case WM8510_ADCCLK: - reg = snd_soc_read(codec, WM8510_ADC) & 0x1f7; - snd_soc_write(codec, WM8510_ADC, reg | div); + reg = snd_soc_component_read32(component, WM8510_ADC) & 0x1f7; + snd_soc_component_write(component, WM8510_ADC, reg | div); break; case WM8510_DACCLK: - reg = snd_soc_read(codec, WM8510_DAC) & 0x1f7; - snd_soc_write(codec, WM8510_DAC, reg | div); + reg = snd_soc_component_read32(component, WM8510_DAC) & 0x1f7; + snd_soc_component_write(component, WM8510_DAC, reg | div); break; case WM8510_BCLKDIV: - reg = snd_soc_read(codec, WM8510_CLOCK) & 0x1e3; - snd_soc_write(codec, WM8510_CLOCK, reg | div); + reg = snd_soc_component_read32(component, WM8510_CLOCK) & 0x1e3; + snd_soc_component_write(component, WM8510_CLOCK, reg | div); break; default: return -EINVAL; @@ -386,9 +386,9 @@ static int wm8510_set_dai_clkdiv(struct snd_soc_dai *codec_dai, static int wm8510_set_dai_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt) { - struct snd_soc_codec *codec = codec_dai->codec; + struct snd_soc_component *component = codec_dai->component; u16 iface = 0; - u16 clk = snd_soc_read(codec, WM8510_CLOCK) & 0x1fe; + u16 clk = snd_soc_component_read32(component, WM8510_CLOCK) & 0x1fe; /* set master/slave audio interface */ switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { @@ -435,8 +435,8 @@ static int wm8510_set_dai_fmt(struct snd_soc_dai *codec_dai, return -EINVAL; } - snd_soc_write(codec, WM8510_IFACE, iface); - snd_soc_write(codec, WM8510_CLOCK, clk); + snd_soc_component_write(component, WM8510_IFACE, iface); + snd_soc_component_write(component, WM8510_CLOCK, clk); return 0; } @@ -444,9 +444,9 @@ static int wm8510_pcm_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { - struct snd_soc_codec *codec = dai->codec; - u16 iface = snd_soc_read(codec, WM8510_IFACE) & 0x19f; - u16 adn = snd_soc_read(codec, WM8510_ADD) & 0x1f1; + struct snd_soc_component *component = dai->component; + u16 iface = snd_soc_component_read32(component, WM8510_IFACE) & 0x19f; + u16 adn = snd_soc_component_read32(component, WM8510_ADD) & 0x1f1; /* bit size */ switch (params_width(params)) { @@ -485,56 +485,56 @@ static int wm8510_pcm_hw_params(struct snd_pcm_substream *substream, break; } - snd_soc_write(codec, WM8510_IFACE, iface); - snd_soc_write(codec, WM8510_ADD, adn); + snd_soc_component_write(component, WM8510_IFACE, iface); + snd_soc_component_write(component, WM8510_ADD, adn); return 0; } static int wm8510_mute(struct snd_soc_dai *dai, int mute) { - struct snd_soc_codec *codec = dai->codec; - u16 mute_reg = snd_soc_read(codec, WM8510_DAC) & 0xffbf; + struct snd_soc_component *component = dai->component; + u16 mute_reg = snd_soc_component_read32(component, WM8510_DAC) & 0xffbf; if (mute) - snd_soc_write(codec, WM8510_DAC, mute_reg | 0x40); + snd_soc_component_write(component, WM8510_DAC, mute_reg | 0x40); else - snd_soc_write(codec, WM8510_DAC, mute_reg); + snd_soc_component_write(component, WM8510_DAC, mute_reg); return 0; } /* liam need to make this lower power with dapm */ -static int wm8510_set_bias_level(struct snd_soc_codec *codec, +static int wm8510_set_bias_level(struct snd_soc_component *component, enum snd_soc_bias_level level) { - struct wm8510_priv *wm8510 = snd_soc_codec_get_drvdata(codec); - u16 power1 = snd_soc_read(codec, WM8510_POWER1) & ~0x3; + struct wm8510_priv *wm8510 = snd_soc_component_get_drvdata(component); + u16 power1 = snd_soc_component_read32(component, WM8510_POWER1) & ~0x3; switch (level) { case SND_SOC_BIAS_ON: case SND_SOC_BIAS_PREPARE: power1 |= 0x1; /* VMID 50k */ - snd_soc_write(codec, WM8510_POWER1, power1); + snd_soc_component_write(component, WM8510_POWER1, power1); break; case SND_SOC_BIAS_STANDBY: power1 |= WM8510_POWER1_BIASEN | WM8510_POWER1_BUFIOEN; - if (snd_soc_codec_get_bias_level(codec) == SND_SOC_BIAS_OFF) { + if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_OFF) { regcache_sync(wm8510->regmap); /* Initial cap charge at VMID 5k */ - snd_soc_write(codec, WM8510_POWER1, power1 | 0x3); + snd_soc_component_write(component, WM8510_POWER1, power1 | 0x3); mdelay(100); } power1 |= 0x2; /* VMID 500k */ - snd_soc_write(codec, WM8510_POWER1, power1); + snd_soc_component_write(component, WM8510_POWER1, power1); break; case SND_SOC_BIAS_OFF: - snd_soc_write(codec, WM8510_POWER1, 0); - snd_soc_write(codec, WM8510_POWER2, 0); - snd_soc_write(codec, WM8510_POWER3, 0); + snd_soc_component_write(component, WM8510_POWER1, 0); + snd_soc_component_write(component, WM8510_POWER2, 0); + snd_soc_component_write(component, WM8510_POWER3, 0); break; } @@ -574,26 +574,27 @@ static struct snd_soc_dai_driver wm8510_dai = { .symmetric_rates = 1, }; -static int wm8510_probe(struct snd_soc_codec *codec) +static int wm8510_probe(struct snd_soc_component *component) { - wm8510_reset(codec); + wm8510_reset(component); return 0; } -static const struct snd_soc_codec_driver soc_codec_dev_wm8510 = { - .probe = wm8510_probe, - .set_bias_level = wm8510_set_bias_level, - .suspend_bias_off = true, - - .component_driver = { - .controls = wm8510_snd_controls, - .num_controls = ARRAY_SIZE(wm8510_snd_controls), - .dapm_widgets = wm8510_dapm_widgets, - .num_dapm_widgets = ARRAY_SIZE(wm8510_dapm_widgets), - .dapm_routes = wm8510_dapm_routes, - .num_dapm_routes = ARRAY_SIZE(wm8510_dapm_routes), - }, +static const struct snd_soc_component_driver soc_component_dev_wm8510 = { + .probe = wm8510_probe, + .set_bias_level = wm8510_set_bias_level, + .controls = wm8510_snd_controls, + .num_controls = ARRAY_SIZE(wm8510_snd_controls), + .dapm_widgets = wm8510_dapm_widgets, + .num_dapm_widgets = ARRAY_SIZE(wm8510_dapm_widgets), + .dapm_routes = wm8510_dapm_routes, + .num_dapm_routes = ARRAY_SIZE(wm8510_dapm_routes), + .suspend_bias_off = 1, + .idle_bias_on = 1, + .use_pmdown_time = 1, + .endianness = 1, + .non_legacy_dai_naming = 1, }; static const struct of_device_id wm8510_of_match[] = { @@ -631,25 +632,18 @@ static int wm8510_spi_probe(struct spi_device *spi) spi_set_drvdata(spi, wm8510); - ret = snd_soc_register_codec(&spi->dev, - &soc_codec_dev_wm8510, &wm8510_dai, 1); + ret = devm_snd_soc_register_component(&spi->dev, + &soc_component_dev_wm8510, &wm8510_dai, 1); return ret; } -static int wm8510_spi_remove(struct spi_device *spi) -{ - snd_soc_unregister_codec(&spi->dev); - return 0; -} - static struct spi_driver wm8510_spi_driver = { .driver = { .name = "wm8510", .of_match_table = wm8510_of_match, }, .probe = wm8510_spi_probe, - .remove = wm8510_spi_remove, }; #endif /* CONFIG_SPI_MASTER */ @@ -671,18 +665,12 @@ static int wm8510_i2c_probe(struct i2c_client *i2c, i2c_set_clientdata(i2c, wm8510); - ret = snd_soc_register_codec(&i2c->dev, - &soc_codec_dev_wm8510, &wm8510_dai, 1); + ret = devm_snd_soc_register_component(&i2c->dev, + &soc_component_dev_wm8510, &wm8510_dai, 1); return ret; } -static int wm8510_i2c_remove(struct i2c_client *client) -{ - snd_soc_unregister_codec(&client->dev); - return 0; -} - static const struct i2c_device_id wm8510_i2c_id[] = { { "wm8510", 0 }, { } @@ -695,7 +683,6 @@ static struct i2c_driver wm8510_i2c_driver = { .of_match_table = wm8510_of_match, }, .probe = wm8510_i2c_probe, - .remove = wm8510_i2c_remove, .id_table = wm8510_i2c_id, }; #endif diff --git a/sound/soc/fsl/wm1133-ev1.c b/sound/soc/fsl/wm1133-ev1.c index cdaf16367b47..2f80b21b2921 100644 --- a/sound/soc/fsl/wm1133-ev1.c +++ b/sound/soc/fsl/wm1133-ev1.c @@ -201,18 +201,18 @@ static struct snd_soc_jack_pin mic_jack_pins[] = { static int wm1133_ev1_init(struct snd_soc_pcm_runtime *rtd) { - struct snd_soc_codec *codec = rtd->codec; + struct snd_soc_component *component = rtd->codec_dai->component; /* Headphone jack detection */ snd_soc_card_jack_new(rtd->card, "Headphone", SND_JACK_HEADPHONE, &hp_jack, hp_jack_pins, ARRAY_SIZE(hp_jack_pins)); - wm8350_hp_jack_detect(codec, WM8350_JDR, &hp_jack, SND_JACK_HEADPHONE); + wm8350_hp_jack_detect(component, WM8350_JDR, &hp_jack, SND_JACK_HEADPHONE); /* Microphone jack detection */ snd_soc_card_jack_new(rtd->card, "Microphone", SND_JACK_MICROPHONE | SND_JACK_BTN_0, &mic_jack, mic_jack_pins, ARRAY_SIZE(mic_jack_pins)); - wm8350_mic_jack_detect(codec, &mic_jack, SND_JACK_MICROPHONE, + wm8350_mic_jack_detect(component, &mic_jack, SND_JACK_MICROPHONE, SND_JACK_BTN_0); snd_soc_dapm_force_enable_pin(&rtd->card->dapm, "Mic Bias"); diff --git a/sound/soc/samsung/lowland.c b/sound/soc/samsung/lowland.c index 0d0f58208b75..c9081f42f373 100644 --- a/sound/soc/samsung/lowland.c +++ b/sound/soc/samsung/lowland.c @@ -37,10 +37,10 @@ static struct snd_soc_jack_pin lowland_headset_pins[] = { static int lowland_wm5100_init(struct snd_soc_pcm_runtime *rtd) { - struct snd_soc_codec *codec = rtd->codec; + struct snd_soc_component *component = rtd->codec_dai->component; int ret; - ret = snd_soc_codec_set_sysclk(codec, WM5100_CLK_SYSCLK, + ret = snd_soc_component_set_sysclk(component, WM5100_CLK_SYSCLK, WM5100_CLKSRC_MCLK1, MCLK1_RATE, SND_SOC_CLOCK_IN); if (ret < 0) { @@ -49,7 +49,7 @@ static int lowland_wm5100_init(struct snd_soc_pcm_runtime *rtd) } /* Clock OPCLK, used by the other audio components. */ - ret = snd_soc_codec_set_sysclk(codec, WM5100_CLK_OPCLK, 0, + ret = snd_soc_component_set_sysclk(component, WM5100_CLK_OPCLK, 0, CLKOUT_RATE, 0); if (ret < 0) { pr_err("Failed to set OPCLK rate: %d\n", ret); @@ -63,19 +63,19 @@ static int lowland_wm5100_init(struct snd_soc_pcm_runtime *rtd) if (ret) return ret; - wm5100_detect(codec, &lowland_headset); + wm5100_detect(component, &lowland_headset); return 0; } static int lowland_wm9081_init(struct snd_soc_pcm_runtime *rtd) { - struct snd_soc_codec *codec = rtd->codec; + struct snd_soc_component *component = rtd->codec_dai->component; snd_soc_dapm_nc_pin(&rtd->card->dapm, "LINEOUT"); /* At any time the WM9081 is active it will have this clock */ - return snd_soc_codec_set_sysclk(codec, WM9081_SYSCLK_MCLK, 0, + return snd_soc_component_set_sysclk(component, WM9081_SYSCLK_MCLK, 0, CLKOUT_RATE, 0); }