leandrof/linux
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge remote-tracking branches 'asoc/topic/max98090', 'asoc/topic/max98095', 'asoc/topic/max98357a', 'asoc/topic/max98371' and 'asoc/topic/max98373' into asoc-next

Browse Source
This commit is contained in:
Mark Brown 2018-03-28 10:29:56 +08:00
commit 5c5bb9a245
No known key found for this signature in database
GPG Key ID: 24D68B725D5487D0
10 changed files with 456 additions and 471 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Documentation/devicetree/bindings/sound/max98090.txt
View File

@ -16,6 +16,8 @@ Optional properties:
- clock-names: Should be "mclk" - clock-names: Should be "mclk"
- #sound-dai-cells : should be 0.
- maxim,dmic-freq: Frequency at which to clock DMIC - maxim,dmic-freq: Frequency at which to clock DMIC
- maxim,micbias: Micbias voltage applies to the analog mic, valid voltages value are: - maxim,micbias: Micbias voltage applies to the analog mic, valid voltages value are:

319
sound/soc/codecs/max98090.c
View File

@ -284,7 +284,7 @@ static int max98090_reset(struct max98090_priv *max98090)
ret = regmap_write(max98090->regmap, M98090_REG_SOFTWARE_RESET, ret = regmap_write(max98090->regmap, M98090_REG_SOFTWARE_RESET,
M98090_SWRESET_MASK); M98090_SWRESET_MASK);
if (ret < 0) { if (ret < 0) {
dev_err(max98090->codec->dev, dev_err(max98090->component->dev,
"Failed to reset codec: %d\n", ret); "Failed to reset codec: %d\n", ret);
return ret; return ret;
} }
@ -354,12 +354,12 @@ static const DECLARE_TLV_DB_RANGE(max98090_rcv_lout_tlv,
static int max98090_get_enab_tlv(struct snd_kcontrol *kcontrol, static int max98090_get_enab_tlv(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol) 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 max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec); struct max98090_priv *max98090 = snd_soc_component_get_drvdata(component);
struct soc_mixer_control *mc = struct soc_mixer_control *mc =
(struct soc_mixer_control *)kcontrol->private_value; (struct soc_mixer_control *)kcontrol->private_value;
unsigned int mask = (1 << fls(mc->max)) - 1; unsigned int mask = (1 << fls(mc->max)) - 1;
unsigned int val = snd_soc_read(codec, mc->reg); unsigned int val = snd_soc_component_read32(component, mc->reg);
unsigned int *select; unsigned int *select;
switch (mc->reg) { switch (mc->reg) {
@ -394,13 +394,13 @@ static int max98090_get_enab_tlv(struct snd_kcontrol *kcontrol,
static int max98090_put_enab_tlv(struct snd_kcontrol *kcontrol, static int max98090_put_enab_tlv(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol) 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 max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec); struct max98090_priv *max98090 = snd_soc_component_get_drvdata(component);
struct soc_mixer_control *mc = struct soc_mixer_control *mc =
(struct soc_mixer_control *)kcontrol->private_value; (struct soc_mixer_control *)kcontrol->private_value;
unsigned int mask = (1 << fls(mc->max)) - 1; unsigned int mask = (1 << fls(mc->max)) - 1;
unsigned int sel = ucontrol->value.integer.value[0]; unsigned int sel = ucontrol->value.integer.value[0];
unsigned int val = snd_soc_read(codec, mc->reg); unsigned int val = snd_soc_component_read32(component, mc->reg);
unsigned int *select; unsigned int *select;
switch (mc->reg) { switch (mc->reg) {
@ -429,7 +429,7 @@ static int max98090_put_enab_tlv(struct snd_kcontrol *kcontrol,
sel = val; sel = val;
} }
snd_soc_update_bits(codec, mc->reg, snd_soc_component_update_bits(component, mc->reg,
mask << mc->shift, mask << mc->shift,
sel << mc->shift); sel << mc->shift);
@ -733,10 +733,10 @@ static const struct snd_kcontrol_new max98091_snd_controls[] = {
static int max98090_micinput_event(struct snd_soc_dapm_widget *w, static int max98090_micinput_event(struct snd_soc_dapm_widget *w,
struct snd_kcontrol *kcontrol, int event) 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 max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec); struct max98090_priv *max98090 = snd_soc_component_get_drvdata(component);
unsigned int val = snd_soc_read(codec, w->reg); unsigned int val = snd_soc_component_read32(component, w->reg);
if (w->reg == M98090_REG_MIC1_INPUT_LEVEL) if (w->reg == M98090_REG_MIC1_INPUT_LEVEL)
val = (val & M98090_MIC_PA1EN_MASK) >> M98090_MIC_PA1EN_SHIFT; val = (val & M98090_MIC_PA1EN_MASK) >> M98090_MIC_PA1EN_SHIFT;
@ -768,10 +768,10 @@ static int max98090_micinput_event(struct snd_soc_dapm_widget *w,
} }
if (w->reg == M98090_REG_MIC1_INPUT_LEVEL) if (w->reg == M98090_REG_MIC1_INPUT_LEVEL)
snd_soc_update_bits(codec, w->reg, M98090_MIC_PA1EN_MASK, snd_soc_component_update_bits(component, w->reg, M98090_MIC_PA1EN_MASK,
val << M98090_MIC_PA1EN_SHIFT); val << M98090_MIC_PA1EN_SHIFT);
else else
snd_soc_update_bits(codec, w->reg, M98090_MIC_PA2EN_MASK, snd_soc_component_update_bits(component, w->reg, M98090_MIC_PA2EN_MASK,
val << M98090_MIC_PA2EN_SHIFT); val << M98090_MIC_PA2EN_SHIFT);
return 0; return 0;
@ -780,8 +780,8 @@ static int max98090_micinput_event(struct snd_soc_dapm_widget *w,
static int max98090_shdn_event(struct snd_soc_dapm_widget *w, static int max98090_shdn_event(struct snd_soc_dapm_widget *w,
struct snd_kcontrol *kcontrol, int event) 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 max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec); struct max98090_priv *max98090 = snd_soc_component_get_drvdata(component);
if (event & SND_SOC_DAPM_POST_PMU) if (event & SND_SOC_DAPM_POST_PMU)
max98090->shdn_pending = true; max98090->shdn_pending = true;
@ -1441,16 +1441,16 @@ static const struct snd_soc_dapm_route max98091_dapm_routes[] = {
{"DMIC4", NULL, "AHPF"}, {"DMIC4", NULL, "AHPF"},
}; };
static int max98090_add_widgets(struct snd_soc_codec *codec) static int max98090_add_widgets(struct snd_soc_component *component)
{ {
struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec); struct max98090_priv *max98090 = snd_soc_component_get_drvdata(component);
struct snd_soc_dapm_context *dapm = snd_soc_codec_get_dapm(codec); struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
snd_soc_add_codec_controls(codec, max98090_snd_controls, snd_soc_add_component_controls(component, max98090_snd_controls,
ARRAY_SIZE(max98090_snd_controls)); ARRAY_SIZE(max98090_snd_controls));
if (max98090->devtype == MAX98091) { if (max98090->devtype == MAX98091) {
snd_soc_add_codec_controls(codec, max98091_snd_controls, snd_soc_add_component_controls(component, max98091_snd_controls,
ARRAY_SIZE(max98091_snd_controls)); ARRAY_SIZE(max98091_snd_controls));
} }
@ -1497,24 +1497,24 @@ static const unsigned long long mi_value[] = {
8125, 1625, 1500, 25 8125, 1625, 1500, 25
}; };
static void max98090_configure_bclk(struct snd_soc_codec *codec) static void max98090_configure_bclk(struct snd_soc_component *component)
{ {
struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec); struct max98090_priv *max98090 = snd_soc_component_get_drvdata(component);
unsigned long long ni; unsigned long long ni;
int i; int i;
if (!max98090->sysclk) { if (!max98090->sysclk) {
dev_err(codec->dev, "No SYSCLK configured\n"); dev_err(component->dev, "No SYSCLK configured\n");
return; return;
} }
if (!max98090->bclk || !max98090->lrclk) { if (!max98090->bclk || !max98090->lrclk) {
dev_err(codec->dev, "No audio clocks configured\n"); dev_err(component->dev, "No audio clocks configured\n");
return; return;
} }
/* Skip configuration when operating as slave */ /* Skip configuration when operating as slave */
if (!(snd_soc_read(codec, M98090_REG_MASTER_MODE) & if (!(snd_soc_component_read32(component, M98090_REG_MASTER_MODE) &
M98090_MAS_MASK)) { M98090_MAS_MASK)) {
return; return;
} }
@ -1523,14 +1523,14 @@ static void max98090_configure_bclk(struct snd_soc_codec *codec)
for (i = 0; i < ARRAY_SIZE(pclk_rates); i++) { for (i = 0; i < ARRAY_SIZE(pclk_rates); i++) {
if ((pclk_rates[i] == max98090->sysclk) && if ((pclk_rates[i] == max98090->sysclk) &&
(lrclk_rates[i] == max98090->lrclk)) { (lrclk_rates[i] == max98090->lrclk)) {
dev_dbg(codec->dev, dev_dbg(component->dev,
"Found supported PCLK to LRCLK rates 0x%x\n", "Found supported PCLK to LRCLK rates 0x%x\n",
i + 0x8); i + 0x8);
snd_soc_update_bits(codec, M98090_REG_CLOCK_MODE, snd_soc_component_update_bits(component, M98090_REG_CLOCK_MODE,
M98090_FREQ_MASK, M98090_FREQ_MASK,
(i + 0x8) << M98090_FREQ_SHIFT); (i + 0x8) << M98090_FREQ_SHIFT);
snd_soc_update_bits(codec, M98090_REG_CLOCK_MODE, snd_soc_component_update_bits(component, M98090_REG_CLOCK_MODE,
M98090_USE_M1_MASK, 0); M98090_USE_M1_MASK, 0);
return; return;
} }
@ -1540,24 +1540,24 @@ static void max98090_configure_bclk(struct snd_soc_codec *codec)
for (i = 0; i < ARRAY_SIZE(user_pclk_rates); i++) { for (i = 0; i < ARRAY_SIZE(user_pclk_rates); i++) {
if ((user_pclk_rates[i] == max98090->sysclk) && if ((user_pclk_rates[i] == max98090->sysclk) &&
(user_lrclk_rates[i] == max98090->lrclk)) { (user_lrclk_rates[i] == max98090->lrclk)) {
dev_dbg(codec->dev, dev_dbg(component->dev,
"Found user supported PCLK to LRCLK rates\n"); "Found user supported PCLK to LRCLK rates\n");
dev_dbg(codec->dev, "i %d ni %lld mi %lld\n", dev_dbg(component->dev, "i %d ni %lld mi %lld\n",
i, ni_value[i], mi_value[i]); i, ni_value[i], mi_value[i]);
snd_soc_update_bits(codec, M98090_REG_CLOCK_MODE, snd_soc_component_update_bits(component, M98090_REG_CLOCK_MODE,
M98090_FREQ_MASK, 0); M98090_FREQ_MASK, 0);
snd_soc_update_bits(codec, M98090_REG_CLOCK_MODE, snd_soc_component_update_bits(component, M98090_REG_CLOCK_MODE,
M98090_USE_M1_MASK, M98090_USE_M1_MASK,
1 << M98090_USE_M1_SHIFT); 1 << M98090_USE_M1_SHIFT);
snd_soc_write(codec, M98090_REG_CLOCK_RATIO_NI_MSB, snd_soc_component_write(component, M98090_REG_CLOCK_RATIO_NI_MSB,
(ni_value[i] >> 8) & 0x7F); (ni_value[i] >> 8) & 0x7F);
snd_soc_write(codec, M98090_REG_CLOCK_RATIO_NI_LSB, snd_soc_component_write(component, M98090_REG_CLOCK_RATIO_NI_LSB,
ni_value[i] & 0xFF); ni_value[i] & 0xFF);
snd_soc_write(codec, M98090_REG_CLOCK_RATIO_MI_MSB, snd_soc_component_write(component, M98090_REG_CLOCK_RATIO_MI_MSB,
(mi_value[i] >> 8) & 0x7F); (mi_value[i] >> 8) & 0x7F);
snd_soc_write(codec, M98090_REG_CLOCK_RATIO_MI_LSB, snd_soc_component_write(component, M98090_REG_CLOCK_RATIO_MI_LSB,
mi_value[i] & 0xFF); mi_value[i] & 0xFF);
return; return;
@ -1567,9 +1567,9 @@ static void max98090_configure_bclk(struct snd_soc_codec *codec)
/* /*
* Calculate based on MI = 65536 (not as good as either method above) * Calculate based on MI = 65536 (not as good as either method above)
*/ */
snd_soc_update_bits(codec, M98090_REG_CLOCK_MODE, snd_soc_component_update_bits(component, M98090_REG_CLOCK_MODE,
M98090_FREQ_MASK, 0); M98090_FREQ_MASK, 0);
snd_soc_update_bits(codec, M98090_REG_CLOCK_MODE, snd_soc_component_update_bits(component, M98090_REG_CLOCK_MODE,
M98090_USE_M1_MASK, 0); M98090_USE_M1_MASK, 0);
/* /*
@ -1580,18 +1580,18 @@ static void max98090_configure_bclk(struct snd_soc_codec *codec)
ni = 65536ULL * (max98090->lrclk < 50000 ? 96ULL : 48ULL) ni = 65536ULL * (max98090->lrclk < 50000 ? 96ULL : 48ULL)
* (unsigned long long int)max98090->lrclk; * (unsigned long long int)max98090->lrclk;
do_div(ni, (unsigned long long int)max98090->sysclk); do_div(ni, (unsigned long long int)max98090->sysclk);
dev_info(codec->dev, "No better method found\n"); dev_info(component->dev, "No better method found\n");
dev_info(codec->dev, "Calculating ni %lld with mi 65536\n", ni); dev_info(component->dev, "Calculating ni %lld with mi 65536\n", ni);
snd_soc_write(codec, M98090_REG_CLOCK_RATIO_NI_MSB, snd_soc_component_write(component, M98090_REG_CLOCK_RATIO_NI_MSB,
(ni >> 8) & 0x7F); (ni >> 8) & 0x7F);
snd_soc_write(codec, M98090_REG_CLOCK_RATIO_NI_LSB, ni & 0xFF); snd_soc_component_write(component, M98090_REG_CLOCK_RATIO_NI_LSB, ni & 0xFF);
} }
static int max98090_dai_set_fmt(struct snd_soc_dai *codec_dai, static int max98090_dai_set_fmt(struct snd_soc_dai *codec_dai,
unsigned int fmt) unsigned int fmt)
{ {
struct snd_soc_codec *codec = codec_dai->codec; struct snd_soc_component *component = codec_dai->component;
struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec); struct max98090_priv *max98090 = snd_soc_component_get_drvdata(component);
struct max98090_cdata *cdata; struct max98090_cdata *cdata;
u8 regval; u8 regval;
@ -1605,11 +1605,11 @@ static int max98090_dai_set_fmt(struct snd_soc_dai *codec_dai,
switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
case SND_SOC_DAIFMT_CBS_CFS: case SND_SOC_DAIFMT_CBS_CFS:
/* Set to slave mode PLL - MAS mode off */ /* Set to slave mode PLL - MAS mode off */
snd_soc_write(codec, snd_soc_component_write(component,
M98090_REG_CLOCK_RATIO_NI_MSB, 0x00); M98090_REG_CLOCK_RATIO_NI_MSB, 0x00);
snd_soc_write(codec, snd_soc_component_write(component,
M98090_REG_CLOCK_RATIO_NI_LSB, 0x00); M98090_REG_CLOCK_RATIO_NI_LSB, 0x00);
snd_soc_update_bits(codec, M98090_REG_CLOCK_MODE, snd_soc_component_update_bits(component, M98090_REG_CLOCK_MODE,
M98090_USE_M1_MASK, 0); M98090_USE_M1_MASK, 0);
max98090->master = false; max98090->master = false;
break; break;
@ -1633,10 +1633,10 @@ static int max98090_dai_set_fmt(struct snd_soc_dai *codec_dai,
case SND_SOC_DAIFMT_CBS_CFM: case SND_SOC_DAIFMT_CBS_CFM:
case SND_SOC_DAIFMT_CBM_CFS: case SND_SOC_DAIFMT_CBM_CFS:
default: default:
dev_err(codec->dev, "DAI clock mode unsupported"); dev_err(component->dev, "DAI clock mode unsupported");
return -EINVAL; return -EINVAL;
} }
snd_soc_write(codec, M98090_REG_MASTER_MODE, regval); snd_soc_component_write(component, M98090_REG_MASTER_MODE, regval);
regval = 0; regval = 0;
switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
@ -1651,7 +1651,7 @@ static int max98090_dai_set_fmt(struct snd_soc_dai *codec_dai,
case SND_SOC_DAIFMT_DSP_A: case SND_SOC_DAIFMT_DSP_A:
/* Not supported mode */ /* Not supported mode */
default: default:
dev_err(codec->dev, "DAI format unsupported"); dev_err(component->dev, "DAI format unsupported");
return -EINVAL; return -EINVAL;
} }
@ -1668,7 +1668,7 @@ static int max98090_dai_set_fmt(struct snd_soc_dai *codec_dai,
regval |= M98090_BCI_MASK|M98090_WCI_MASK; regval |= M98090_BCI_MASK|M98090_WCI_MASK;
break; break;
default: default:
dev_err(codec->dev, "DAI invert mode unsupported"); dev_err(component->dev, "DAI invert mode unsupported");
return -EINVAL; return -EINVAL;
} }
@ -1681,7 +1681,7 @@ static int max98090_dai_set_fmt(struct snd_soc_dai *codec_dai,
if (max98090->tdm_slots > 1) if (max98090->tdm_slots > 1)
regval ^= M98090_BCI_MASK; regval ^= M98090_BCI_MASK;
snd_soc_write(codec, snd_soc_component_write(component,
M98090_REG_INTERFACE_FORMAT, regval); M98090_REG_INTERFACE_FORMAT, regval);
} }
@ -1691,8 +1691,8 @@ static int max98090_dai_set_fmt(struct snd_soc_dai *codec_dai,
static int max98090_set_tdm_slot(struct snd_soc_dai *codec_dai, static int max98090_set_tdm_slot(struct snd_soc_dai *codec_dai,
unsigned int tx_mask, unsigned int rx_mask, int slots, int slot_width) unsigned int tx_mask, unsigned int rx_mask, int slots, int slot_width)
{ {
struct snd_soc_codec *codec = codec_dai->codec; struct snd_soc_component *component = codec_dai->component;
struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec); struct max98090_priv *max98090 = snd_soc_component_get_drvdata(component);
struct max98090_cdata *cdata; struct max98090_cdata *cdata;
cdata = &max98090->dai[0]; cdata = &max98090->dai[0];
@ -1704,13 +1704,13 @@ static int max98090_set_tdm_slot(struct snd_soc_dai *codec_dai,
if (max98090->tdm_slots > 1) { if (max98090->tdm_slots > 1) {
/* SLOTL SLOTR SLOTDLY */ /* SLOTL SLOTR SLOTDLY */
snd_soc_write(codec, M98090_REG_TDM_FORMAT, snd_soc_component_write(component, M98090_REG_TDM_FORMAT,
0 << M98090_TDM_SLOTL_SHIFT | 0 << M98090_TDM_SLOTL_SHIFT |
1 << M98090_TDM_SLOTR_SHIFT | 1 << M98090_TDM_SLOTR_SHIFT |
0 << M98090_TDM_SLOTDLY_SHIFT); 0 << M98090_TDM_SLOTDLY_SHIFT);
/* FSW TDM */ /* FSW TDM */
snd_soc_update_bits(codec, M98090_REG_TDM_CONTROL, snd_soc_component_update_bits(component, M98090_REG_TDM_CONTROL,
M98090_TDM_MASK, M98090_TDM_MASK,
M98090_TDM_MASK); M98090_TDM_MASK);
} }
@ -1724,10 +1724,10 @@ static int max98090_set_tdm_slot(struct snd_soc_dai *codec_dai,
return 0; return 0;
} }
static int max98090_set_bias_level(struct snd_soc_codec *codec, static int max98090_set_bias_level(struct snd_soc_component *component,
enum snd_soc_bias_level level) enum snd_soc_bias_level level)
{ {
struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec); struct max98090_priv *max98090 = snd_soc_component_get_drvdata(component);
int ret; int ret;
switch (level) { switch (level) {
@ -1745,7 +1745,7 @@ static int max98090_set_bias_level(struct snd_soc_codec *codec,
if (IS_ERR(max98090->mclk)) if (IS_ERR(max98090->mclk))
break; break;
if (snd_soc_codec_get_bias_level(codec) == SND_SOC_BIAS_ON) { if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_ON) {
clk_disable_unprepare(max98090->mclk); clk_disable_unprepare(max98090->mclk);
} else { } else {
ret = clk_prepare_enable(max98090->mclk); ret = clk_prepare_enable(max98090->mclk);
@ -1755,10 +1755,10 @@ static int max98090_set_bias_level(struct snd_soc_codec *codec,
break; break;
case SND_SOC_BIAS_STANDBY: 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 = regcache_sync(max98090->regmap); ret = regcache_sync(max98090->regmap);
if (ret != 0) { if (ret != 0) {
dev_err(codec->dev, dev_err(component->dev,
"Failed to sync cache: %d\n", ret); "Failed to sync cache: %d\n", ret);
return ret; return ret;
} }
@ -1767,7 +1767,7 @@ static int max98090_set_bias_level(struct snd_soc_codec *codec,
case SND_SOC_BIAS_OFF: case SND_SOC_BIAS_OFF:
/* Set internal pull-up to lowest power mode */ /* Set internal pull-up to lowest power mode */
snd_soc_update_bits(codec, M98090_REG_JACK_DETECT, snd_soc_component_update_bits(component, M98090_REG_JACK_DETECT,
M98090_JDWK_MASK, M98090_JDWK_MASK); M98090_JDWK_MASK, M98090_JDWK_MASK);
regcache_mark_dirty(max98090->regmap); regcache_mark_dirty(max98090->regmap);
break; break;
@ -1928,8 +1928,8 @@ static int max98090_dai_hw_params(struct snd_pcm_substream *substream,
struct snd_pcm_hw_params *params, struct snd_pcm_hw_params *params,
struct snd_soc_dai *dai) struct snd_soc_dai *dai)
{ {
struct snd_soc_codec *codec = dai->codec; struct snd_soc_component *component = dai->component;
struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec); struct max98090_priv *max98090 = snd_soc_component_get_drvdata(component);
struct max98090_cdata *cdata; struct max98090_cdata *cdata;
cdata = &max98090->dai[0]; cdata = &max98090->dai[0];
@ -1941,7 +1941,7 @@ static int max98090_dai_hw_params(struct snd_pcm_substream *substream,
switch (params_width(params)) { switch (params_width(params)) {
case 16: case 16:
snd_soc_update_bits(codec, M98090_REG_INTERFACE_FORMAT, snd_soc_component_update_bits(component, M98090_REG_INTERFACE_FORMAT,
M98090_WS_MASK, 0); M98090_WS_MASK, 0);
break; break;
default: default:
@ -1949,24 +1949,24 @@ static int max98090_dai_hw_params(struct snd_pcm_substream *substream,
} }
if (max98090->master) if (max98090->master)
max98090_configure_bclk(codec); max98090_configure_bclk(component);
cdata->rate = max98090->lrclk; cdata->rate = max98090->lrclk;
/* Update filter mode */ /* Update filter mode */
if (max98090->lrclk < 24000) if (max98090->lrclk < 24000)
snd_soc_update_bits(codec, M98090_REG_FILTER_CONFIG, snd_soc_component_update_bits(component, M98090_REG_FILTER_CONFIG,
M98090_MODE_MASK, 0); M98090_MODE_MASK, 0);
else else
snd_soc_update_bits(codec, M98090_REG_FILTER_CONFIG, snd_soc_component_update_bits(component, M98090_REG_FILTER_CONFIG,
M98090_MODE_MASK, M98090_MODE_MASK); M98090_MODE_MASK, M98090_MODE_MASK);
/* Update sample rate mode */ /* Update sample rate mode */
if (max98090->lrclk < 50000) if (max98090->lrclk < 50000)
snd_soc_update_bits(codec, M98090_REG_FILTER_CONFIG, snd_soc_component_update_bits(component, M98090_REG_FILTER_CONFIG,
M98090_DHF_MASK, 0); M98090_DHF_MASK, 0);
else else
snd_soc_update_bits(codec, M98090_REG_FILTER_CONFIG, snd_soc_component_update_bits(component, M98090_REG_FILTER_CONFIG,
M98090_DHF_MASK, M98090_DHF_MASK); M98090_DHF_MASK, M98090_DHF_MASK);
max98090_configure_dmic(max98090, max98090->dmic_freq, max98090->pclk, max98090_configure_dmic(max98090, max98090->dmic_freq, max98090->pclk,
@ -1981,8 +1981,8 @@ static int max98090_dai_hw_params(struct snd_pcm_substream *substream,
static int max98090_dai_set_sysclk(struct snd_soc_dai *dai, static int max98090_dai_set_sysclk(struct snd_soc_dai *dai,
int clk_id, unsigned int freq, int dir) int clk_id, unsigned int freq, int dir)
{ {
struct snd_soc_codec *codec = dai->codec; struct snd_soc_component *component = dai->component;
struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec); struct max98090_priv *max98090 = snd_soc_component_get_drvdata(component);
/* Requested clock frequency is already setup */ /* Requested clock frequency is already setup */
if (freq == max98090->sysclk) if (freq == max98090->sysclk)
@ -1999,19 +1999,19 @@ static int max98090_dai_set_sysclk(struct snd_soc_dai *dai,
* 0x03 (when master clk is 40MHz to 60MHz).. * 0x03 (when master clk is 40MHz to 60MHz)..
*/ */
if ((freq >= 10000000) && (freq <= 20000000)) { if ((freq >= 10000000) && (freq <= 20000000)) {
snd_soc_write(codec, M98090_REG_SYSTEM_CLOCK, snd_soc_component_write(component, M98090_REG_SYSTEM_CLOCK,
M98090_PSCLK_DIV1); M98090_PSCLK_DIV1);
max98090->pclk = freq; max98090->pclk = freq;
} else if ((freq > 20000000) && (freq <= 40000000)) { } else if ((freq > 20000000) && (freq <= 40000000)) {
snd_soc_write(codec, M98090_REG_SYSTEM_CLOCK, snd_soc_component_write(component, M98090_REG_SYSTEM_CLOCK,
M98090_PSCLK_DIV2); M98090_PSCLK_DIV2);
max98090->pclk = freq >> 1; max98090->pclk = freq >> 1;
} else if ((freq > 40000000) && (freq <= 60000000)) { } else if ((freq > 40000000) && (freq <= 60000000)) {
snd_soc_write(codec, M98090_REG_SYSTEM_CLOCK, snd_soc_component_write(component, M98090_REG_SYSTEM_CLOCK,
M98090_PSCLK_DIV4); M98090_PSCLK_DIV4);
max98090->pclk = freq >> 2; max98090->pclk = freq >> 2;
} else { } else {
dev_err(codec->dev, "Invalid master clock frequency\n"); dev_err(component->dev, "Invalid master clock frequency\n");
return -EINVAL; return -EINVAL;
} }
@ -2022,11 +2022,11 @@ static int max98090_dai_set_sysclk(struct snd_soc_dai *dai,
static int max98090_dai_digital_mute(struct snd_soc_dai *codec_dai, int mute) static int max98090_dai_digital_mute(struct snd_soc_dai *codec_dai, int mute)
{ {
struct snd_soc_codec *codec = codec_dai->codec; struct snd_soc_component *component = codec_dai->component;
int regval; int regval;
regval = mute ? M98090_DVM_MASK : 0; regval = mute ? M98090_DVM_MASK : 0;
snd_soc_update_bits(codec, M98090_REG_DAI_PLAYBACK_LEVEL, snd_soc_component_update_bits(component, M98090_REG_DAI_PLAYBACK_LEVEL,
M98090_DVM_MASK, regval); M98090_DVM_MASK, regval);
return 0; return 0;
@ -2035,8 +2035,8 @@ static int max98090_dai_digital_mute(struct snd_soc_dai *codec_dai, int mute)
static int max98090_dai_trigger(struct snd_pcm_substream *substream, int cmd, static int max98090_dai_trigger(struct snd_pcm_substream *substream, int cmd,
struct snd_soc_dai *dai) struct snd_soc_dai *dai)
{ {
struct snd_soc_codec *codec = dai->codec; struct snd_soc_component *component = dai->component;
struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec); struct max98090_priv *max98090 = snd_soc_component_get_drvdata(component);
switch (cmd) { switch (cmd) {
case SNDRV_PCM_TRIGGER_START: case SNDRV_PCM_TRIGGER_START:
@ -2065,7 +2065,7 @@ static void max98090_pll_det_enable_work(struct work_struct *work)
struct max98090_priv *max98090 = struct max98090_priv *max98090 =
container_of(work, struct max98090_priv, container_of(work, struct max98090_priv,
pll_det_enable_work.work); pll_det_enable_work.work);
struct snd_soc_codec *codec = max98090->codec; struct snd_soc_component *component = max98090->component;
unsigned int status, mask; unsigned int status, mask;
/* /*
@ -2088,7 +2088,7 @@ static void max98090_pll_det_enable_work(struct work_struct *work)
msecs_to_jiffies(100)); msecs_to_jiffies(100));
/* Enable PLL unlock interrupt */ /* Enable PLL unlock interrupt */
snd_soc_update_bits(codec, M98090_REG_INTERRUPT_S, snd_soc_component_update_bits(component, M98090_REG_INTERRUPT_S,
M98090_IULK_MASK, M98090_IULK_MASK,
1 << M98090_IULK_SHIFT); 1 << M98090_IULK_SHIFT);
} }
@ -2097,12 +2097,12 @@ static void max98090_pll_det_disable_work(struct work_struct *work)
{ {
struct max98090_priv *max98090 = struct max98090_priv *max98090 =
container_of(work, struct max98090_priv, pll_det_disable_work); container_of(work, struct max98090_priv, pll_det_disable_work);
struct snd_soc_codec *codec = max98090->codec; struct snd_soc_component *component = max98090->component;
cancel_delayed_work_sync(&max98090->pll_det_enable_work); cancel_delayed_work_sync(&max98090->pll_det_enable_work);
/* Disable PLL unlock interrupt */ /* Disable PLL unlock interrupt */
snd_soc_update_bits(codec, M98090_REG_INTERRUPT_S, snd_soc_component_update_bits(component, M98090_REG_INTERRUPT_S,
M98090_IULK_MASK, 0); M98090_IULK_MASK, 0);
} }
@ -2110,18 +2110,18 @@ static void max98090_pll_work(struct work_struct *work)
{ {
struct max98090_priv *max98090 = struct max98090_priv *max98090 =
container_of(work, struct max98090_priv, pll_work); container_of(work, struct max98090_priv, pll_work);
struct snd_soc_codec *codec = max98090->codec; struct snd_soc_component *component = max98090->component;
if (!snd_soc_codec_is_active(codec)) if (!snd_soc_component_is_active(component))
return; return;
dev_info_ratelimited(codec->dev, "PLL unlocked\n"); dev_info_ratelimited(component->dev, "PLL unlocked\n");
/* Toggle shutdown OFF then ON */ /* Toggle shutdown OFF then ON */
snd_soc_update_bits(codec, M98090_REG_DEVICE_SHUTDOWN, snd_soc_component_update_bits(component, M98090_REG_DEVICE_SHUTDOWN,
M98090_SHDNN_MASK, 0); M98090_SHDNN_MASK, 0);
msleep(10); msleep(10);
snd_soc_update_bits(codec, M98090_REG_DEVICE_SHUTDOWN, snd_soc_component_update_bits(component, M98090_REG_DEVICE_SHUTDOWN,
M98090_SHDNN_MASK, M98090_SHDNN_MASK); M98090_SHDNN_MASK, M98090_SHDNN_MASK);
/* Give PLL time to lock */ /* Give PLL time to lock */
@ -2133,7 +2133,7 @@ static void max98090_jack_work(struct work_struct *work)
struct max98090_priv *max98090 = container_of(work, struct max98090_priv *max98090 = container_of(work,
struct max98090_priv, struct max98090_priv,
jack_work.work); jack_work.work);
struct snd_soc_codec *codec = max98090->codec; struct snd_soc_component *component = max98090->component;
int status = 0; int status = 0;
int reg; int reg;
@ -2141,25 +2141,25 @@ static void max98090_jack_work(struct work_struct *work)
if (max98090->jack_state == M98090_JACK_STATE_NO_HEADSET) { if (max98090->jack_state == M98090_JACK_STATE_NO_HEADSET) {
/* Strong pull up allows mic detection */ /* Strong pull up allows mic detection */
snd_soc_update_bits(codec, M98090_REG_JACK_DETECT, snd_soc_component_update_bits(component, M98090_REG_JACK_DETECT,
M98090_JDWK_MASK, 0); M98090_JDWK_MASK, 0);
msleep(50); msleep(50);
reg = snd_soc_read(codec, M98090_REG_JACK_STATUS); reg = snd_soc_component_read32(component, M98090_REG_JACK_STATUS);
/* Weak pull up allows only insertion detection */ /* Weak pull up allows only insertion detection */
snd_soc_update_bits(codec, M98090_REG_JACK_DETECT, snd_soc_component_update_bits(component, M98090_REG_JACK_DETECT,
M98090_JDWK_MASK, M98090_JDWK_MASK); M98090_JDWK_MASK, M98090_JDWK_MASK);
} else { } else {
reg = snd_soc_read(codec, M98090_REG_JACK_STATUS); reg = snd_soc_component_read32(component, M98090_REG_JACK_STATUS);
} }
reg = snd_soc_read(codec, M98090_REG_JACK_STATUS); reg = snd_soc_component_read32(component, M98090_REG_JACK_STATUS);
switch (reg & (M98090_LSNS_MASK | M98090_JKSNS_MASK)) { switch (reg & (M98090_LSNS_MASK | M98090_JKSNS_MASK)) {
case M98090_LSNS_MASK | M98090_JKSNS_MASK: case M98090_LSNS_MASK | M98090_JKSNS_MASK:
dev_dbg(codec->dev, "No Headset Detected\n"); dev_dbg(component->dev, "No Headset Detected\n");
max98090->jack_state = M98090_JACK_STATE_NO_HEADSET; max98090->jack_state = M98090_JACK_STATE_NO_HEADSET;
@ -2171,7 +2171,7 @@ static void max98090_jack_work(struct work_struct *work)
if (max98090->jack_state == if (max98090->jack_state ==
M98090_JACK_STATE_HEADSET) { M98090_JACK_STATE_HEADSET) {
dev_dbg(codec->dev, dev_dbg(component->dev,
"Headset Button Down Detected\n"); "Headset Button Down Detected\n");
/* /*
@ -2188,7 +2188,7 @@ static void max98090_jack_work(struct work_struct *work)
/* Line is reported as Headphone */ /* Line is reported as Headphone */
/* Nokia Headset is reported as Headphone */ /* Nokia Headset is reported as Headphone */
/* Mono Headphone is reported as Headphone */ /* Mono Headphone is reported as Headphone */
dev_dbg(codec->dev, "Headphone Detected\n"); dev_dbg(component->dev, "Headphone Detected\n");
max98090->jack_state = M98090_JACK_STATE_HEADPHONE; max98090->jack_state = M98090_JACK_STATE_HEADPHONE;
@ -2197,7 +2197,7 @@ static void max98090_jack_work(struct work_struct *work)
break; break;
case M98090_JKSNS_MASK: case M98090_JKSNS_MASK:
dev_dbg(codec->dev, "Headset Detected\n"); dev_dbg(component->dev, "Headset Detected\n");
max98090->jack_state = M98090_JACK_STATE_HEADSET; max98090->jack_state = M98090_JACK_STATE_HEADSET;
@ -2206,7 +2206,7 @@ static void max98090_jack_work(struct work_struct *work)
break; break;
default: default:
dev_dbg(codec->dev, "Unrecognized Jack Status\n"); dev_dbg(component->dev, "Unrecognized Jack Status\n");
break; break;
} }
@ -2217,21 +2217,21 @@ static void max98090_jack_work(struct work_struct *work)
static irqreturn_t max98090_interrupt(int irq, void *data) static irqreturn_t max98090_interrupt(int irq, void *data)
{ {
struct max98090_priv *max98090 = data; struct max98090_priv *max98090 = data;
struct snd_soc_codec *codec = max98090->codec; struct snd_soc_component *component = max98090->component;
int ret; int ret;
unsigned int mask; unsigned int mask;
unsigned int active; unsigned int active;
/* Treat interrupt before codec is initialized as spurious */ /* Treat interrupt before codec is initialized as spurious */
if (codec == NULL) if (component == NULL)
return IRQ_NONE; return IRQ_NONE;
dev_dbg(codec->dev, "***** max98090_interrupt *****\n"); dev_dbg(component->dev, "***** max98090_interrupt *****\n");
ret = regmap_read(max98090->regmap, M98090_REG_INTERRUPT_S, &mask); ret = regmap_read(max98090->regmap, M98090_REG_INTERRUPT_S, &mask);
if (ret != 0) { if (ret != 0) {
dev_err(codec->dev, dev_err(component->dev,
"failed to read M98090_REG_INTERRUPT_S: %d\n", "failed to read M98090_REG_INTERRUPT_S: %d\n",
ret); ret);
return IRQ_NONE; return IRQ_NONE;
@ -2240,13 +2240,13 @@ static irqreturn_t max98090_interrupt(int irq, void *data)
ret = regmap_read(max98090->regmap, M98090_REG_DEVICE_STATUS, &active); ret = regmap_read(max98090->regmap, M98090_REG_DEVICE_STATUS, &active);
if (ret != 0) { if (ret != 0) {
dev_err(codec->dev, dev_err(component->dev,
"failed to read M98090_REG_DEVICE_STATUS: %d\n", "failed to read M98090_REG_DEVICE_STATUS: %d\n",
ret); ret);
return IRQ_NONE; return IRQ_NONE;
} }
dev_dbg(codec->dev, "active=0x%02x mask=0x%02x -> active=0x%02x\n", dev_dbg(component->dev, "active=0x%02x mask=0x%02x -> active=0x%02x\n",
active, mask, active & mask); active, mask, active & mask);
active &= mask; active &= mask;
@ -2255,20 +2255,20 @@ static irqreturn_t max98090_interrupt(int irq, void *data)
return IRQ_NONE; return IRQ_NONE;
if (active & M98090_CLD_MASK) if (active & M98090_CLD_MASK)
dev_err(codec->dev, "M98090_CLD_MASK\n"); dev_err(component->dev, "M98090_CLD_MASK\n");
if (active & M98090_SLD_MASK) if (active & M98090_SLD_MASK)
dev_dbg(codec->dev, "M98090_SLD_MASK\n"); dev_dbg(component->dev, "M98090_SLD_MASK\n");
if (active & M98090_ULK_MASK) { if (active & M98090_ULK_MASK) {
dev_dbg(codec->dev, "M98090_ULK_MASK\n"); dev_dbg(component->dev, "M98090_ULK_MASK\n");
schedule_work(&max98090->pll_work); schedule_work(&max98090->pll_work);
} }
if (active & M98090_JDET_MASK) { if (active & M98090_JDET_MASK) {
dev_dbg(codec->dev, "M98090_JDET_MASK\n"); dev_dbg(component->dev, "M98090_JDET_MASK\n");
pm_wakeup_event(codec->dev, 100); pm_wakeup_event(component->dev, 100);
queue_delayed_work(system_power_efficient_wq, queue_delayed_work(system_power_efficient_wq,
&max98090->jack_work, &max98090->jack_work,
@ -2276,10 +2276,10 @@ static irqreturn_t max98090_interrupt(int irq, void *data)
} }
if (active & M98090_DRCACT_MASK) if (active & M98090_DRCACT_MASK)
dev_dbg(codec->dev, "M98090_DRCACT_MASK\n"); dev_dbg(component->dev, "M98090_DRCACT_MASK\n");
if (active & M98090_DRCCLP_MASK) if (active & M98090_DRCCLP_MASK)
dev_err(codec->dev, "M98090_DRCCLP_MASK\n"); dev_err(component->dev, "M98090_DRCCLP_MASK\n");
return IRQ_HANDLED; return IRQ_HANDLED;
} }
@ -2287,7 +2287,7 @@ static irqreturn_t max98090_interrupt(int irq, void *data)
/** /**
* max98090_mic_detect - Enable microphone detection via the MAX98090 IRQ * max98090_mic_detect - Enable microphone detection via the MAX98090 IRQ
* *
* @codec: MAX98090 codec * @component: MAX98090 component
* @jack: jack to report detection events on * @jack: jack to report detection events on
* *
* Enable microphone detection via IRQ on the MAX98090. If GPIOs are * Enable microphone detection via IRQ on the MAX98090. If GPIOs are
@ -2297,20 +2297,20 @@ static irqreturn_t max98090_interrupt(int irq, void *data)
* *
* If no jack is supplied detection will be disabled. * If no jack is supplied detection will be disabled.
*/ */
int max98090_mic_detect(struct snd_soc_codec *codec, int max98090_mic_detect(struct snd_soc_component *component,
struct snd_soc_jack *jack) struct snd_soc_jack *jack)
{ {
struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec); struct max98090_priv *max98090 = snd_soc_component_get_drvdata(component);
dev_dbg(codec->dev, "max98090_mic_detect\n"); dev_dbg(component->dev, "max98090_mic_detect\n");
max98090->jack = jack; max98090->jack = jack;
if (jack) { if (jack) {
snd_soc_update_bits(codec, M98090_REG_INTERRUPT_S, snd_soc_component_update_bits(component, M98090_REG_INTERRUPT_S,
M98090_IJDET_MASK, M98090_IJDET_MASK,
1 << M98090_IJDET_SHIFT); 1 << M98090_IJDET_SHIFT);
} else { } else {
snd_soc_update_bits(codec, M98090_REG_INTERRUPT_S, snd_soc_component_update_bits(component, M98090_REG_INTERRUPT_S,
M98090_IJDET_MASK, M98090_IJDET_MASK,
0); 0);
} }
@ -2360,22 +2360,22 @@ static struct snd_soc_dai_driver max98090_dai[] = {
} }
}; };
static int max98090_probe(struct snd_soc_codec *codec) static int max98090_probe(struct snd_soc_component *component)
{ {
struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec); struct max98090_priv *max98090 = snd_soc_component_get_drvdata(component);
struct max98090_cdata *cdata; struct max98090_cdata *cdata;
enum max98090_type devtype; enum max98090_type devtype;
int ret = 0; int ret = 0;
int err; int err;
unsigned int micbias; unsigned int micbias;
dev_dbg(codec->dev, "max98090_probe\n"); dev_dbg(component->dev, "max98090_probe\n");
max98090->mclk = devm_clk_get(codec->dev, "mclk"); max98090->mclk = devm_clk_get(component->dev, "mclk");
if (PTR_ERR(max98090->mclk) == -EPROBE_DEFER) if (PTR_ERR(max98090->mclk) == -EPROBE_DEFER)
return -EPROBE_DEFER; return -EPROBE_DEFER;
max98090->codec = codec; max98090->component = component;
/* Reset the codec, the DSP core, and disable all interrupts */ /* Reset the codec, the DSP core, and disable all interrupts */
max98090_reset(max98090); max98090_reset(max98090);
@ -2394,26 +2394,26 @@ static int max98090_probe(struct snd_soc_codec *codec)
max98090->pa1en = 0; max98090->pa1en = 0;
max98090->pa2en = 0; max98090->pa2en = 0;
ret = snd_soc_read(codec, M98090_REG_REVISION_ID); ret = snd_soc_component_read32(component, M98090_REG_REVISION_ID);
if (ret < 0) { if (ret < 0) {
dev_err(codec->dev, "Failed to read device revision: %d\n", dev_err(component->dev, "Failed to read device revision: %d\n",
ret); ret);
goto err_access; goto err_access;
} }
if ((ret >= M98090_REVA) && (ret <= M98090_REVA + 0x0f)) { if ((ret >= M98090_REVA) && (ret <= M98090_REVA + 0x0f)) {
devtype = MAX98090; devtype = MAX98090;
dev_info(codec->dev, "MAX98090 REVID=0x%02x\n", ret); dev_info(component->dev, "MAX98090 REVID=0x%02x\n", ret);
} else if ((ret >= M98091_REVA) && (ret <= M98091_REVA + 0x0f)) { } else if ((ret >= M98091_REVA) && (ret <= M98091_REVA + 0x0f)) {
devtype = MAX98091; devtype = MAX98091;
dev_info(codec->dev, "MAX98091 REVID=0x%02x\n", ret); dev_info(component->dev, "MAX98091 REVID=0x%02x\n", ret);
} else { } else {
devtype = MAX98090; devtype = MAX98090;
dev_err(codec->dev, "Unrecognized revision 0x%02x\n", ret); dev_err(component->dev, "Unrecognized revision 0x%02x\n", ret);
} }
if (max98090->devtype != devtype) { if (max98090->devtype != devtype) {
dev_warn(codec->dev, "Mismatch in DT specified CODEC type.\n"); dev_warn(component->dev, "Mismatch in DT specified CODEC type.\n");
max98090->devtype = devtype; max98090->devtype = devtype;
} }
@ -2427,7 +2427,7 @@ static int max98090_probe(struct snd_soc_codec *codec)
INIT_WORK(&max98090->pll_work, max98090_pll_work); INIT_WORK(&max98090->pll_work, max98090_pll_work);
/* Enable jack detection */ /* Enable jack detection */
snd_soc_write(codec, M98090_REG_JACK_DETECT, snd_soc_component_write(component, M98090_REG_JACK_DETECT,
M98090_JDETEN_MASK | M98090_JDEB_25MS); M98090_JDETEN_MASK | M98090_JDEB_25MS);
/* /*
@ -2435,75 +2435,76 @@ static int max98090_probe(struct snd_soc_codec *codec)
* An old interrupt ocurring prior to installing the ISR * An old interrupt ocurring prior to installing the ISR
* can keep a new interrupt from generating a trigger. * can keep a new interrupt from generating a trigger.
*/ */
snd_soc_read(codec, M98090_REG_DEVICE_STATUS); snd_soc_component_read32(component, M98090_REG_DEVICE_STATUS);
/* High Performance is default */ /* High Performance is default */
snd_soc_update_bits(codec, M98090_REG_DAC_CONTROL, snd_soc_component_update_bits(component, M98090_REG_DAC_CONTROL,
M98090_DACHP_MASK, M98090_DACHP_MASK,
1 << M98090_DACHP_SHIFT); 1 << M98090_DACHP_SHIFT);
snd_soc_update_bits(codec, M98090_REG_DAC_CONTROL, snd_soc_component_update_bits(component, M98090_REG_DAC_CONTROL,
M98090_PERFMODE_MASK, M98090_PERFMODE_MASK,
0 << M98090_PERFMODE_SHIFT); 0 << M98090_PERFMODE_SHIFT);
snd_soc_update_bits(codec, M98090_REG_ADC_CONTROL, snd_soc_component_update_bits(component, M98090_REG_ADC_CONTROL,
M98090_ADCHP_MASK, M98090_ADCHP_MASK,
1 << M98090_ADCHP_SHIFT); 1 << M98090_ADCHP_SHIFT);
/* Turn on VCM bandgap reference */ /* Turn on VCM bandgap reference */
snd_soc_write(codec, M98090_REG_BIAS_CONTROL, snd_soc_component_write(component, M98090_REG_BIAS_CONTROL,
M98090_VCM_MODE_MASK); M98090_VCM_MODE_MASK);
err = device_property_read_u32(codec->dev, "maxim,micbias", &micbias); err = device_property_read_u32(component->dev, "maxim,micbias", &micbias);
if (err) { if (err) {
micbias = M98090_MBVSEL_2V8; micbias = M98090_MBVSEL_2V8;
dev_info(codec->dev, "use default 2.8v micbias\n"); dev_info(component->dev, "use default 2.8v micbias\n");
} else if (micbias > M98090_MBVSEL_2V8) { } else if (micbias > M98090_MBVSEL_2V8) {
dev_err(codec->dev, "micbias out of range 0x%x\n", micbias); dev_err(component->dev, "micbias out of range 0x%x\n", micbias);
micbias = M98090_MBVSEL_2V8; micbias = M98090_MBVSEL_2V8;
} }
snd_soc_update_bits(codec, M98090_REG_MIC_BIAS_VOLTAGE, snd_soc_component_update_bits(component, M98090_REG_MIC_BIAS_VOLTAGE,
M98090_MBVSEL_MASK, micbias); M98090_MBVSEL_MASK, micbias);
max98090_add_widgets(codec); max98090_add_widgets(component);
err_access: err_access:
return ret; return ret;
} }
static int max98090_remove(struct snd_soc_codec *codec) static void max98090_remove(struct snd_soc_component *component)
{ {
struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec); struct max98090_priv *max98090 = snd_soc_component_get_drvdata(component);
cancel_delayed_work_sync(&max98090->jack_work); cancel_delayed_work_sync(&max98090->jack_work);
cancel_delayed_work_sync(&max98090->pll_det_enable_work); cancel_delayed_work_sync(&max98090->pll_det_enable_work);
cancel_work_sync(&max98090->pll_det_disable_work); cancel_work_sync(&max98090->pll_det_disable_work);
cancel_work_sync(&max98090->pll_work); cancel_work_sync(&max98090->pll_work);
max98090->codec = NULL; max98090->component = NULL;
return 0;
} }
static void max98090_seq_notifier(struct snd_soc_dapm_context *dapm, static void max98090_seq_notifier(struct snd_soc_component *component,
enum snd_soc_dapm_type event, int subseq) enum snd_soc_dapm_type event, int subseq)
{ {
struct snd_soc_codec *codec = snd_soc_dapm_to_codec(dapm); struct max98090_priv *max98090 = snd_soc_component_get_drvdata(component);
struct max98090_priv *max98090 = snd_soc_codec_get_drvdata(codec);
if (max98090->shdn_pending) { if (max98090->shdn_pending) {
snd_soc_update_bits(codec, M98090_REG_DEVICE_SHUTDOWN, snd_soc_component_update_bits(component, M98090_REG_DEVICE_SHUTDOWN,
M98090_SHDNN_MASK, 0); M98090_SHDNN_MASK, 0);
msleep(40); msleep(40);
snd_soc_update_bits(codec, M98090_REG_DEVICE_SHUTDOWN, snd_soc_component_update_bits(component, M98090_REG_DEVICE_SHUTDOWN,
M98090_SHDNN_MASK, M98090_SHDNN_MASK); M98090_SHDNN_MASK, M98090_SHDNN_MASK);
max98090->shdn_pending = false; max98090->shdn_pending = false;
} }
} }
static const struct snd_soc_codec_driver soc_codec_dev_max98090 = { static const struct snd_soc_component_driver soc_component_dev_max98090 = {
.probe = max98090_probe, .probe = max98090_probe,
.remove = max98090_remove, .remove = max98090_remove,
.seq_notifier = max98090_seq_notifier, .seq_notifier = max98090_seq_notifier,
.set_bias_level = max98090_set_bias_level, .set_bias_level = max98090_set_bias_level,
.idle_bias_on = 1,
.use_pmdown_time = 1,
.endianness = 1,
.non_legacy_dai_naming = 1,
}; };
static const struct regmap_config max98090_regmap = { static const struct regmap_config max98090_regmap = {
@ -2570,8 +2571,8 @@ static int max98090_i2c_probe(struct i2c_client *i2c,
return ret; return ret;
} }
ret = snd_soc_register_codec(&i2c->dev, ret = devm_snd_soc_register_component(&i2c->dev,
&soc_codec_dev_max98090, max98090_dai, &soc_component_dev_max98090, max98090_dai,
ARRAY_SIZE(max98090_dai)); ARRAY_SIZE(max98090_dai));
err_enable: err_enable:
return ret; return ret;
@ -2595,7 +2596,7 @@ static void max98090_i2c_shutdown(struct i2c_client *i2c)
static int max98090_i2c_remove(struct i2c_client *client) static int max98090_i2c_remove(struct i2c_client *client)
{ {
max98090_i2c_shutdown(client); max98090_i2c_shutdown(client);
snd_soc_unregister_codec(&client->dev);
return 0; return 0;
} }

4
sound/soc/codecs/max98090.h
View File

@ -1519,7 +1519,7 @@ struct max98090_cdata {
struct max98090_priv { struct max98090_priv {
struct regmap *regmap; struct regmap *regmap;
struct snd_soc_codec *codec; struct snd_soc_component *component;
enum max98090_type devtype; enum max98090_type devtype;
struct max98090_pdata *pdata; struct max98090_pdata *pdata;
struct clk *mclk; struct clk *mclk;
@ -1546,7 +1546,7 @@ struct max98090_priv {
bool shdn_pending; bool shdn_pending;
}; };
int max98090_mic_detect(struct snd_soc_codec *codec, int max98090_mic_detect(struct snd_soc_component *component,
struct snd_soc_jack *jack); struct snd_soc_jack *jack);
#endif #endif

448
sound/soc/codecs/max98095.c
View File

File diff suppressed because it is too large Load Diff

2
sound/soc/codecs/max98095.h
View File

@ -315,7 +315,7 @@
/* Default Delay used in Slew Rate Calculation for Jack detection */ /* Default Delay used in Slew Rate Calculation for Jack detection */
#define M98095_DEFAULT_SLEW_DELAY 0x18 #define M98095_DEFAULT_SLEW_DELAY 0x18
extern int max98095_jack_detect(struct snd_soc_codec *codec, extern int max98095_jack_detect(struct snd_soc_component *component,
struct snd_soc_jack *hp_jack, struct snd_soc_jack *mic_jack); struct snd_soc_jack *hp_jack, struct snd_soc_jack *mic_jack);
#endif #endif

29
sound/soc/codecs/max98357a.c
View File

@ -59,27 +59,29 @@ static const struct snd_soc_dapm_route max98357a_dapm_routes[] = {
{"Speaker", NULL, "HiFi Playback"}, {"Speaker", NULL, "HiFi Playback"},
}; };
static int max98357a_codec_probe(struct snd_soc_codec *codec) static int max98357a_component_probe(struct snd_soc_component *component)
{ {
struct gpio_desc *sdmode; struct gpio_desc *sdmode;
sdmode = devm_gpiod_get_optional(codec->dev, "sdmode", GPIOD_OUT_LOW); sdmode = devm_gpiod_get_optional(component->dev, "sdmode", GPIOD_OUT_LOW);
if (IS_ERR(sdmode)) if (IS_ERR(sdmode))
return PTR_ERR(sdmode); return PTR_ERR(sdmode);
snd_soc_codec_set_drvdata(codec, sdmode); snd_soc_component_set_drvdata(component, sdmode);
return 0; return 0;
} }
static const struct snd_soc_codec_driver max98357a_codec_driver = { static const struct snd_soc_component_driver max98357a_component_driver = {
.probe = max98357a_codec_probe, .probe = max98357a_component_probe,
.component_driver = { .dapm_widgets = max98357a_dapm_widgets,
.dapm_widgets = max98357a_dapm_widgets, .num_dapm_widgets = ARRAY_SIZE(max98357a_dapm_widgets),
.num_dapm_widgets = ARRAY_SIZE(max98357a_dapm_widgets), .dapm_routes = max98357a_dapm_routes,
.dapm_routes = max98357a_dapm_routes, .num_dapm_routes = ARRAY_SIZE(max98357a_dapm_routes),
.num_dapm_routes = ARRAY_SIZE(max98357a_dapm_routes), .idle_bias_on = 1,
}, .use_pmdown_time = 1,
.endianness = 1,
.non_legacy_dai_naming = 1,
}; };
static const struct snd_soc_dai_ops max98357a_dai_ops = { static const struct snd_soc_dai_ops max98357a_dai_ops = {
@ -107,14 +109,13 @@ static struct snd_soc_dai_driver max98357a_dai_driver = {
static int max98357a_platform_probe(struct platform_device *pdev) static int max98357a_platform_probe(struct platform_device *pdev)
{ {
return snd_soc_register_codec(&pdev->dev, &max98357a_codec_driver, return devm_snd_soc_register_component(&pdev->dev,
&max98357a_component_driver,
&max98357a_dai_driver, 1); &max98357a_dai_driver, 1);
} }
static int max98357a_platform_remove(struct platform_device *pdev) static int max98357a_platform_remove(struct platform_device *pdev)
{ {
snd_soc_unregister_codec(&pdev->dev);
return 0; return 0;
} }

43
sound/soc/codecs/max98371.c
View File

@ -187,15 +187,15 @@ static const struct snd_kcontrol_new max98371_snd_controls[] = {
static int max98371_dai_set_fmt(struct snd_soc_dai *codec_dai, static int max98371_dai_set_fmt(struct snd_soc_dai *codec_dai,
unsigned int fmt) unsigned int fmt)
{ {
struct snd_soc_codec *codec = codec_dai->codec; struct snd_soc_component *component = codec_dai->component;
struct max98371_priv *max98371 = snd_soc_codec_get_drvdata(codec); struct max98371_priv *max98371 = snd_soc_component_get_drvdata(component);
unsigned int val = 0; unsigned int val = 0;
switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
case SND_SOC_DAIFMT_CBS_CFS: case SND_SOC_DAIFMT_CBS_CFS:
break; break;
default: default:
dev_err(codec->dev, "DAI clock mode unsupported"); dev_err(component->dev, "DAI clock mode unsupported");
return -EINVAL; return -EINVAL;
} }
@ -210,7 +210,7 @@ static int max98371_dai_set_fmt(struct snd_soc_dai *codec_dai,
val |= MAX98371_DAI_LEFT; val |= MAX98371_DAI_LEFT;
break; break;
default: default:
dev_err(codec->dev, "DAI wrong mode unsupported"); dev_err(component->dev, "DAI wrong mode unsupported");
return -EINVAL; return -EINVAL;
} }
regmap_update_bits(max98371->regmap, MAX98371_FMT, regmap_update_bits(max98371->regmap, MAX98371_FMT,
@ -222,8 +222,8 @@ static int max98371_dai_hw_params(struct snd_pcm_substream *substream,
struct snd_pcm_hw_params *params, struct snd_pcm_hw_params *params,
struct snd_soc_dai *dai) struct snd_soc_dai *dai)
{ {
struct snd_soc_codec *codec = dai->codec; struct snd_soc_component *component = dai->component;
struct max98371_priv *max98371 = snd_soc_codec_get_drvdata(codec); struct max98371_priv *max98371 = snd_soc_component_get_drvdata(component);
int blr_clk_ratio, ch_size, channels = params_channels(params); int blr_clk_ratio, ch_size, channels = params_channels(params);
int rate = params_rate(params); int rate = params_rate(params);
@ -348,15 +348,17 @@ static struct snd_soc_dai_driver max98371_dai[] = {
} }
}; };
static const struct snd_soc_codec_driver max98371_codec = { static const struct snd_soc_component_driver max98371_component = {
.component_driver = { .controls = max98371_snd_controls,
.controls = max98371_snd_controls, .num_controls = ARRAY_SIZE(max98371_snd_controls),
.num_controls = ARRAY_SIZE(max98371_snd_controls), .dapm_routes = max98371_audio_map,
.dapm_routes = max98371_audio_map, .num_dapm_routes = ARRAY_SIZE(max98371_audio_map),
.num_dapm_routes = ARRAY_SIZE(max98371_audio_map), .dapm_widgets = max98371_dapm_widgets,
.dapm_widgets = max98371_dapm_widgets, .num_dapm_widgets = ARRAY_SIZE(max98371_dapm_widgets),
.num_dapm_widgets = ARRAY_SIZE(max98371_dapm_widgets), .idle_bias_on = 1,
}, .use_pmdown_time = 1,
.endianness = 1,
.non_legacy_dai_naming = 1,
}; };
static const struct regmap_config max98371_regmap = { static const struct regmap_config max98371_regmap = {
@ -397,21 +399,15 @@ static int max98371_i2c_probe(struct i2c_client *i2c,
} }
dev_info(&i2c->dev, "device version %x\n", reg); dev_info(&i2c->dev, "device version %x\n", reg);
ret = snd_soc_register_codec(&i2c->dev, &max98371_codec, ret = devm_snd_soc_register_component(&i2c->dev, &max98371_component,
max98371_dai, ARRAY_SIZE(max98371_dai)); max98371_dai, ARRAY_SIZE(max98371_dai));
if (ret < 0) { if (ret < 0) {
dev_err(&i2c->dev, "Failed to register codec: %d\n", ret); dev_err(&i2c->dev, "Failed to register component: %d\n", ret);
return ret; return ret;
} }
return ret; return ret;
} }
static int max98371_i2c_remove(struct i2c_client *client)
{
snd_soc_unregister_codec(&client->dev);
return 0;
}
static const struct i2c_device_id max98371_i2c_id[] = { static const struct i2c_device_id max98371_i2c_id[] = {
{ "max98371", 0 }, { "max98371", 0 },
{ } { }
@ -432,7 +428,6 @@ static struct i2c_driver max98371_i2c_driver = {
.of_match_table = of_match_ptr(max98371_of_match), .of_match_table = of_match_ptr(max98371_of_match),
}, },
.probe = max98371_i2c_probe, .probe = max98371_i2c_probe,
.remove = max98371_i2c_remove,
.id_table = max98371_i2c_id, .id_table = max98371_i2c_id,
}; };

1
sound/soc/codecs/max98371.h
View File

@ -62,6 +62,5 @@
struct max98371_priv { struct max98371_priv {
struct regmap *regmap; struct regmap *regmap;
struct snd_soc_codec *codec;
}; };
#endif #endif

75
sound/soc/codecs/max98373.c
View File

@ -112,12 +112,12 @@ static struct reg_default max98373_reg[] = {
static int max98373_dai_set_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt) static int max98373_dai_set_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;
struct max98373_priv *max98373 = snd_soc_codec_get_drvdata(codec); struct max98373_priv *max98373 = snd_soc_component_get_drvdata(component);
unsigned int format = 0; unsigned int format = 0;
unsigned int invert = 0; unsigned int invert = 0;
dev_dbg(codec->dev, "%s: fmt 0x%08X\n", __func__, fmt); dev_dbg(component->dev, "%s: fmt 0x%08X\n", __func__, fmt);
switch (fmt & SND_SOC_DAIFMT_INV_MASK) { switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
case SND_SOC_DAIFMT_NB_NF: case SND_SOC_DAIFMT_NB_NF:
@ -126,7 +126,7 @@ static int max98373_dai_set_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt)
invert = MAX98373_PCM_MODE_CFG_PCM_BCLKEDGE; invert = MAX98373_PCM_MODE_CFG_PCM_BCLKEDGE;
break; break;
default: default:
dev_err(codec->dev, "DAI invert mode unsupported\n"); dev_err(component->dev, "DAI invert mode unsupported\n");
return -EINVAL; return -EINVAL;
} }
@ -177,10 +177,10 @@ static int max98373_get_bclk_sel(int bclk)
return 0; return 0;
} }
static int max98373_set_clock(struct snd_soc_codec *codec, static int max98373_set_clock(struct snd_soc_component *component,
struct snd_pcm_hw_params *params) struct snd_pcm_hw_params *params)
{ {
struct max98373_priv *max98373 = snd_soc_codec_get_drvdata(codec); struct max98373_priv *max98373 = snd_soc_component_get_drvdata(component);
/* BCLK/LRCLK ratio calculation */ /* BCLK/LRCLK ratio calculation */
int blr_clk_ratio = params_channels(params) * max98373->ch_size; int blr_clk_ratio = params_channels(params) * max98373->ch_size;
int value; int value;
@ -189,7 +189,7 @@ static int max98373_set_clock(struct snd_soc_codec *codec,
/* BCLK configuration */ /* BCLK configuration */
value = max98373_get_bclk_sel(blr_clk_ratio); value = max98373_get_bclk_sel(blr_clk_ratio);
if (!value) { if (!value) {
dev_err(codec->dev, "format unsupported %d\n", dev_err(component->dev, "format unsupported %d\n",
params_format(params)); params_format(params));
return -EINVAL; return -EINVAL;
} }
@ -206,8 +206,8 @@ static int max98373_dai_hw_params(struct snd_pcm_substream *substream,
struct snd_pcm_hw_params *params, struct snd_pcm_hw_params *params,
struct snd_soc_dai *dai) struct snd_soc_dai *dai)
{ {
struct snd_soc_codec *codec = dai->codec; struct snd_soc_component *component = dai->component;
struct max98373_priv *max98373 = snd_soc_codec_get_drvdata(codec); struct max98373_priv *max98373 = snd_soc_component_get_drvdata(component);
unsigned int sampling_rate = 0; unsigned int sampling_rate = 0;
unsigned int chan_sz = 0; unsigned int chan_sz = 0;
@ -223,7 +223,7 @@ static int max98373_dai_hw_params(struct snd_pcm_substream *substream,
chan_sz = MAX98373_PCM_MODE_CFG_CHANSZ_32; chan_sz = MAX98373_PCM_MODE_CFG_CHANSZ_32;
break; break;
default: default:
dev_err(codec->dev, "format unsupported %d\n", dev_err(component->dev, "format unsupported %d\n",
params_format(params)); params_format(params));
goto err; goto err;
} }
@ -234,7 +234,7 @@ static int max98373_dai_hw_params(struct snd_pcm_substream *substream,
MAX98373_R2024_PCM_DATA_FMT_CFG, MAX98373_R2024_PCM_DATA_FMT_CFG,
MAX98373_PCM_MODE_CFG_CHANSZ_MASK, chan_sz); MAX98373_PCM_MODE_CFG_CHANSZ_MASK, chan_sz);
dev_dbg(codec->dev, "format supported %d", dev_dbg(component->dev, "format supported %d",
params_format(params)); params_format(params));
/* sampling rate configuration */ /* sampling rate configuration */
@ -267,7 +267,7 @@ static int max98373_dai_hw_params(struct snd_pcm_substream *substream,
sampling_rate = MAX98373_PCM_SR_SET1_SR_48000; sampling_rate = MAX98373_PCM_SR_SET1_SR_48000;
break; break;
default: default:
dev_err(codec->dev, "rate %d not supported\n", dev_err(component->dev, "rate %d not supported\n",
params_rate(params)); params_rate(params));
goto err; goto err;
} }
@ -295,7 +295,7 @@ static int max98373_dai_hw_params(struct snd_pcm_substream *substream,
MAX98373_PCM_SR_SET2_IVADC_SR_MASK, MAX98373_PCM_SR_SET2_IVADC_SR_MASK,
sampling_rate); sampling_rate);
return max98373_set_clock(codec, params); return max98373_set_clock(component, params);
err: err:
return -EINVAL; return -EINVAL;
} }
@ -304,8 +304,8 @@ static int max98373_dai_tdm_slot(struct snd_soc_dai *dai,
unsigned int tx_mask, unsigned int rx_mask, unsigned int tx_mask, unsigned int rx_mask,
int slots, int slot_width) int slots, int slot_width)
{ {
struct snd_soc_codec *codec = dai->codec; struct snd_soc_component *component = dai->component;
struct max98373_priv *max98373 = snd_soc_codec_get_drvdata(codec); struct max98373_priv *max98373 = snd_soc_component_get_drvdata(component);
int bsel = 0; int bsel = 0;
unsigned int chan_sz = 0; unsigned int chan_sz = 0;
unsigned int mask; unsigned int mask;
@ -319,7 +319,7 @@ static int max98373_dai_tdm_slot(struct snd_soc_dai *dai,
/* BCLK configuration */ /* BCLK configuration */
bsel = max98373_get_bclk_sel(slots * slot_width); bsel = max98373_get_bclk_sel(slots * slot_width);
if (bsel == 0) { if (bsel == 0) {
dev_err(codec->dev, "BCLK %d not supported\n", dev_err(component->dev, "BCLK %d not supported\n",
slots * slot_width); slots * slot_width);
return -EINVAL; return -EINVAL;
} }
@ -341,7 +341,7 @@ static int max98373_dai_tdm_slot(struct snd_soc_dai *dai,
chan_sz = MAX98373_PCM_MODE_CFG_CHANSZ_32; chan_sz = MAX98373_PCM_MODE_CFG_CHANSZ_32;
break; break;
default: default:
dev_err(codec->dev, "format unsupported %d\n", dev_err(component->dev, "format unsupported %d\n",
slot_width); slot_width);
return -EINVAL; return -EINVAL;
} }
@ -394,8 +394,8 @@ static const struct snd_soc_dai_ops max98373_dai_ops = {
static int max98373_dac_event(struct snd_soc_dapm_widget *w, static int max98373_dac_event(struct snd_soc_dapm_widget *w,
struct snd_kcontrol *kcontrol, int event) 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 max98373_priv *max98373 = snd_soc_codec_get_drvdata(codec); struct max98373_priv *max98373 = snd_soc_component_get_drvdata(component);
switch (event) { switch (event) {
case SND_SOC_DAPM_POST_PMU: case SND_SOC_DAPM_POST_PMU:
@ -721,11 +721,9 @@ static struct snd_soc_dai_driver max98373_dai[] = {
} }
}; };
static int max98373_probe(struct snd_soc_codec *codec) static int max98373_probe(struct snd_soc_component *component)
{ {
struct max98373_priv *max98373 = snd_soc_codec_get_drvdata(codec); struct max98373_priv *max98373 = snd_soc_component_get_drvdata(component);
codec->control_data = max98373->regmap;
/* Software Reset */ /* Software Reset */
regmap_write(max98373->regmap, regmap_write(max98373->regmap,
@ -828,16 +826,18 @@ static const struct dev_pm_ops max98373_pm = {
SET_SYSTEM_SLEEP_PM_OPS(max98373_suspend, max98373_resume) SET_SYSTEM_SLEEP_PM_OPS(max98373_suspend, max98373_resume)
}; };
static const struct snd_soc_codec_driver soc_codec_dev_max98373 = { static const struct snd_soc_component_driver soc_codec_dev_max98373 = {
.probe = max98373_probe, .probe = max98373_probe,
.component_driver = { .controls = max98373_snd_controls,
.controls = max98373_snd_controls, .num_controls = ARRAY_SIZE(max98373_snd_controls),
.num_controls = ARRAY_SIZE(max98373_snd_controls), .dapm_widgets = max98373_dapm_widgets,
.dapm_widgets = max98373_dapm_widgets, .num_dapm_widgets = ARRAY_SIZE(max98373_dapm_widgets),
.num_dapm_widgets = ARRAY_SIZE(max98373_dapm_widgets), .dapm_routes = max98373_audio_map,
.dapm_routes = max98373_audio_map, .num_dapm_routes = ARRAY_SIZE(max98373_audio_map),
.num_dapm_routes = ARRAY_SIZE(max98373_audio_map), .idle_bias_on = 1,
}, .use_pmdown_time = 1,
.endianness = 1,
.non_legacy_dai_naming = 1,
}; };
static const struct regmap_config max98373_regmap = { static const struct regmap_config max98373_regmap = {
@ -920,7 +920,7 @@ static int max98373_i2c_probe(struct i2c_client *i2c,
max98373_slot_config(i2c, max98373); max98373_slot_config(i2c, max98373);
/* codec registeration */ /* codec registeration */
ret = snd_soc_register_codec(&i2c->dev, &soc_codec_dev_max98373, ret = devm_snd_soc_register_component(&i2c->dev, &soc_codec_dev_max98373,
max98373_dai, ARRAY_SIZE(max98373_dai)); max98373_dai, ARRAY_SIZE(max98373_dai));
if (ret < 0) if (ret < 0)
dev_err(&i2c->dev, "Failed to register codec: %d\n", ret); dev_err(&i2c->dev, "Failed to register codec: %d\n", ret);
@ -928,12 +928,6 @@ static int max98373_i2c_probe(struct i2c_client *i2c,
return ret; return ret;
} }
static int max98373_i2c_remove(struct i2c_client *client)
{
snd_soc_unregister_codec(&client->dev);
return 0;
}
static const struct i2c_device_id max98373_i2c_id[] = { static const struct i2c_device_id max98373_i2c_id[] = {
{ "max98373", 0}, { "max98373", 0},
{ }, { },
@ -965,7 +959,6 @@ static struct i2c_driver max98373_i2c_driver = {
.pm = &max98373_pm, .pm = &max98373_pm,
}, },
.probe = max98373_i2c_probe, .probe = max98373_i2c_probe,
.remove = max98373_i2c_remove,
.id_table = max98373_i2c_id, .id_table = max98373_i2c_id,
}; };

4
sound/soc/mediatek/mt8173/mt8173-max98090.c
View File

@ -75,7 +75,7 @@ static int mt8173_max98090_init(struct snd_soc_pcm_runtime *runtime)
{ {
int ret; int ret;
struct snd_soc_card *card = runtime->card; struct snd_soc_card *card = runtime->card;
struct snd_soc_codec *codec = runtime->codec; struct snd_soc_component *component = runtime->codec_dai->component;
/* enable jack detection */ /* enable jack detection */
ret = snd_soc_card_jack_new(card, "Headphone", SND_JACK_HEADPHONE, ret = snd_soc_card_jack_new(card, "Headphone", SND_JACK_HEADPHONE,
@ -87,7 +87,7 @@ static int mt8173_max98090_init(struct snd_soc_pcm_runtime *runtime)
return ret; return ret;
} }
return max98090_mic_detect(codec, &mt8173_max98090_jack); return max98090_mic_detect(component, &mt8173_max98090_jack);
} }
/* Digital audio interface glue - connects codec <---> CPU */ /* Digital audio interface glue - connects codec <---> CPU */