自学教程：C++ snd_soc_component_get_drvdata函数代码示例

static int wm9712_soc_probe(struct snd_soc_component *component){	struct wm9712_priv *wm9712 = snd_soc_component_get_drvdata(component);	struct regmap *regmap;	int ret;	if (wm9712->mfd_pdata) {		wm9712->ac97 = wm9712->mfd_pdata->ac97;		regmap = wm9712->mfd_pdata->regmap;	} else {#ifdef CONFIG_SND_SOC_AC97_BUS		wm9712->ac97 = snd_soc_new_ac97_component(component, WM9712_VENDOR_ID,						      WM9712_VENDOR_ID_MASK);		if (IS_ERR(wm9712->ac97)) {			ret = PTR_ERR(wm9712->ac97);			dev_err(component->dev,				"Failed to register AC97 codec: %d/n", ret);			return ret;		}		regmap = regmap_init_ac97(wm9712->ac97, &wm9712_regmap_config);		if (IS_ERR(regmap)) {			snd_soc_free_ac97_component(wm9712->ac97);			return PTR_ERR(regmap);		}#endif	}	snd_soc_component_init_regmap(component, regmap);	/* set alc mux to none */	snd_soc_component_update_bits(component, AC97_VIDEO, 0x3000, 0x3000);	return 0;}

/** * cs4270_set_dai_fmt - configure the codec for the selected audio format * @codec_dai: the codec DAI * @format: a SND_SOC_DAIFMT_x value indicating the data format * * This function takes a bitmask of SND_SOC_DAIFMT_x bits and programs the * codec accordingly. * * Currently, this function only supports SND_SOC_DAIFMT_I2S and * SND_SOC_DAIFMT_LEFT_J.  The CS4270 codec also supports right-justified * data for playback only, but ASoC currently does not support different * formats for playback vs. record. */static int cs4270_set_dai_fmt(struct snd_soc_dai *codec_dai,			      unsigned int format){	struct snd_soc_component *component = codec_dai->component;	struct cs4270_private *cs4270 = snd_soc_component_get_drvdata(component);	/* set DAI format */	switch (format & SND_SOC_DAIFMT_FORMAT_MASK) {	case SND_SOC_DAIFMT_I2S:	case SND_SOC_DAIFMT_LEFT_J:		cs4270->mode = format & SND_SOC_DAIFMT_FORMAT_MASK;		break;	default:		dev_err(component->dev, "invalid dai format/n");		return -EINVAL;	}	/* set master/slave audio interface */	switch (format & SND_SOC_DAIFMT_MASTER_MASK) {	case SND_SOC_DAIFMT_CBS_CFS:		cs4270->slave_mode = 1;		break;	case SND_SOC_DAIFMT_CBM_CFM:		cs4270->slave_mode = 0;		break;	default:		/* all other modes are unsupported by the hardware */		dev_err(component->dev, "Unknown master/slave configuration/n");		return -EINVAL;	}	return 0;}

static int wm8711_hw_params(struct snd_pcm_substream *substream,	struct snd_pcm_hw_params *params,	struct snd_soc_dai *dai){	struct snd_soc_component *component = dai->component;	struct wm8711_priv *wm8711 =  snd_soc_component_get_drvdata(component);	u16 iface = snd_soc_component_read32(component, WM8711_IFACE) & 0xfff3;	int i = get_coeff(wm8711->sysclk, params_rate(params));	u16 srate = (coeff_div[i].sr << 2) |		(coeff_div[i].bosr << 1) | coeff_div[i].usb;	snd_soc_component_write(component, WM8711_SRATE, srate);	/* bit size */	switch (params_width(params)) {	case 16:		break;	case 20:		iface |= 0x0004;		break;	case 24:		iface |= 0x0008;		break;	}	snd_soc_component_write(component, WM8711_IFACE, iface);	return 0;}

static void mc13783_remove(struct snd_soc_component *component){	struct mc13783_priv *priv = snd_soc_component_get_drvdata(component);	/* Make sure VAUDIOON is off */	mc13xxx_reg_rmw(priv->mc13xxx, MC13783_AUDIO_RX0, 0x3, 0);}

static int tas571x_hw_params(struct snd_pcm_substream *substream,			     struct snd_pcm_hw_params *params,			     struct snd_soc_dai *dai){	struct tas571x_private *priv = snd_soc_component_get_drvdata(dai->component);	u32 val;	switch (priv->format & SND_SOC_DAIFMT_FORMAT_MASK) {	case SND_SOC_DAIFMT_RIGHT_J:		val = 0x00;		break;	case SND_SOC_DAIFMT_I2S:		val = 0x03;		break;	case SND_SOC_DAIFMT_LEFT_J:		val = 0x06;		break;	default:		return -EINVAL;	}	if (params_width(params) >= 24)		val += 2;	else if (params_width(params) >= 20)		val += 1;	return regmap_update_bits(priv->regmap, TAS571X_SDI_REG,				  TAS571X_SDI_FMT_MASK, val);}

static int cs35l33_pcm_hw_params(struct snd_pcm_substream *substream,				 struct snd_pcm_hw_params *params,				 struct snd_soc_dai *dai){	struct snd_soc_component *component = dai->component;	struct cs35l33_private *priv = snd_soc_component_get_drvdata(component);	int sample_size = params_width(params);	int coeff = cs35l33_get_mclk_coeff(priv->mclk_int, params_rate(params));	if (coeff < 0)		return coeff;	regmap_update_bits(priv->regmap, CS35L33_CLK_CTL,		CS35L33_ADSP_FS | CS35L33_INT_FS_RATE,		cs35l33_mclk_coeffs[coeff].int_fs_ratio		| cs35l33_mclk_coeffs[coeff].adsp_rate);	if (priv->is_tdm_mode) {		sample_size = (sample_size / 8) - 1;		if (sample_size > 2)			sample_size = 2;		regmap_update_bits(priv->regmap, CS35L33_RX_AUD,			CS35L33_AUDIN_RX_DEPTH,			sample_size << CS35L33_AUDIN_RX_DEPTH_SHIFT);	}	dev_dbg(component->dev, "sample rate=%d, bits per sample=%d/n",		params_rate(params), params_width(params));	return 0;}

static int cs35l33_set_bst_ipk(struct snd_soc_component *component, unsigned int bst){	struct cs35l33_private *cs35l33 = snd_soc_component_get_drvdata(component);	int ret = 0, steps = 0;	/* Boost current in uA */	if (bst > 3600000 || bst < 1850000) {		dev_err(component->dev, "Invalid boost current %d/n", bst);		ret = -EINVAL;		goto err;	}	if (bst % 15625) {		dev_err(component->dev, "Current not a multiple of 15625uA (%d)/n",			bst);		ret = -EINVAL;		goto err;	}	while (bst > 1850000) {		bst -= 15625;		steps++;	}	regmap_write(cs35l33->regmap, CS35L33_BST_PEAK_CTL,		steps+0x70);err:	return ret;}

static int ak5558_hw_params(struct snd_pcm_substream *substream,			    struct snd_pcm_hw_params *params,			    struct snd_soc_dai *dai){	struct snd_soc_component *component = dai->component;	struct ak5558_priv *ak5558 = snd_soc_component_get_drvdata(component);	u8 bits;	int pcm_width = max(params_physical_width(params), ak5558->slot_width);	/* set master/slave audio interface */	bits = snd_soc_component_read32(component, AK5558_02_CONTROL1);	bits &= ~AK5558_BITS;	switch (pcm_width) {	case 16:		bits |= AK5558_DIF_24BIT_MODE;		break;	case 32:		bits |= AK5558_DIF_32BIT_MODE;		break;	default:		return -EINVAL;	}	snd_soc_component_update_bits(component, AK5558_02_CONTROL1, AK5558_BITS, bits);	return 0;}

static int ak5558_set_tdm_slot(struct snd_soc_dai *dai, unsigned int tx_mask,			       unsigned int rx_mask, int slots,			       int slot_width){	struct snd_soc_component *component = dai->component;	struct ak5558_priv *ak5558 = snd_soc_component_get_drvdata(component);	int tdm_mode;	ak5558->slots = slots;	ak5558->slot_width = slot_width;	switch (slots * slot_width) {	case 128:		tdm_mode = AK5558_MODE_TDM128;		break;	case 256:		tdm_mode = AK5558_MODE_TDM256;		break;	case 512:		tdm_mode = AK5558_MODE_TDM512;		break;	default:		tdm_mode = AK5558_MODE_NORMAL;		break;	}	snd_soc_component_update_bits(component, AK5558_03_CONTROL2, AK5558_MODE_BITS,			    tdm_mode);	return 0;}

static int uda134x_set_dai_fmt(struct snd_soc_dai *codec_dai,			       unsigned int fmt){	struct snd_soc_component *component = codec_dai->component;	struct uda134x_priv *uda134x = snd_soc_component_get_drvdata(component);	pr_debug("%s fmt: %08X/n", __func__, fmt);	/* codec supports only full slave mode */	if ((fmt & SND_SOC_DAIFMT_MASTER_MASK) != SND_SOC_DAIFMT_CBS_CFS) {		printk(KERN_ERR "%s unsupported slave mode/n", __func__);		return -EINVAL;	}	/* no support for clock inversion */	if ((fmt & SND_SOC_DAIFMT_INV_MASK) != SND_SOC_DAIFMT_NB_NF) {		printk(KERN_ERR "%s unsupported clock inversion/n", __func__);		return -EINVAL;	}	/* We can't setup DAI format here as it depends on the word bit num */	/* so let's just store the value for later */	uda134x->dai_fmt = fmt;	return 0;}

static int uda134x_set_bias_level(struct snd_soc_component *component,				  enum snd_soc_bias_level level){	struct uda134x_priv *uda134x = snd_soc_component_get_drvdata(component);	struct uda134x_platform_data *pd = uda134x->pd;	pr_debug("%s bias level %d/n", __func__, level);	switch (level) {	case SND_SOC_BIAS_ON:		break;	case SND_SOC_BIAS_PREPARE:		/* power on */		if (pd->power) {			pd->power(1);			regcache_sync(uda134x->regmap);		}		break;	case SND_SOC_BIAS_STANDBY:		break;	case SND_SOC_BIAS_OFF:		/* power off */		if (pd->power) {			pd->power(0);			regcache_mark_dirty(uda134x->regmap);		}		break;	}	return 0;}

static int uda134x_startup(struct snd_pcm_substream *substream,	struct snd_soc_dai *dai){	struct snd_soc_component *component = dai->component;	struct uda134x_priv *uda134x = snd_soc_component_get_drvdata(component);	struct snd_pcm_runtime *master_runtime;	if (uda134x->master_substream) {		master_runtime = uda134x->master_substream->runtime;		pr_debug("%s constraining to %d bits at %d/n", __func__,			 master_runtime->sample_bits,			 master_runtime->rate);		snd_pcm_hw_constraint_single(substream->runtime,					     SNDRV_PCM_HW_PARAM_RATE,					     master_runtime->rate);		snd_pcm_hw_constraint_single(substream->runtime,					     SNDRV_PCM_HW_PARAM_SAMPLE_BITS,					     master_runtime->sample_bits);		uda134x->slave_substream = substream;	} else		uda134x->master_substream = substream;	return 0;}

static snd_pcm_uframes_t mtk_afe_pcm_pointer			 (struct snd_pcm_substream *substream){	struct snd_soc_pcm_runtime *rtd = substream->private_data;	struct snd_soc_component *component = snd_soc_rtdcom_lookup(rtd, AFE_PCM_NAME);	struct mtk_base_afe *afe = snd_soc_component_get_drvdata(component);	struct mtk_base_afe_memif *memif = &afe->memif[rtd->cpu_dai->id];	const struct mtk_base_memif_data *memif_data = memif->data;	struct regmap *regmap = afe->regmap;	struct device *dev = afe->dev;	int reg_ofs_base = memif_data->reg_ofs_base;	int reg_ofs_cur = memif_data->reg_ofs_cur;	unsigned int hw_ptr = 0, hw_base = 0;	int ret, pcm_ptr_bytes;	ret = regmap_read(regmap, reg_ofs_cur, &hw_ptr);	if (ret || hw_ptr == 0) {		dev_err(dev, "%s hw_ptr err/n", __func__);		pcm_ptr_bytes = 0;		goto POINTER_RETURN_FRAMES;	}	ret = regmap_read(regmap, reg_ofs_base, &hw_base);	if (ret || hw_base == 0) {		dev_err(dev, "%s hw_ptr err/n", __func__);		pcm_ptr_bytes = 0;		goto POINTER_RETURN_FRAMES;	}	pcm_ptr_bytes = hw_ptr - hw_base;POINTER_RETURN_FRAMES:	return bytes_to_frames(substream->runtime, pcm_ptr_bytes);}

static int sta529_set_bias_level(struct snd_soc_component *component, enum		snd_soc_bias_level level){	struct sta529 *sta529 = snd_soc_component_get_drvdata(component);	switch (level) {	case SND_SOC_BIAS_ON:	case SND_SOC_BIAS_PREPARE:		snd_soc_component_update_bits(component, STA529_FFXCFG0, POWER_CNTLMSAK,				POWER_UP);		snd_soc_component_update_bits(component, STA529_MISC,	FFX_CLK_MSK,				FFX_CLK_ENB);		break;	case SND_SOC_BIAS_STANDBY:		if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_OFF)			regcache_sync(sta529->regmap);		snd_soc_component_update_bits(component, STA529_FFXCFG0,					POWER_CNTLMSAK, POWER_STDBY);		/* Making FFX output to zero */		snd_soc_component_update_bits(component, STA529_FFXCFG0, FFX_MASK,				FFX_OFF);		snd_soc_component_update_bits(component, STA529_MISC, FFX_CLK_MSK,				FFX_CLK_DIS);		break;	case SND_SOC_BIAS_OFF:		break;	}	return 0;}

static int cs35l33_spkrdrv_event(struct snd_soc_dapm_widget *w,	struct snd_kcontrol *kcontrol, int event){	struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);	struct cs35l33_private *priv = snd_soc_component_get_drvdata(component);	switch (event) {	case SND_SOC_DAPM_POST_PMU:		if (!priv->amp_cal) {			usleep_range(8000, 9000);			priv->amp_cal = true;			regmap_update_bits(priv->regmap, CS35L33_CLASSD_CTL,				    CS35L33_AMP_CAL, 0);			dev_dbg(component->dev, "Amp calibration done/n");		}		dev_dbg(component->dev, "Amp turned on/n");		break;	case SND_SOC_DAPM_POST_PMD:		dev_dbg(component->dev, "Amp turned off/n");		break;	default:		dev_err(component->dev, "Invalid event = 0x%x/n", event);		break;	}	return 0;}

