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

static void t0_micdet(u16 status, void *data){	struct wm1811_machine_priv *wm1811 = data;	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(wm1811->codec);	int report;	/*	 * If the jack is inserted abnormally,	 * The variable puts back to its previous status.	 */	if (!wm1811->get_g_det_value_f) {		dev_err(wm1811->codec->dev, "Do not use the ground detection/n");	} else {		if (wm1811->get_g_det_value_f()) {			dev_info(wm1811->codec->dev, "The jack is inserted abnormally/n");			wm8994->mic_detecting = false;		}	}	wake_lock_timeout(&wm1811->jackdet_wake_lock, 5 * HZ);	/* Either nothing present or just starting detection */	if (!(status & WM8958_MICD_STS)) {		if (!wm8994->jackdet) {			/* If nothing present then clear our statuses */			dev_dbg(wm1811->codec->dev, "Detected open circuit/n");			wm8994->jack_mic = false;			wm8994->mic_detecting = true;			t0_micd_set_rate(wm1811->codec);			snd_soc_jack_report(wm8994->micdet[0].jack, 0,					    wm8994->btn_mask |					     SND_JACK_HEADSET);		}		/*ToDo*/		/*return;*/	}	/* If the measurement is showing a high impedence we've got a	 * microphone.	 */	if (wm8994->mic_detecting && (status & 0x400)) {		dev_info(wm1811->codec->dev, "Detected microphone/n");		wm8994->mic_detecting = false;		wm8994->jack_mic = true;		t0_micd_set_rate(wm1811->codec);		snd_soc_jack_report(wm8994->micdet[0].jack, SND_JACK_HEADSET,				    SND_JACK_HEADSET);	}	if (wm8994->mic_detecting && status & 0x4) {		dev_info(wm1811->codec->dev, "Detected headphone/n");		wm8994->mic_detecting = false;		t0_micd_set_rate(wm1811->codec);		snd_soc_jack_report(wm8994->micdet[0].jack, SND_JACK_HEADPHONE,				    SND_JACK_HEADSET);		/* If we have jackdet that will detect removal */		if (wm8994->jackdet) {			mutex_lock(&wm8994->accdet_lock);			snd_soc_update_bits(wm1811->codec, WM8958_MIC_DETECT_1,					    WM8958_MICD_ENA, 0);			if (wm8994->active_refcount) {				snd_soc_update_bits(wm1811->codec,					WM8994_ANTIPOP_2,					WM1811_JACKDET_MODE_MASK,					WM1811_JACKDET_MODE_AUDIO);			}			mutex_unlock(&wm8994->accdet_lock);			if (wm8994->pdata->jd_ext_cap) {				mutex_lock(&wm1811->codec->mutex);				snd_soc_dapm_disable_pin(&wm1811->codec->dapm,							 "MICBIAS2");				snd_soc_dapm_sync(&wm1811->codec->dapm);				mutex_unlock(&wm1811->codec->mutex);			}		}	}	/* Report short circuit as a button */	if (wm8994->jack_mic) {		report = 0;		if (status & WM1811_JACKDET_BTN0)			report |= SND_JACK_BTN_0;		if (status & WM1811_JACKDET_BTN1)			report |= SND_JACK_BTN_1;		if (status & WM1811_JACKDET_BTN2)//.........这里部分代码省略.........

//.........这里部分代码省略.........	snd_soc_dapm_ignore_suspend(&codec->dapm, "AIF1DACDAT");	snd_soc_dapm_ignore_suspend(&codec->dapm, "AIF2DACDAT");	snd_soc_dapm_ignore_suspend(&codec->dapm, "AIF3DACDAT");	snd_soc_dapm_ignore_suspend(&codec->dapm, "AIF1ADCDAT");	snd_soc_dapm_ignore_suspend(&codec->dapm, "AIF2ADCDAT");	snd_soc_dapm_ignore_suspend(&codec->dapm, "AIF3ADCDAT");	snd_soc_dapm_ignore_suspend(&codec->dapm, "FM In");	snd_soc_dapm_ignore_suspend(&codec->dapm, "LINE");	snd_soc_dapm_ignore_suspend(&codec->dapm, "HDMI");	snd_soc_dapm_ignore_suspend(&codec->dapm, "Third Mic");	wm1811->codec = codec;	tab3_micd_set_rate(codec);#ifdef CONFIG_SEC_DEV_JACK	/* By default use idle_bias_off, will override for WM8994 */	codec->dapm.idle_bias_off = 0;#if defined (CONFIG_TAB3_00_BD)	if(system_rev < 2) {		ret = snd_soc_dapm_force_enable_pin(&codec->dapm, "MICBIAS2");		if (ret < 0)			dev_err(codec->dev, "Failed to enable MICBIAS2: %d/n",					ret);	}#endif#else /* CONFIG_SEC_DEV_JACK */	wm1811->jack.status = 0;	ret = snd_soc_jack_new(codec, "Tab3 Jack",				SND_JACK_HEADSET | SND_JACK_BTN_0 |				SND_JACK_BTN_1 | SND_JACK_BTN_2,				&wm1811->jack);	if (ret < 0)		dev_err(codec->dev, "Failed to create jack: %d/n", ret);	ret = snd_jack_set_key(wm1811->jack.jack, SND_JACK_BTN_0, KEY_MEDIA);	if (ret < 0)		dev_err(codec->dev, "Failed to set KEY_MEDIA: %d/n", ret);	ret = snd_jack_set_key(wm1811->jack.jack, SND_JACK_BTN_1,							KEY_VOLUMEUP);	if (ret < 0)		dev_err(codec->dev, "Failed to set KEY_VOLUMEUP: %d/n", ret);	ret = snd_jack_set_key(wm1811->jack.jack, SND_JACK_BTN_2,							KEY_VOLUMEDOWN);	if (ret < 0)		dev_err(codec->dev, "Failed to set KEY_VOLUMEDOWN: %d/n", ret);	if (wm8994->revision > 1) {		dev_info(codec->dev, "wm1811: Rev %c support mic detection/n",			'A' + wm8994->revision);		ret = wm8958_mic_detect(codec, &wm1811->jack, NULL,				NULL, tab3_mic_id, wm1811);		if (ret < 0)			dev_err(codec->dev, "Failed start detection: %d/n",				ret);	} else {		dev_info(codec->dev, "wm1811: Rev %c doesn't support mic detection/n",			'A' + wm8994->revision);		codec->dapm.idle_bias_off = 0;	}	/* To wakeup for earjack event in suspend mode */	enable_irq_wake(control->irq);	wake_lock_init(&wm1811->jackdet_wake_lock,					WAKE_LOCK_SUSPEND, "Tab3_jackdet");	/* To support PBA function test */	jack_class = class_create(THIS_MODULE, "audio");	if (IS_ERR(jack_class))		pr_err("Failed to create class/n");	jack_dev = device_create(jack_class, NULL, 0, codec, "earjack");	if (device_create_file(jack_dev, &dev_attr_select_jack) < 0)		pr_err("Failed to create device file (%s)!/n",			dev_attr_select_jack.attr.name);	if (device_create_file(jack_dev, &dev_attr_key_state) < 0)		pr_err("Failed to create device file (%s)!/n",			dev_attr_key_state.attr.name);	if (device_create_file(jack_dev, &dev_attr_state) < 0)		pr_err("Failed to create device file (%s)!/n",			dev_attr_state.attr.name);	if (device_create_file(jack_dev, &dev_attr_reselect_jack) < 0)		pr_err("Failed to create device file (%s)!/n",			dev_attr_reselect_jack.attr.name);#endif /* CONFIG_SEC_DEV_JACK */	return snd_soc_dapm_sync(&codec->dapm);}

//.........这里部分代码省略.........			ret = PTR_ERR(machine->audio_reg);			return ret;		}		ret = regulator_enable(machine->audio_reg);		if (ret) {			dev_err(card->dev, "cannot enable avddio_audio reg/n");			regulator_put(machine->audio_reg);			machine->audio_reg = NULL;			return ret;		}	}	if (gpio_is_valid(pdata->gpio_spkr_en)) {		ret = gpio_request(pdata->gpio_spkr_en, "spkr_en");		if (ret) {			dev_err(card->dev, "cannot get spkr_en gpio/n");			return ret;		}		machine->gpio_requested |= GPIO_SPKR_EN;		gpio_direction_output(pdata->gpio_spkr_en, 0);	}	if (gpio_is_valid(pdata->gpio_hp_mute)) {		ret = gpio_request(pdata->gpio_hp_mute, "hp_mute");		if (ret) {			dev_err(card->dev, "cannot get hp_mute gpio/n");			return ret;		}		machine->gpio_requested |= GPIO_HP_MUTE;		gpio_direction_output(pdata->gpio_hp_mute, 0);	}	if (gpio_is_valid(pdata->gpio_int_mic_en)) {		ret = gpio_request(pdata->gpio_int_mic_en, "int_mic_en");		if (ret) {			dev_err(card->dev, "cannot get int_mic_en gpio/n");			return ret;		}		machine->gpio_requested |= GPIO_INT_MIC_EN;		/* Disable int mic; enable signal is active-high */		gpio_direction_output(pdata->gpio_int_mic_en, 0);	}	if (gpio_is_valid(pdata->gpio_ext_mic_en)) {		ret = gpio_request(pdata->gpio_ext_mic_en, "ext_mic_en");		if (ret) {			dev_err(card->dev, "cannot get ext_mic_en gpio/n");			return ret;		}		machine->gpio_requested |= GPIO_EXT_MIC_EN;		/* Enable ext mic; enable signal is active-low */		gpio_direction_output(pdata->gpio_ext_mic_en, 0);	}	ret = snd_soc_add_controls(codec, tegra_aic326x_controls,				   ARRAY_SIZE(tegra_aic326x_controls));	if (ret < 0)		return ret;	snd_soc_dapm_new_controls(dapm, tegra_aic326x_dapm_widgets,					ARRAY_SIZE(tegra_aic326x_dapm_widgets));	snd_soc_dapm_add_routes(dapm, aic326x_audio_map,					ARRAY_SIZE(aic326x_audio_map));	ret = snd_soc_jack_new(codec, "Headset Jack", SND_JACK_HEADSET,			&tegra_aic326x_hp_jack);	if (ret < 0)		return ret;#ifdef CONFIG_SWITCH	snd_soc_jack_notifier_register(&tegra_aic326x_hp_jack,		&aic326x_headset_switch_nb);#else /*gpio based headset detection*/	snd_soc_jack_add_pins(&tegra_aic326x_hp_jack,		ARRAY_SIZE(tegra_aic326x_hp_jack_pins),		tegra_aic326x_hp_jack_pins);#endif	aic326x_headset_detect(codec, &tegra_aic326x_hp_jack,		SND_JACK_HEADSET);	/* Add call mode switch control */	ret = snd_ctl_add(codec->card->snd_card,			snd_ctl_new1(&tegra_aic326x_call_mode_control,				machine));	if (ret < 0)		return ret;	snd_soc_dapm_force_enable_pin(dapm, "MICBIAS_EXT ON");	snd_soc_dapm_force_enable_pin(dapm,"MICBIAS_INT ON");	snd_soc_dapm_sync(dapm);	return 0;}

static int msm8960_audrx_init(struct snd_soc_pcm_runtime *rtd){	int err;	struct snd_soc_codec *codec = rtd->codec;	struct snd_soc_dapm_context *dapm = &codec->dapm;	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;	struct pm_gpio jack_gpio_cfg = {		.direction = PM_GPIO_DIR_IN,		.pull = PM_GPIO_PULL_UP_1P5,		.function = PM_GPIO_FUNC_NORMAL,		.vin_sel = 2,		.inv_int_pol = 0,	};	pr_debug("%s(), dev_name%s/n", __func__, dev_name(cpu_dai->dev));	if (machine_is_msm8960_liquid()) {		top_spk_pamp_gpio = (PM8921_GPIO_PM_TO_SYS(19));		bottom_spk_pamp_gpio = (PM8921_GPIO_PM_TO_SYS(18));	}	snd_soc_dapm_new_controls(dapm, msm8960_dapm_widgets,				ARRAY_SIZE(msm8960_dapm_widgets));	snd_soc_dapm_add_routes(dapm, common_audio_map,		ARRAY_SIZE(common_audio_map));	snd_soc_dapm_enable_pin(dapm, "Ext Spk Bottom Pos");	snd_soc_dapm_enable_pin(dapm, "Ext Spk Bottom Neg");	snd_soc_dapm_enable_pin(dapm, "Ext Spk Top Pos");	snd_soc_dapm_enable_pin(dapm, "Ext Spk Top Neg");	snd_soc_dapm_sync(dapm);	err = snd_soc_jack_new(codec, "Headset Jack",			       (SND_JACK_HEADSET | SND_JACK_OC_HPHL |				SND_JACK_OC_HPHR | SND_JACK_UNSUPPORTED),			       &hs_jack);	if (err) {		pr_err("failed to create new jack/n");		return err;	}	err = snd_soc_jack_new(codec, "Button Jack",			       TABLA_JACK_BUTTON_MASK, &button_jack);	if (err) {		pr_err("failed to create new jack/n");		return err;	}	codec_clk = clk_get(cpu_dai->dev, "osr_clk");	if (machine_is_msm8960_cdp())		mbhc_cfg.swap_gnd_mic = msm8960_swap_gnd_mic;	if (hs_detect_use_gpio) {		mbhc_cfg.gpio = PM8921_GPIO_PM_TO_SYS(JACK_DETECT_GPIO);		mbhc_cfg.gpio_irq = JACK_DETECT_INT;	}	if (mbhc_cfg.gpio) {		err = pm8xxx_gpio_config(mbhc_cfg.gpio, &jack_gpio_cfg);		if (err) {			pr_err("%s: pm8xxx_gpio_config JACK_DETECT failed %d/n",			       __func__, err);			return err;		}	}	mbhc_cfg.read_fw_bin = hs_detect_use_firmware;	err = tabla_hs_detect(codec, &mbhc_cfg);	return err;}static int msm8960_slim_0_rx_be_hw_params_fixup(struct snd_soc_pcm_runtime *rtd,			struct snd_pcm_hw_params *params){	struct snd_interval *rate = hw_param_interval(params,	SNDRV_PCM_HW_PARAM_RATE);	struct snd_interval *channels = hw_param_interval(params,			SNDRV_PCM_HW_PARAM_CHANNELS);	pr_debug("%s()/n", __func__);	rate->min = rate->max = 48000;	channels->min = channels->max = msm8960_slim_0_rx_ch;	return 0;}static int msm8960_slim_0_tx_be_hw_params_fixup(struct snd_soc_pcm_runtime *rtd,			struct snd_pcm_hw_params *params){	struct snd_interval *rate = hw_param_interval(params,	SNDRV_PCM_HW_PARAM_RATE);	struct snd_interval *channels = hw_param_interval(params,			SNDRV_PCM_HW_PARAM_CHANNELS);//.........这里部分代码省略.........

static int tegra_wm8903_init(struct snd_soc_pcm_runtime *rtd){	struct snd_soc_codec *codec = rtd->codec;	struct snd_soc_dapm_context *dapm = &codec->dapm;	struct snd_soc_card *card = codec->card;	struct tegra_wm8903 *machine = snd_soc_card_get_drvdata(card);	struct tegra_wm8903_platform_data *pdata = machine->pdata;	int ret;	if (gpio_is_valid(pdata->gpio_spkr_en)) {		ret = gpio_request(pdata->gpio_spkr_en, "spkr_en");		if (ret) {			dev_err(card->dev, "cannot get spkr_en gpio/n");			return ret;		}		machine->gpio_requested |= GPIO_SPKR_EN;		gpio_direction_output(pdata->gpio_spkr_en, 0);	}	if (gpio_is_valid(pdata->gpio_hp_mute)) {		ret = gpio_request(pdata->gpio_hp_mute, "hp_mute");		if (ret) {			dev_err(card->dev, "cannot get hp_mute gpio/n");			return ret;		}		machine->gpio_requested |= GPIO_HP_MUTE;		gpio_direction_output(pdata->gpio_hp_mute, 1);	}	if (gpio_is_valid(pdata->gpio_int_mic_en)) {		ret = gpio_request(pdata->gpio_int_mic_en, "int_mic_en");		if (ret) {			dev_err(card->dev, "cannot get int_mic_en gpio/n");			return ret;		}		machine->gpio_requested |= GPIO_INT_MIC_EN;		/* Disable int mic; enable signal is active-high */		gpio_direction_output(pdata->gpio_int_mic_en, 0);	}	if (gpio_is_valid(pdata->gpio_ext_mic_en)) {		ret = gpio_request(pdata->gpio_ext_mic_en, "ext_mic_en");		if (ret) {			dev_err(card->dev, "cannot get ext_mic_en gpio/n");			return ret;		}		machine->gpio_requested |= GPIO_EXT_MIC_EN;		/* Enable ext mic; enable signal is active-low */		gpio_direction_output(pdata->gpio_ext_mic_en, 0);	}	if (gpio_is_valid(pdata->gpio_hp_det)) {		tegra_wm8903_hp_jack_gpio.gpio = pdata->gpio_hp_det;		snd_soc_jack_new(codec, "Headphone Jack", SND_JACK_HEADPHONE,				&tegra_wm8903_hp_jack);		snd_soc_jack_add_pins(&tegra_wm8903_hp_jack,					ARRAY_SIZE(tegra_wm8903_hp_jack_pins),					tegra_wm8903_hp_jack_pins);		snd_soc_jack_add_gpios(&tegra_wm8903_hp_jack,					1,					&tegra_wm8903_hp_jack_gpio);		machine->gpio_requested |= GPIO_HP_DET;	}	snd_soc_jack_new(codec, "Mic Jack", SND_JACK_MICROPHONE,			 &tegra_wm8903_mic_jack);	snd_soc_jack_add_pins(&tegra_wm8903_mic_jack,			      ARRAY_SIZE(tegra_wm8903_mic_jack_pins),			      tegra_wm8903_mic_jack_pins);	wm8903_mic_detect(codec, &tegra_wm8903_mic_jack, SND_JACK_MICROPHONE,				0);	snd_soc_dapm_force_enable_pin(dapm, "Mic Bias");	/* FIXME: Calculate automatically based on DAPM routes? */	if (!machine_is_harmony() && !machine_is_ventana())		snd_soc_dapm_nc_pin(dapm, "IN1L");	if (!machine_is_seaboard() && !machine_is_aebl())		snd_soc_dapm_nc_pin(dapm, "IN1R");	snd_soc_dapm_nc_pin(dapm, "IN2L");	if (!machine_is_kaen())		snd_soc_dapm_nc_pin(dapm, "IN2R");	snd_soc_dapm_nc_pin(dapm, "IN3L");	snd_soc_dapm_nc_pin(dapm, "IN3R");	if (machine_is_aebl()) {		snd_soc_dapm_nc_pin(dapm, "LON");		snd_soc_dapm_nc_pin(dapm, "RON");		snd_soc_dapm_nc_pin(dapm, "ROP");		snd_soc_dapm_nc_pin(dapm, "LOP");	} else {		snd_soc_dapm_nc_pin(dapm, "LINEOUTR");		snd_soc_dapm_nc_pin(dapm, "LINEOUTL");	}	snd_soc_dapm_sync(dapm);//.........这里部分代码省略.........

static void midas_micdet(u16 status, void *data){	struct wm1811_machine_priv *wm1811 = data;	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(wm1811->codec);	int report;	int reg;	bool present;	wake_lock_timeout(&wm1811->jackdet_wake_lock, 5 * HZ);	/* Either nothing present or just starting detection */	if (!(status & WM8958_MICD_STS)) {		if (!wm8994->jackdet) {			/* If nothing present then clear our statuses */			dev_dbg(wm1811->codec->dev, "Detected open circuit/n");			wm8994->jack_mic = false;			wm8994->mic_detecting = true;			midas_micd_set_rate(wm1811->codec);			snd_soc_jack_report(wm8994->micdet[0].jack, 0,					    wm8994->btn_mask |					     SND_JACK_HEADSET);		}		/*ToDo*/		/*return;*/	}	/* If the measurement is showing a high impedence we've got a	 * microphone.	 */	if (wm8994->mic_detecting && (status & 0x400)) {		dev_info(wm1811->codec->dev, "Detected microphone/n");		wm8994->mic_detecting = false;		wm8994->jack_mic = true;		midas_micd_set_rate(wm1811->codec);		snd_soc_jack_report(wm8994->micdet[0].jack, SND_JACK_HEADSET,				    SND_JACK_HEADSET);	}	if (wm8994->mic_detecting && status & 0x4) {		dev_info(wm1811->codec->dev, "Detected headphone/n");		wm8994->mic_detecting = false;		midas_micd_set_rate(wm1811->codec);		snd_soc_jack_report(wm8994->micdet[0].jack, SND_JACK_HEADPHONE,				    SND_JACK_HEADSET);		/* If we have jackdet that will detect removal */		if (wm8994->jackdet) {			mutex_lock(&wm8994->accdet_lock);			snd_soc_update_bits(wm1811->codec, WM8958_MIC_DETECT_1,					    WM8958_MICD_ENA, 0);			if (wm8994->active_refcount) {				snd_soc_update_bits(wm1811->codec,					WM8994_ANTIPOP_2,					WM1811_JACKDET_MODE_MASK,					WM1811_JACKDET_MODE_AUDIO);			}			mutex_unlock(&wm8994->accdet_lock);			if (wm8994->pdata->jd_ext_cap) {				mutex_lock(&wm1811->codec->mutex);				snd_soc_dapm_disable_pin(&wm1811->codec->dapm,							 "MICBIAS2");				snd_soc_dapm_sync(&wm1811->codec->dapm);				mutex_unlock(&wm1811->codec->mutex);			}		}	}	/* Report short circuit as a button */	if (wm8994->jack_mic) {		report = 0;		if (status & WM1811_JACKDET_BTN0)			report |= SND_JACK_BTN_0;		if (status & WM1811_JACKDET_BTN1)			report |= SND_JACK_BTN_1;		if (status & WM1811_JACKDET_BTN2)			report |= SND_JACK_BTN_2;		reg = snd_soc_read(wm1811->codec, WM1811_JACKDET_CTRL);		if (reg < 0) {			pr_err("%s: Failed to read jack status: %d/n",					__func__, reg);			return;		}		pr_err("%s: JACKDET %x/n", __func__, reg);		present = reg & WM1811_JACKDET_LVL;//.........这里部分代码省略.........

static int ctp_wm5102_init(struct snd_soc_pcm_runtime *runtime){	int ret;	struct snd_soc_card *card = runtime->card;	struct ctp_mc_private *ctx = snd_soc_card_get_drvdata(runtime->card);	struct snd_soc_codec *codec;	struct snd_soc_dapm_context *dapm;	codec = ctp_get_codec(card, "wm5102-codec");	if (!codec)		return -EIO;	dapm = &codec->dapm;	/* Set codec bias level */	ctp_set_bias_level(card, dapm, SND_SOC_BIAS_OFF);	card->dapm.idle_bias_off = true;	/* Disable MICBIAS3 bypass mode and set CAP mode.	* Capacitors are connected to DMIC on 1525-EV1 board */	snd_soc_update_bits(codec, ARIZONA_MIC_BIAS_CTRL_3,			ARIZONA_MICB1_BYPASS_MASK | ARIZONA_MICB1_EXT_CAP_MASK,			ARIZONA_MICB1_EXT_CAP);	/* Set codec clock */	ret = snd_soc_codec_set_sysclk(codec, ARIZONA_CLK_SYSCLK,				ARIZONA_CLK_SRC_FLL1,				SYSCLK_RATE,				SND_SOC_CLOCK_IN);	if (ret != 0) {		pr_err("failed: %d/n", ret);		return ret;	}	/* Add Jack specific widgets */	ret = snd_soc_dapm_new_controls(dapm, ctp_dapm_widgets,					ARRAY_SIZE(ctp_dapm_widgets));	if (ret)		return ret;	/* Set up Jack specific audio path audio_map */	snd_soc_dapm_add_routes(dapm, ctp_audio_map,					ARRAY_SIZE(ctp_audio_map));	/* Add Comms specefic controls */	ctx->comms_ctl.ssp_bt_sco_master_mode = false;	ctx->comms_ctl.ssp_voip_master_mode = false;	ctx->comms_ctl.ssp_modem_master_mode = false;	ret = snd_soc_add_card_controls(card, ssp_comms_controls,				ARRAY_SIZE(ssp_comms_controls));	if (ret) {		pr_err("Add Comms Controls failed %d",				ret);		return ret;	}	/* Keep the voice call paths active during	suspend. Mark the end points ignore_suspend */	snd_soc_dapm_ignore_suspend(dapm, "HPOUT1R");	snd_soc_dapm_ignore_suspend(dapm, "HPOUT1L");	snd_soc_dapm_disable_pin(dapm, "MICBIAS1");	snd_soc_dapm_disable_pin(dapm, "SPKOUTLP");	snd_soc_dapm_disable_pin(dapm, "SPKOUTLN");	snd_soc_dapm_ignore_suspend(dapm, "SPKOUTRP");	snd_soc_dapm_ignore_suspend(dapm, "SPKOUTRN");	mutex_lock(&codec->mutex);	snd_soc_dapm_sync(dapm);	mutex_unlock(&codec->mutex);	return ret;}

static int msm_audrx_init(struct snd_soc_pcm_runtime *rtd){	int err;	struct snd_soc_codec *codec = rtd->codec;	struct snd_soc_dapm_context *dapm = &codec->dapm;	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;	struct snd_soc_dai *codec_dai = rtd->codec_dai;	/* Taiko SLIMBUS configuration	 * RX1, RX2, RX3, RX4, RX5, RX6, RX7, RX8, RX9, RX10, RX11, RX12, RX13	 * TX1, TX2, TX3, TX4, TX5, TX6, TX7, TX8, TX9, TX10, TX11, TX12, TX13	 * TX14, TX15, TX16	 */	unsigned int rx_ch[TAIKO_RX_MAX] = {144, 145, 146, 147, 148, 149, 150,					    151, 152, 153, 154, 155, 156};	unsigned int tx_ch[TAIKO_TX_MAX]  = {128, 129, 130, 131, 132, 133,					     134, 135, 136, 137, 138, 139,					     140, 141, 142, 143};	pr_info("%s(), dev_name%s/n", __func__, dev_name(cpu_dai->dev));	if (machine_is_msm8960_liquid()) {		top_spk_pamp_gpio = (PM8921_GPIO_PM_TO_SYS(19));		bottom_spk_pamp_gpio = (PM8921_GPIO_PM_TO_SYS(18));	}	rtd->pmdown_time = 0;	err = snd_soc_add_codec_controls(codec, msm_snd_controls,					 ARRAY_SIZE(msm_snd_controls));	if (err < 0)		return err;	snd_soc_dapm_new_controls(dapm, msm_dapm_widgets,				ARRAY_SIZE(msm_dapm_widgets));	snd_soc_dapm_add_routes(dapm, common_audio_map,		ARRAY_SIZE(common_audio_map));	snd_soc_dapm_enable_pin(dapm, "Ext Spk Bottom Pos");	snd_soc_dapm_enable_pin(dapm, "Ext Spk Bottom Neg");	snd_soc_dapm_enable_pin(dapm, "Ext Spk Top Pos");	snd_soc_dapm_enable_pin(dapm, "Ext Spk Top Neg");	snd_soc_dapm_sync(dapm);	err = snd_soc_jack_new(codec, "Headset Jack",			       (SND_JACK_HEADSET | SND_JACK_OC_HPHL |				SND_JACK_OC_HPHR | SND_JACK_UNSUPPORTED),			       &hs_jack);	if (err) {		pr_err("failed to create new jack/n");		return err;	}	snd_soc_dai_set_channel_map(codec_dai, ARRAY_SIZE(tx_ch),				    tx_ch, ARRAY_SIZE(rx_ch), rx_ch);	err = snd_soc_jack_new(codec, "Button Jack",			       TAIKO_JACK_BUTTON_MASK, &button_jack);	if (err) {		pr_err("failed to create new jack/n");		return err;	}	return err;}

static int adav80x_set_pll(struct snd_soc_codec *codec, int pll_id,		int source, unsigned int freq_in, unsigned int freq_out){	struct adav80x *adav80x = snd_soc_codec_get_drvdata(codec);	unsigned int pll_ctrl1 = 0;	unsigned int pll_ctrl2 = 0;	unsigned int pll_src;	switch (source) {	case ADAV80X_PLL_SRC_XTAL:	case ADAV80X_PLL_SRC_XIN:	case ADAV80X_PLL_SRC_MCLKI:		break;	default:		return -EINVAL;	}	if (!freq_out)		return 0;	switch (freq_in) {	case 27000000:		break;	case 54000000:		if (source == ADAV80X_PLL_SRC_XIN) {			pll_ctrl1 |= ADAV80X_PLL_CTRL1_PLLDIV;			break;		}	default:		return -EINVAL;	}	if (freq_out > 12288000) {		pll_ctrl2 |= ADAV80X_PLL_CTRL2_DOUB(pll_id);		freq_out /= 2;	}	/* freq_out = sample_rate * 256 */	switch (freq_out) {	case 8192000:		pll_ctrl2 |= ADAV80X_PLL_CTRL2_FS_32(pll_id);		break;	case 11289600:		pll_ctrl2 |= ADAV80X_PLL_CTRL2_FS_44(pll_id);		break;	case 12288000:		pll_ctrl2 |= ADAV80X_PLL_CTRL2_FS_48(pll_id);		break;	default:		return -EINVAL;	}	regmap_update_bits(adav80x->regmap, ADAV80X_PLL_CTRL1,			ADAV80X_PLL_CTRL1_PLLDIV, pll_ctrl1);	regmap_update_bits(adav80x->regmap, ADAV80X_PLL_CTRL2,			ADAV80X_PLL_CTRL2_PLL_MASK(pll_id), pll_ctrl2);	if (source != adav80x->pll_src) {		if (source == ADAV80X_PLL_SRC_MCLKI)			pll_src = ADAV80X_PLL_CLK_SRC_PLL_MCLKI(pll_id);		else			pll_src = ADAV80X_PLL_CLK_SRC_PLL_XIN(pll_id);		regmap_update_bits(adav80x->regmap, ADAV80X_PLL_CLK_SRC,				ADAV80X_PLL_CLK_SRC_PLL_MASK(pll_id), pll_src);		adav80x->pll_src = source;		snd_soc_dapm_sync(&codec->dapm);	}	return 0;}

static int msm8960_audrx_init(struct snd_soc_pcm_runtime *rtd){	int err;	struct snd_soc_codec *codec = rtd->codec;	struct snd_soc_dapm_context *dapm = &codec->dapm;	u8 tabla_version;	pr_aud_info("%s()/n", __func__);	rtd->pmdown_time = 0;	err = snd_soc_add_controls(codec, tabla_msm8960_controls,				ARRAY_SIZE(tabla_msm8960_controls));	if (err < 0)		return err;	snd_soc_dapm_new_controls(dapm, msm8960_dapm_widgets,				ARRAY_SIZE(msm8960_dapm_widgets));	snd_soc_dapm_new_controls(dapm, fighter_dapm_widgets,				ARRAY_SIZE(fighter_dapm_widgets));	snd_soc_dapm_add_routes(dapm, common_audio_map,		ARRAY_SIZE(common_audio_map));	/* determine HW connection based on codec revision */	tabla_version = snd_soc_read(codec, TABLA_A_CHIP_VERSION);	tabla_version &=  0x1F;	pr_aud_info("%s : Tabla version %u/n", __func__, (u32)tabla_version);	if ((tabla_version == TABLA_VERSION_1_0) ||		(tabla_version == TABLA_VERSION_1_1)) {		snd_soc_dapm_add_routes(dapm, tabla_1_x_audio_map,			 ARRAY_SIZE(tabla_1_x_audio_map));	} else {		snd_soc_dapm_add_routes(dapm, tabla_2_x_audio_map,			 ARRAY_SIZE(tabla_2_x_audio_map));	}	snd_soc_dapm_enable_pin(dapm, "Ext Spk Bottom Pos");	snd_soc_dapm_enable_pin(dapm, "Ext Spk Bottom Neg");	snd_soc_dapm_enable_pin(dapm, "Ext USB AMP Pos");	snd_soc_dapm_enable_pin(dapm, "Ext USB AMP Neg");	snd_soc_dapm_sync(dapm);	err = snd_soc_jack_new(codec, "Headset Jack",		(SND_JACK_HEADSET | SND_JACK_OC_HPHL | SND_JACK_OC_HPHR),		&hs_jack);	if (err) {		pr_aud_err("failed to create new jack/n");		return err;	}	err = snd_soc_jack_new(codec, "Button Jack",				SND_JACK_BTN_0, &button_jack);	if (err) {		pr_aud_err("failed to create new jack/n");		return err;	}	/* Do not pass MBHC calibration data to disable HS detection.	 * Otherwise, sending project-based cal-data to enable	 * MBHC mechanism that tabla provides */	tabla_hs_detect(codec, &hs_jack, &button_jack, NULL,			TABLA_MICBIAS2, msm8960_enable_codec_ext_clk, 0,			TABLA_EXT_CLK_RATE);	return 0;}

static int adc3101_set_scenario_endpoints(struct tt_scenario_context *c){	struct snd_kcontrol	*kcontrol = (struct snd_kcontrol *) c->data;	struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);	/* check whether the new scenario is already active, if so,	   don't set it again as this has been seen to result in non	   wanted register changes e.g. setting scenario TT_SCENARIO_ASR	   twice result in non ASR scenario registers being set. */	if (c->tt_current_scenario == c->tt_scenario)		return 0;		/* scenario routing switching */	switch(c->tt_scenario) {	default:	case TT_SCENARIO_AUDIO_INIT:		/* enable mic bias (not if we use mic pre-amp) */		adc3101_mic_bias_enable(codec);	case TT_SCENARIO_AUDIO_OFF:		c->tt_volume = 0;		switch(c->tt_current_scenario) {		case TT_SCENARIO_VR:			adc3101_alc_disable(codec);		case TT_SCENARIO_NOISE:		case TT_SCENARIO_ASR:		case TT_SCENARIO_HF_LINEOUT:		case TT_SCENARIO_HF_FM:		case TT_SCENARIO_HF_SPEAKER:			adc3101_mic_disable(codec);			break;		case TT_SCENARIO_SPEAKER:		case TT_SCENARIO_LINEOUT:		case TT_SCENARIO_FM:			break;			adc3101_mic_disable(codec);			break;		case TT_SCENARIO_iPod:			adc3101_line_in_disable(codec);			adc3101_mic_bias_enable(codec);			break;		case TT_SCENARIO_iPod_SPEAKER:			adc3101_line_in_disable(codec);			adc3101_mic_bias_enable(codec);			break;		case TT_SCENARIO_iPod_LINEOUT:		case TT_SCENARIO_iPod_FM:			adc3101_line_in_disable(codec);			adc3101_mic_bias_enable(codec);			break;		default:			snd_soc_dapm_disable_pin(codec, "MicIn");			break;		}		break;	case TT_SCENARIO_ASR:		adc3101_mic_enable(codec, 25, 1);		break;	case TT_SCENARIO_VR:		adc3101_mic_enable(codec, 25, 1);		break;	case TT_SCENARIO_NOISE:		adc3101_mic_enable(codec, 15, 1);		break;	case TT_SCENARIO_iPod:		adc3101_line_in_enable(codec);		break;	case TT_SCENARIO_SPEAKER:		break;	case TT_SCENARIO_LINEOUT:		break;	case TT_SCENARIO_FM:		break;	case TT_SCENARIO_iPod_SPEAKER:		adc3101_line_in_enable(codec);		break;	case TT_SCENARIO_iPod_LINEOUT:	case TT_SCENARIO_iPod_FM:		adc3101_line_in_enable(codec);		break;	case TT_SCENARIO_HF_SPEAKER:		adc3101_mic_enable(codec, 13, 1);		break;	case TT_SCENARIO_HF_LINEOUT:	case TT_SCENARIO_HF_FM:		adc3101_mic_enable(codec, 13, 1);		break;	}	c->tt_current_scenario = c->tt_scenario;	snd_soc_dapm_sync(codec);	switch(c->tt_scenario) {	case TT_SCENARIO_LINEOUT:	case TT_SCENARIO_iPod_LINEOUT:	case TT_SCENARIO_FM:	case TT_SCENARIO_iPod_FM:		break;	default:	case TT_SCENARIO_AUDIO_INIT:	case TT_SCENARIO_AUDIO_OFF://.........这里部分代码省略.........

static int msm_audrx_init(struct snd_soc_pcm_runtime *rtd){	int err;	struct snd_soc_codec *codec = rtd->codec;	struct snd_soc_dapm_context *dapm = &codec->dapm;	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;	pr_debug("%s(), dev_name%s/n", __func__, dev_name(cpu_dai->dev));	/*if (machine_is_msm_liquid()) {		top_spk_pamp_gpio = (PM8921_GPIO_PM_TO_SYS(19));		bottom_spk_pamp_gpio = (PM8921_GPIO_PM_TO_SYS(18));	}*/	rtd->pmdown_time = 0;	err = snd_soc_add_controls(codec, tabla_msm_controls,				ARRAY_SIZE(tabla_msm_controls));	if (err < 0)		return err;	snd_soc_dapm_new_controls(dapm, apq8064_dapm_widgets,				ARRAY_SIZE(apq8064_dapm_widgets));	snd_soc_dapm_add_routes(dapm, apq8064_common_audio_map,		ARRAY_SIZE(apq8064_common_audio_map));	if (machine_is_apq8064_mtp()) {		snd_soc_dapm_add_routes(dapm, apq8064_mtp_audio_map,			ARRAY_SIZE(apq8064_mtp_audio_map));	} else  {		snd_soc_dapm_add_routes(dapm, apq8064_liquid_cdp_audio_map,			ARRAY_SIZE(apq8064_liquid_cdp_audio_map));	}	snd_soc_dapm_enable_pin(dapm, "Ext Spk Bottom Pos");	snd_soc_dapm_enable_pin(dapm, "Ext Spk Bottom Neg");	snd_soc_dapm_enable_pin(dapm, "Ext Spk Top Pos");	snd_soc_dapm_enable_pin(dapm, "Ext Spk Top Neg");	snd_soc_dapm_sync(dapm);	err = snd_soc_jack_new(codec, "Headset Jack",		(SND_JACK_HEADSET | SND_JACK_OC_HPHL | SND_JACK_OC_HPHR),		&hs_jack);	if (err) {		pr_err("failed to create new jack/n");		return err;	}	err = snd_soc_jack_new(codec, "Button Jack",			       TABLA_JACK_BUTTON_MASK, &button_jack);	if (err) {		pr_err("failed to create new jack/n");		return err;	}	codec_clk = clk_get(cpu_dai->dev, "osr_clk");	err = tabla_hs_detect(codec, &mbhc_cfg);	return err;}

static int aml_asoc_init(struct snd_soc_pcm_runtime *rtd){    struct snd_soc_card *card = rtd->card;    struct snd_soc_codec *codec = rtd->codec;    //struct snd_soc_dai *codec_dai = rtd->codec_dai;    struct snd_soc_dapm_context *dapm = &codec->dapm;    struct aml_audio_private_data * p_aml_audio;    int ret = 0;        printk(KERN_DEBUG "enter %s /n", __func__);    p_aml_audio = snd_soc_card_get_drvdata(card);    /* Add specific widgets */  //  snd_soc_dapm_new_controls(dapm, aml_asoc_dapm_widgets, //                ARRAY_SIZE(aml_asoc_dapm_widgets));    /* set ADCLRC/GPIO1 Pin Function Select */    snd_soc_update_bits(codec, WM8960_IFACE2, (1 << 6), (1 << 6));    /* not connected */    snd_soc_dapm_nc_pin(dapm, "LINPUT3");    snd_soc_dapm_nc_pin(dapm, "RINPUT3");        snd_soc_dapm_nc_pin(dapm, "OUT3");    /* always connected */    snd_soc_dapm_enable_pin(dapm, "Ext Spk");    snd_soc_dapm_enable_pin(dapm, "Mic");    /* disable connected */    snd_soc_dapm_disable_pin(dapm, "HP");    snd_soc_dapm_sync(dapm);    ret = snd_soc_jack_new(codec, "hp switch", SND_JACK_HEADPHONE, &p_aml_audio->jack);    if (ret) {        printk(KERN_WARNING "Failed to alloc resource for hp switch/n");    } else {        ret = snd_soc_jack_add_pins(&p_aml_audio->jack, ARRAY_SIZE(jack_pins), jack_pins);        if (ret) {            printk(KERN_WARNING "Failed to setup hp pins/n");        }    }#if HP_IRQ      p_aml_audio->gpio_hp_det = of_get_named_gpio(card->dev->of_node,"wm8960_gpio",0);    if (gpio_is_valid(p_aml_audio->gpio_hp_det)) {        aml_audio_hp_jack_gpio.gpio = p_aml_audio->gpio_hp_det;        snd_soc_jack_add_gpios(&p_aml_audio->jack,                        1, &aml_audio_hp_jack_gpio);    }#endif#if HP_DET    init_timer(&p_aml_audio->timer);    p_aml_audio->timer.function = aml_asoc_timer_func;    p_aml_audio->timer.data = (unsigned long)p_aml_audio;    p_aml_audio->data= (void*)card;    INIT_WORK(&p_aml_audio->work, aml_asoc_work_func);    mutex_init(&p_aml_audio->lock);    mutex_lock(&p_aml_audio->lock);    if (!p_aml_audio->timer_en) {        aml_audio_start_timer(p_aml_audio, msecs_to_jiffies(100));    }    mutex_unlock(&p_aml_audio->lock);#endif//p_aml_audio->dis_hp_det = of_property_read_bool(card->dev->of_node,"dis_hp_det");     ret = of_property_read_u32(card->dev->of_node,"dis_hp_det",(u32 *)&p_aml_audio->dis_hp_det);     printk("******p_aml_audio->dis_hp_det=%d***/n",p_aml_audio->dis_hp_det);    if(ret){        printk("don't find match dis_hp_det/n");        goto out1;    }      if(!p_aml_audio->dis_hp_det){        printk("****mm**p_aml_audio->dis_hp_det/n");        //JD2 as headphone detect        snd_soc_update_bits(codec,27, 0x008, 0x008);// OUT3 buffer Enabled and disabled with HPL and HPR jack detect                      //INSERT_DELAY    [1]         mdelay(1);              ///GPIO1 output the "jack detect output"        snd_soc_update_bits(codec,48, 0x03A, 0x03A);// JD2 used for Jack Detect Input, GPIO function = jack detect output         snd_soc_update_bits(codec,24, 0x040, 0x040);// HPDETECT LOW = Speaker             snd_soc_update_bits(codec, 23, 0x1D1, 0x1D1);        mdelay(500);    }out1:           return 0;}

static int machine_init(struct snd_soc_codec *codec){	snd_soc_dapm_sync(codec);	return 0;}

//.........这里部分代码省略.........	struct tegra30_i2s *i2s = snd_soc_dai_get_drvdata(rtd->cpu_dai);#endif	int ret;#ifndef CONFIG_ARCH_TEGRA_2x_SOC	if (machine->codec_info[BASEBAND].i2s_id != -1)		i2s->is_dam_used = true;#endif	if (machine->init_done)		return 0;	machine->init_done = true;	if (gpio_is_valid(pdata->gpio_spkr_en)) {		ret = gpio_request(pdata->gpio_spkr_en, "spkr_en");		if (ret) {			dev_err(card->dev, "cannot get spkr_en gpio/n");			return ret;		}		machine->gpio_requested |= GPIO_SPKR_EN;		gpio_direction_output(pdata->gpio_spkr_en, 0);	}	if (gpio_is_valid(pdata->gpio_hp_mute)) {		ret = gpio_request(pdata->gpio_hp_mute, "hp_mute");		if (ret) {			dev_err(card->dev, "cannot get hp_mute gpio/n");			return ret;		}		machine->gpio_requested |= GPIO_HP_MUTE;		gpio_direction_output(pdata->gpio_hp_mute, 0);	}	if (gpio_is_valid(pdata->gpio_int_mic_en)) {		ret = gpio_request(pdata->gpio_int_mic_en, "int_mic_en");		if (ret) {			dev_err(card->dev, "cannot get int_mic_en gpio/n");			return ret;		}		machine->gpio_requested |= GPIO_INT_MIC_EN;		/* Disable int mic; enable signal is active-high */		gpio_direction_output(pdata->gpio_int_mic_en, 0);	}	if (gpio_is_valid(pdata->gpio_ext_mic_en)) {		ret = gpio_request(pdata->gpio_ext_mic_en, "ext_mic_en");		if (ret) {			dev_err(card->dev, "cannot get ext_mic_en gpio/n");			return ret;		}		machine->gpio_requested |= GPIO_EXT_MIC_EN;		/* Enable ext mic; enable signal is active-low */		gpio_direction_output(pdata->gpio_ext_mic_en, 0);	}	ret = snd_soc_add_card_controls(card, tegra_max98095_controls,				   ARRAY_SIZE(tegra_max98095_controls));	if (ret < 0)		return ret;	snd_soc_dapm_new_controls(dapm, tegra_max98095_dapm_widgets,			ARRAY_SIZE(tegra_max98095_dapm_widgets));	snd_soc_dapm_add_routes(dapm, enterprise_audio_map,			ARRAY_SIZE(enterprise_audio_map));	ret = snd_soc_jack_new(codec, "Headset Jack", SND_JACK_HEADSET,			&tegra_max98095_hp_jack);	if (ret < 0)		return ret;#ifdef CONFIG_SWITCH	snd_soc_jack_notifier_register(&tegra_max98095_hp_jack,		&headset_switch_nb);#else /*gpio based headset detection*/	snd_soc_jack_add_pins(&tegra_max98095_hp_jack,		ARRAY_SIZE(tegra_max98095_hp_jack_pins),		tegra_max98095_hp_jack_pins);#endif	ret = tegra_asoc_utils_register_ctls(&machine->util_data);	if (ret < 0)		return ret;	/* max98095_headset_detect(codec, &tegra_max98095_hp_jack,		SND_JACK_HEADSET); */	snd_soc_dapm_nc_pin(dapm, "INA1");	snd_soc_dapm_nc_pin(dapm, "INA2");	snd_soc_dapm_nc_pin(dapm, "INB1");	snd_soc_dapm_nc_pin(dapm, "INB2");	snd_soc_dapm_sync(dapm);	return 0;}

static void tab3_mic_id(void *data, u16 status){	struct wm1811_machine_priv *wm1811 = data;	struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(wm1811->codec);	int report;	int reg;	bool present;	wake_lock_timeout(&wm1811->jackdet_wake_lock, 5 * HZ);	/* Either nothing present or just starting detection */	if (!(status & WM8958_MICD_STS)) {		if (!wm8994->jackdet) {			/* If nothing present then clear our statuses */			dev_dbg(wm1811->codec->dev, "Detected open circuit/n");			wm8994->jack_mic = false;			wm8994->mic_detecting = true;			tab3_micd_set_rate(wm1811->codec);			snd_soc_jack_report(wm8994->micdet[0].jack, 0,					    wm8994->btn_mask |					     SND_JACK_HEADSET);		}		/*ToDo*/		/*return;*/	}	/* If the measurement is showing a high impedence we've got a	 * microphone.	 */	if (wm8994->mic_detecting && (status & 0x400)) {		dev_info(wm1811->codec->dev, "Detected microphone/n");		wm8994->mic_detecting = false;		wm8994->jack_mic = true;		tab3_micd_set_rate(wm1811->codec);		snd_soc_jack_report(wm8994->micdet[0].jack, SND_JACK_HEADSET,				    SND_JACK_HEADSET);	}	if (wm8994->mic_detecting && status & 0x4) {		dev_info(wm1811->codec->dev, "Detected headphone/n");		wm8994->mic_detecting = false;		tab3_micd_set_rate(wm1811->codec);		snd_soc_jack_report(wm8994->micdet[0].jack, SND_JACK_HEADPHONE,				    SND_JACK_HEADSET);		/* If we have jackdet that will detect removal */		if (wm8994->jackdet) {			mutex_lock(&wm8994->accdet_lock);			snd_soc_update_bits(wm1811->codec, WM8958_MIC_DETECT_1,					    WM8958_MICD_ENA, 0);			if (wm8994->active_refcount) {				snd_soc_update_bits(wm1811->codec,					WM8994_ANTIPOP_2,					WM1811_JACKDET_MODE_MASK,					WM1811_JACKDET_MODE_AUDIO);			}			mutex_unlock(&wm8994->accdet_lock);			if (wm8994->pdata->jd_ext_cap) {				mutex_lock(&wm1811->codec->mutex);				snd_soc_dapm_disable_pin(&wm1811->codec->dapm,							 "MICBIAS2");				snd_soc_dapm_sync(&wm1811->codec->dapm);				mutex_unlock(&wm1811->codec->mutex);			}		}	}}

static int adav80x_set_sysclk(struct snd_soc_codec *codec,		int clk_id, unsigned int freq, int dir){	struct adav80x *adav80x = snd_soc_codec_get_drvdata(codec);	if (dir == SND_SOC_CLOCK_IN) {		switch (clk_id) {		case ADAV80X_CLK_XIN:		case ADAV80X_CLK_XTAL:		case ADAV80X_CLK_MCLKI:		case ADAV80X_CLK_PLL1:		case ADAV80X_CLK_PLL2:			break;		default:			return -EINVAL;		}		adav80x->sysclk = freq;		if (adav80x->clk_src != clk_id) {			unsigned int iclk_ctrl1, iclk_ctrl2;			adav80x->clk_src = clk_id;			if (clk_id == ADAV80X_CLK_XTAL)				clk_id = ADAV80X_CLK_XIN;			iclk_ctrl1 = ADAV80X_ICLK_CTRL1_DAC_SRC(clk_id) |					ADAV80X_ICLK_CTRL1_ADC_SRC(clk_id) |					ADAV80X_ICLK_CTRL1_ICLK2_SRC(clk_id);			iclk_ctrl2 = ADAV80X_ICLK_CTRL2_ICLK1_SRC(clk_id);			snd_soc_write(codec, ADAV80X_ICLK_CTRL1, iclk_ctrl1);			snd_soc_write(codec, ADAV80X_ICLK_CTRL2, iclk_ctrl2);			snd_soc_dapm_sync(&codec->dapm);		}	} else {		unsigned int mask;		switch (clk_id) {		case ADAV80X_CLK_SYSCLK1:		case ADAV80X_CLK_SYSCLK2:		case ADAV80X_CLK_SYSCLK3:			break;		default:			return -EINVAL;		}		clk_id -= ADAV80X_CLK_SYSCLK1;		mask = ADAV80X_PLL_OUTE_SYSCLKPD(clk_id);		if (freq == 0) {			snd_soc_update_bits(codec, ADAV80X_PLL_OUTE, mask, mask);			adav80x->sysclk_pd[clk_id] = true;		} else {			snd_soc_update_bits(codec, ADAV80X_PLL_OUTE, mask, 0);			adav80x->sysclk_pd[clk_id] = false;		}		if (adav80x->sysclk_pd[0])			snd_soc_dapm_disable_pin(&codec->dapm, "PLL1");		else			snd_soc_dapm_force_enable_pin(&codec->dapm, "PLL1");		if (adav80x->sysclk_pd[1] || adav80x->sysclk_pd[2])			snd_soc_dapm_disable_pin(&codec->dapm, "PLL2");		else			snd_soc_dapm_force_enable_pin(&codec->dapm, "PLL2");		snd_soc_dapm_sync(&codec->dapm);	}	return 0;}

/* * omap4_aic31xx_init * This function is to initialize the machine Driver. */static int omap4_aic31xx_init(struct snd_soc_pcm_runtime *rtd){	struct snd_soc_codec *codec = rtd->codec;	int ret = 0;	int gpiostatus;	printk(KERN_INFO "entered the omap4_aic31xx_init function..../n");#ifdef DRIVER_DAPM_SUPPORT	/* Add OMAP4 specific widgets */	ret = snd_soc_dapm_new_controls(codec->dapm, omap4_aic31xx_dapm_widgets,					ARRAY_SIZE(omap4_aic31xx_dapm_widgets));	if (ret) {		printk (KERN_INFO "snd_soc_dapm_new_controls call failed. returning.../n");		return ret;	}	DBG ("snd_soc_dapm_new_controls passed../n");	DBG ("Disabling the DAPM Routes for now.../n");	/* Set up OMAP4 specific audio path audio_map */	ret = snd_soc_dapm_add_routes(codec->dapm, audio_map, ARRAY_SIZE(audio_map));	if (ret != 0) {		printk (KERN_INFO "snd_soc_dapm_add_routes failed... %d/n", ret);	}	/* OMAP4 connected pins */	snd_soc_dapm_enable_pin(codec->dapm, "Ext Mic");	snd_soc_dapm_enable_pin(codec->dapm, "Ext Spk");	snd_soc_dapm_disable_pin(codec->dapm, "Headset Mic");	snd_soc_dapm_disable_pin(codec->dapm, "Headset Stereophone");	/* AIC31XX not connected pins */	snd_soc_dapm_nc_pin(codec->dapm, "AUXL");	snd_soc_dapm_nc_pin(codec->dapm, "AUXR");	snd_soc_dapm_nc_pin(codec->dapm, "CARKITMIC");	snd_soc_dapm_nc_pin(codec->dapm, "DIGIMIC0");	snd_soc_dapm_nc_pin(codec->dapm, "DIGIMIC1");mcbsp_be_hw_params_fixup	snd_soc_dapm_nc_pin(codec->dapm, "OUTL");	snd_soc_dapm_nc_pin(codec->dapm, "OUTR");	snd_soc_dapm_nc_pin(codec->dapm, "EARPIECE");	snd_soc_dapm_nc_pin(codec->dapm, "PREDRIVEL");	snd_soc_dapm_nc_pin(codec->dapm, "PREDRIVER");	snd_soc_dapm_nc_pin(codec->dapm, "CARKITL");	snd_soc_dapm_nc_pin(codec->dapm, "CARKITR");	ret = snd_soc_dapm_sync(codec->dapm);	if (ret != 0) {		printk (KERN_INFO "snd_soc_dapm_sync failed... %d/n", ret);		return ret;	}	printk (KERN_INFO "snd_soc_dapm_sync passed../n");mcbsp_be_hw_params_fixup	/* Headset jack detection */	ret = snd_soc_jack_new(codec, "Headset Jack",			       SND_JACK_HEADSET, &hs_jack);	if (ret != 0) {		printk (KERN_INFO "snd_soc_jack_new failed.../n");		return ret;	}	ret = snd_soc_jack_add_pins(&hs_jack, ARRAY_SIZE(hs_jack_pins),				    hs_jack_pins);	if (ret != 0) {		printk (KERN_INFO "snd_soc_jack_add_pins failed... %d/n", ret);		return ret;	}	ret = snd_soc_jack_add_gpios(&hs_jack, ARRAY_SIZE(hs_jack_gpios),				     hs_jack_gpios);#endif	/* Headset jack detection */	gpiostatus = snd_soc_jack_new(codec, "Headset Jack",			       SND_JACK_HEADSET, &hs_jack);	if (gpiostatus != 0) {		printk (KERN_INFO "snd_soc_jack_new failed. %d../n", gpiostatus);	}	gpiostatus = snd_soc_jack_add_pins(&hs_jack, ARRAY_SIZE(hs_jack_pins),				    hs_jack_pins);	if (gpiostatus != 0) {		printk (KERN_INFO "snd_soc_jack_add_pins failed... %d/n", gpiostatus);        }	gpiostatus = snd_soc_jack_add_gpios(&hs_jack, ARRAY_SIZE(hs_jack_gpios),				     hs_jack_gpios);	if (gpiostatus != 0)		printk (KERN_INFO "snd_soc_jack_add_gpios failed..%d/n", gpiostatus);	DBG ("%s: Exiting /n", __func__);//.........这里部分代码省略.........