static int ak5558_probe(struct snd_soc_component *component){	struct ak5558_priv *ak5558 = snd_soc_component_get_drvdata(component);	ak5558_power_on(ak5558);	return ak5558_set_mcki(component);}

static int cs35l33_set_bias_level(struct snd_soc_component *component,				  enum snd_soc_bias_level level){	unsigned int val;	struct cs35l33_private *priv = snd_soc_component_get_drvdata(component);	switch (level) {	case SND_SOC_BIAS_ON:		break;	case SND_SOC_BIAS_PREPARE:		regmap_update_bits(priv->regmap, CS35L33_PWRCTL1,				    CS35L33_PDN_ALL, 0);		regmap_update_bits(priv->regmap, CS35L33_CLK_CTL,				    CS35L33_MCLKDIS, 0);		break;	case SND_SOC_BIAS_STANDBY:		regmap_update_bits(priv->regmap, CS35L33_PWRCTL1,				    CS35L33_PDN_ALL, CS35L33_PDN_ALL);		regmap_read(priv->regmap, CS35L33_INT_STATUS_2, &val);		usleep_range(1000, 1100);		if (val & CS35L33_PDN_DONE)			regmap_update_bits(priv->regmap, CS35L33_CLK_CTL,					    CS35L33_MCLKDIS, CS35L33_MCLKDIS);		break;	case SND_SOC_BIAS_OFF:		break;	default:		return -EINVAL;	}	return 0;}

static int wm8728_set_bias_level(struct snd_soc_component *component,				 enum snd_soc_bias_level level){	struct wm8728_priv *wm8728 = snd_soc_component_get_drvdata(component);	u16 reg;	switch (level) {	case SND_SOC_BIAS_ON:	case SND_SOC_BIAS_PREPARE:	case SND_SOC_BIAS_STANDBY:		if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_OFF) {			/* Power everything up... */			reg = snd_soc_component_read32(component, WM8728_DACCTL);			snd_soc_component_write(component, WM8728_DACCTL, reg & ~0x4);			/* ..then sync in the register cache. */			regcache_sync(wm8728->regmap);		}		break;	case SND_SOC_BIAS_OFF:		reg = snd_soc_component_read32(component, WM8728_DACCTL);		snd_soc_component_write(component, WM8728_DACCTL, reg | 0x4);		break;	}	return 0;}

static int cs35l33_component_set_sysclk(struct snd_soc_component *component,		int clk_id, int source, unsigned int freq, int dir){	struct cs35l33_private *cs35l33 = snd_soc_component_get_drvdata(component);	switch (freq) {	case CS35L33_MCLK_5644:	case CS35L33_MCLK_6:	case CS35L33_MCLK_6144:		regmap_update_bits(cs35l33->regmap, CS35L33_CLK_CTL,			CS35L33_MCLKDIV2, 0);		cs35l33->mclk_int = freq;		break;	case CS35L33_MCLK_11289:	case CS35L33_MCLK_12:	case CS35L33_MCLK_12288:		regmap_update_bits(cs35l33->regmap, CS35L33_CLK_CTL,			CS35L33_MCLKDIV2, CS35L33_MCLKDIV2);		cs35l33->mclk_int = freq/2;		break;	default:		cs35l33->mclk_int = 0;		return -EINVAL;	}	dev_dbg(component->dev, "external mclk freq=%d, internal mclk freq=%d/n",		freq, cs35l33->mclk_int);	return 0;}

static int adau17x1_dsp_mux_enum_get(struct snd_kcontrol *kcontrol,	struct snd_ctl_elem_value *ucontrol){	struct snd_soc_component *component = snd_soc_dapm_kcontrol_component(kcontrol);	struct adau *adau = snd_soc_component_get_drvdata(component);	struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;	unsigned int stream = e->shift_l;	unsigned int reg, val;	int ret;	if (stream == SNDRV_PCM_STREAM_PLAYBACK)		reg = ADAU17X1_SERIAL_INPUT_ROUTE;	else		reg = ADAU17X1_SERIAL_OUTPUT_ROUTE;	ret = regmap_read(adau->regmap, reg, &val);	if (ret)		return ret;	if (val != 0)		val = 1;	ucontrol->value.enumerated.item[0] = val;	return 0;}

static int mc13783_probe(struct snd_soc_component *component){	struct mc13783_priv *priv = snd_soc_component_get_drvdata(component);	snd_soc_component_init_regmap(component,				  dev_get_regmap(component->dev->parent, NULL));	/* these are the reset values */	mc13xxx_reg_write(priv->mc13xxx, MC13783_AUDIO_RX0, 0x25893);	mc13xxx_reg_write(priv->mc13xxx, MC13783_AUDIO_RX1, 0x00d35A);	mc13xxx_reg_write(priv->mc13xxx, MC13783_AUDIO_TX, 0x420000);	mc13xxx_reg_write(priv->mc13xxx, MC13783_SSI_NETWORK, 0x013060);	mc13xxx_reg_write(priv->mc13xxx, MC13783_AUDIO_CODEC, 0x180027);	mc13xxx_reg_write(priv->mc13xxx, MC13783_AUDIO_DAC, 0x0e0004);	if (priv->adc_ssi_port == MC13783_SSI1_PORT)		mc13xxx_reg_rmw(priv->mc13xxx, MC13783_AUDIO_CODEC,				AUDIO_SSI_SEL, 0);	else		mc13xxx_reg_rmw(priv->mc13xxx, MC13783_AUDIO_CODEC,				AUDIO_SSI_SEL, AUDIO_SSI_SEL);	if (priv->dac_ssi_port == MC13783_SSI1_PORT)		mc13xxx_reg_rmw(priv->mc13xxx, MC13783_AUDIO_DAC,				AUDIO_SSI_SEL, 0);	else		mc13xxx_reg_rmw(priv->mc13xxx, MC13783_AUDIO_DAC,				AUDIO_SSI_SEL, AUDIO_SSI_SEL);	return 0;}

static int adau17x1_pll_event(struct snd_soc_dapm_widget *w,	struct snd_kcontrol *kcontrol, int event){	struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);	struct adau *adau = snd_soc_component_get_drvdata(component);	if (SND_SOC_DAPM_EVENT_ON(event)) {		adau->pll_regs[5] = 1;	} else {		adau->pll_regs[5] = 0;		/* Bypass the PLL when disabled, otherwise registers will become		 * inaccessible. */		regmap_update_bits(adau->regmap, ADAU17X1_CLOCK_CONTROL,			ADAU17X1_CLOCK_CONTROL_CORECLK_SRC_PLL, 0);	}	/* The PLL register is 6 bytes long and can only be written at once. */	regmap_raw_write(adau->regmap, ADAU17X1_PLL_CONTROL,			adau->pll_regs, ARRAY_SIZE(adau->pll_regs));	if (SND_SOC_DAPM_EVENT_ON(event)) {		mdelay(5);		regmap_update_bits(adau->regmap, ADAU17X1_CLOCK_CONTROL,			ADAU17X1_CLOCK_CONTROL_CORECLK_SRC_PLL,			ADAU17X1_CLOCK_CONTROL_CORECLK_SRC_PLL);	}	return 0;}

static int sst_byt_pcm_open(struct snd_pcm_substream *substream){	struct snd_soc_pcm_runtime *rtd = substream->private_data;	struct snd_soc_component *component = snd_soc_rtdcom_lookup(rtd, DRV_NAME);	struct sst_byt_priv_data *pdata = snd_soc_component_get_drvdata(component);	struct sst_byt_pcm_data *pcm_data = &pdata->pcm[substream->stream];	struct sst_byt *byt = pdata->byt;	dev_dbg(rtd->dev, "PCM: open/n");	mutex_lock(&pcm_data->mutex);	pcm_data->substream = substream;	snd_soc_set_runtime_hwparams(substream, &sst_byt_pcm_hardware);	pcm_data->stream = sst_byt_stream_new(byt, substream->stream + 1,					      byt_notify_pointer, pcm_data);	if (pcm_data->stream == NULL) {		dev_err(rtd->dev, "failed to create stream/n");		mutex_unlock(&pcm_data->mutex);		return -EINVAL;	}	mutex_unlock(&pcm_data->mutex);	return 0;}

int adau17x1_add_widgets(struct snd_soc_component *component){	struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);	struct adau *adau = snd_soc_component_get_drvdata(component);	int ret;	ret = snd_soc_add_component_controls(component, adau17x1_controls,		ARRAY_SIZE(adau17x1_controls));	if (ret)		return ret;	ret = snd_soc_dapm_new_controls(dapm, adau17x1_dapm_widgets,		ARRAY_SIZE(adau17x1_dapm_widgets));	if (ret)		return ret;	if (adau17x1_has_dsp(adau)) {		ret = snd_soc_dapm_new_controls(dapm, adau17x1_dsp_dapm_widgets,			ARRAY_SIZE(adau17x1_dsp_dapm_widgets));		if (ret)			return ret;		if (!adau->sigmadsp)			return 0;		ret = sigmadsp_attach(adau->sigmadsp, component);		if (ret) {			dev_err(component->dev, "Failed to attach firmware: %d/n",				ret);			return ret;		}	}	return 0;}

static int tas571x_set_bias_level(struct snd_soc_component *component,				  enum snd_soc_bias_level level){	struct tas571x_private *priv = snd_soc_component_get_drvdata(component);	int ret;	switch (level) {	case SND_SOC_BIAS_ON:		break;	case SND_SOC_BIAS_PREPARE:		break;	case SND_SOC_BIAS_STANDBY:		if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_OFF) {			if (!IS_ERR(priv->mclk)) {				ret = clk_prepare_enable(priv->mclk);				if (ret) {					dev_err(component->dev,						"Failed to enable master clock: %d/n",						ret);					return ret;				}			}		}		break;	case SND_SOC_BIAS_OFF:		if (!IS_ERR(priv->mclk))			clk_disable_unprepare(priv->mclk);		break;	}	return 0;}

static int ad1980_reset(struct snd_soc_component *component, int try_warm){	struct snd_ac97 *ac97 = snd_soc_component_get_drvdata(component);	unsigned int retry_cnt = 0;	int ret;	do {		ret = snd_ac97_reset(ac97, true, AD1980_VENDOR_ID,			AD1980_VENDOR_MASK);		if (ret >= 0)			return 0;		/*		 * Set bit 16slot in register 74h, then every slot will has only		 * 16 bits. This command is sent out in 20bit mode, in which		 * case the first nibble of data is eaten by the addr. (Tag is		 * always 16 bit)		 */		snd_soc_component_write(component, AC97_AD_SERIAL_CFG, 0x9900);	} while (retry_cnt++ < 10);	dev_err(component->dev, "Failed to reset: AC97 link error/n");	return -EIO;}

/** * cs4270_probe - ASoC probe function * @pdev: platform device * * This function is called when ASoC has all the pieces it needs to * instantiate a sound driver. */static int cs4270_probe(struct snd_soc_component *component){	struct cs4270_private *cs4270 = snd_soc_component_get_drvdata(component);	int ret;	/* Disable auto-mute.  This feature appears to be buggy.  In some	 * situations, auto-mute will not deactivate when it should, so we want	 * this feature disabled by default.  An application (e.g. alsactl) can	 * re-enabled it by using the controls.	 */	ret = snd_soc_component_update_bits(component, CS4270_MUTE, CS4270_MUTE_AUTO, 0);	if (ret < 0) {		dev_err(component->dev, "i2c write failed/n");		return ret;	}	/* Disable automatic volume control.  The hardware enables, and it	 * causes volume change commands to be delayed, sometimes until after	 * playback has started.  An application (e.g. alsactl) can	 * re-enabled it by using the controls.	 */	ret = snd_soc_component_update_bits(component, CS4270_TRANS,		CS4270_TRANS_SOFT | CS4270_TRANS_ZERO, 0);	if (ret < 0) {		dev_err(component->dev, "i2c write failed/n");		return ret;	}	ret = regulator_bulk_enable(ARRAY_SIZE(cs4270->supplies),				    cs4270->supplies);	return ret;}

static void ad1980_soc_remove(struct snd_soc_component *component){	struct snd_ac97 *ac97 = snd_soc_component_get_drvdata(component);	snd_soc_component_exit_regmap(component);	snd_soc_free_ac97_component(ac97);}

static int wm8711_set_bias_level(struct snd_soc_component *component,	enum snd_soc_bias_level level){	struct wm8711_priv *wm8711 = snd_soc_component_get_drvdata(component);	u16 reg = snd_soc_component_read32(component, WM8711_PWR) & 0xff7f;	switch (level) {	case SND_SOC_BIAS_ON:		snd_soc_component_write(component, WM8711_PWR, reg);		break;	case SND_SOC_BIAS_PREPARE:		break;	case SND_SOC_BIAS_STANDBY:		if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_OFF)			regcache_sync(wm8711->regmap);		snd_soc_component_write(component, WM8711_PWR, reg | 0x0040);		break;	case SND_SOC_BIAS_OFF:		snd_soc_component_write(component, WM8711_ACTIVE, 0x0);		snd_soc_component_write(component, WM8711_PWR, 0xffff);		break;	}	return 0;}

static int mtk_afe_i2s_mclk_connect(struct snd_soc_dapm_widget *source,				    struct snd_soc_dapm_widget *sink){	struct snd_soc_dapm_widget *w = sink;	struct snd_soc_component *cmpnt = snd_soc_dapm_to_component(w->dapm);	struct mtk_base_afe *afe = snd_soc_component_get_drvdata(cmpnt);	struct mtk_afe_i2s_priv *i2s_priv;	i2s_priv = get_i2s_priv_by_name(afe, sink->name);	if (!i2s_priv) {		dev_warn(afe->dev, "%s(), i2s_priv == NULL", __func__);		return 0;	}	if (get_i2s_id_by_name(afe, sink->name) ==	    get_i2s_id_by_name(afe, source->name))		return (i2s_priv->mclk_rate > 0) ? 1 : 0;	/* check if share i2s need mclk */	if (i2s_priv->share_i2s_id < 0)		return 0;	if (i2s_priv->share_i2s_id == get_i2s_id_by_name(afe, source->name))		return (i2s_priv->mclk_rate > 0) ? 1 : 0;	return 0;}