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

static int broadwell_rt286_codec_init(struct snd_soc_pcm_runtime *rtd){	struct snd_soc_codec *codec = rtd->codec;	int ret = 0;	ret = snd_soc_jack_new(codec, "Headphone Jack", SND_JACK_HEADPHONE,				&broadwell_hp);	if (ret)		return ret;	ret = snd_soc_jack_add_pins(&broadwell_hp, 1, broadwell_hp_pins);	if (ret)		return ret;	ret = snd_soc_jack_new(codec, "Mic Jack", SND_JACK_MICROPHONE,				&broadwell_mic);	if (ret)		return ret;	ret = snd_soc_jack_add_pins(&broadwell_mic, 1, broadwell_mic_pins);	if (ret)		return ret;	rt286_mic_detect(codec, &broadwell_hp, &broadwell_mic);	return 0;}

static int bdw_rt5677_init(struct snd_soc_pcm_runtime *rtd){	struct bdw_rt5677_priv *bdw_rt5677 =			snd_soc_card_get_drvdata(rtd->card);	struct snd_soc_codec *codec = rtd->codec;	struct snd_soc_dapm_context *dapm = &codec->dapm;	/* Enable codec ASRC function for Stereo DAC/Stereo1 ADC/DMIC/I2S1.	 * The ASRC clock source is clk_i2s1_asrc.	 */	rt5677_sel_asrc_clk_src(codec, RT5677_DA_STEREO_FILTER |			RT5677_AD_STEREO1_FILTER | RT5677_I2S1_SOURCE,			RT5677_CLK_SEL_I2S1_ASRC);	/* Request rt5677 GPIO for headphone amp control */	bdw_rt5677->gpio_hp_en = devm_gpiod_get_index(codec->dev,		"RT5677_GPIO_HP_AMP_SHDN_L", RT5677_GPIO_HP_AMP_SHDN_L, GPIOD_ASIS);	if (IS_ERR(bdw_rt5677->gpio_hp_en)) {		dev_err(codec->dev, "Can't find HP_AMP_SHDN_L gpio/n");		return PTR_ERR(bdw_rt5677->gpio_hp_en);	}	gpiod_direction_output(bdw_rt5677->gpio_hp_en, 0);	/* Create and initialize headphone jack */	if (!snd_soc_jack_new(codec, "Headphone Jack", SND_JACK_HEADPHONE,			&headphone_jack)) {		if (snd_soc_jack_add_pins(&headphone_jack, 1,				&headphone_jack_pin))			dev_err(codec->dev, "Can't add headphone jack pin/n");		headphone_jack_gpio.gpiod_dev = codec->dev;		if (snd_soc_jack_add_gpios(&headphone_jack, 1,				&headphone_jack_gpio))			dev_err(codec->dev, "Can't add headphone jack gpio/n");	} else {		dev_err(codec->dev, "Can't create headphone jack/n");	}	/* Create and initialize mic jack */	if (!snd_soc_jack_new(codec, "Mic Jack", SND_JACK_MICROPHONE,			&mic_jack)) {		if (snd_soc_jack_add_pins(&mic_jack, 1, &mic_jack_pin))			dev_err(codec->dev, "Can't add mic jack pin/n");		mic_jack_gpio.gpiod_dev = codec->dev;		if (snd_soc_jack_add_gpios(&mic_jack, 1, &mic_jack_gpio))			dev_err(codec->dev, "Can't add mic jack gpio/n");	} else {		dev_err(codec->dev, "Can't create mic jack/n");	}	bdw_rt5677->codec = codec;	snd_soc_dapm_force_enable_pin(dapm, "MICBIAS1");	return 0;}

static int tegra_wm8903_init(struct snd_soc_pcm_runtime *rtd){	struct snd_soc_dai *codec_dai = rtd->codec_dai;	struct snd_soc_codec *codec = codec_dai->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_asoc_platform_data *pdata = machine->pdata;	machine->bias_level = SND_SOC_BIAS_STANDBY;	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);#ifndef CONFIG_SWITCH		snd_soc_jack_add_pins(&tegra_wm8903_hp_jack,					ARRAY_SIZE(tegra_wm8903_hp_jack_pins),					tegra_wm8903_hp_jack_pins);#else		snd_soc_jack_notifier_register(&tegra_wm8903_hp_jack,					&tegra_wm8903_jack_detect_nb);#endif		snd_soc_jack_add_gpios(&tegra_wm8903_hp_jack,					1,					&tegra_wm8903_hp_jack_gpio);	}	snd_soc_jack_new(codec, "Mic Jack", SND_JACK_MICROPHONE,			 &tegra_wm8903_mic_jack);#ifndef CONFIG_SWITCH	snd_soc_jack_add_pins(&tegra_wm8903_mic_jack,			      ARRAY_SIZE(tegra_wm8903_mic_jack_pins),			      tegra_wm8903_mic_jack_pins);#else	snd_soc_jack_notifier_register(&tegra_wm8903_mic_jack,				&tegra_wm8903_jack_detect_nb);#endif	wm8903_mic_detect(codec, &tegra_wm8903_mic_jack, SND_JACK_MICROPHONE,			  machine_is_cardhu() ? SND_JACK_MICROPHONE : 0);	ret = tegra_asoc_utils_register_ctls(&machine->util_data);	if (ret < 0)		return ret;	snd_soc_dapm_force_enable_pin(dapm, "MICBIAS");	return 0;}

static int hx4700_ak4641_init(struct snd_soc_pcm_runtime *rtd){	struct snd_soc_codec *codec = rtd->codec;	struct snd_soc_dapm_context *dapm = &codec->dapm;	int err;			snd_soc_dapm_nc_pin(dapm, "MOUT1");	snd_soc_dapm_nc_pin(dapm, "MICEXT");	snd_soc_dapm_nc_pin(dapm, "AUX");		err = snd_soc_jack_new(codec, "Headphone Jack",				SND_JACK_HEADPHONE, &hs_jack);	if (err)		return err;	err = snd_soc_jack_add_pins(&hs_jack, ARRAY_SIZE(hs_jack_pin),					hs_jack_pin);	if (err)		return err;	err = snd_soc_jack_add_gpios(&hs_jack, 1, &hs_jack_gpio);	return err;}

/* * Initialization routine. */static int acclaim_aic3100_init (struct snd_soc_pcm_runtime *pcm){	struct snd_soc_codec *codec = pcm->codec;	int gpiostatus;        DBG(KERN_INFO  "acclaim_aic3100_init../n");	gpiostatus = snd_soc_jack_new(codec, "Headset Jack",				      SND_JACK_HEADSET, &hs_jack);	if (gpiostatus != 0) {		printk (KERN_ERR "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_ERR"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_ERR "snd_soc_jack_add_gpios failed..%d/n",			gpiostatus);	/* For our Driver, the Codec Driver itself manages the POP	*  polling and hence	* we will reset the ALSA pmdown_time to zero.	*/	pcm->pmdown_time = 0;	return 0;}

static int tegra_alc5632_asoc_init(struct snd_soc_pcm_runtime *rtd){	struct snd_soc_codec *codec = rtd->codec;	struct snd_soc_dapm_context *dapm = &codec->dapm;	struct device_node *np = codec->card->dev->of_node;	struct tegra_alc5632 *machine = snd_soc_card_get_drvdata(codec->card);	snd_soc_jack_new(codec, "Headset Jack", SND_JACK_HEADSET,			 &tegra_alc5632_hs_jack);	snd_soc_jack_add_pins(&tegra_alc5632_hs_jack,			ARRAY_SIZE(tegra_alc5632_hs_jack_pins),			tegra_alc5632_hs_jack_pins);	machine->gpio_hp_det = of_get_named_gpio(np, "nvidia,hp-det-gpios", 0);	if (gpio_is_valid(machine->gpio_hp_det)) {		tegra_alc5632_hp_jack_gpio.gpio = machine->gpio_hp_det;		snd_soc_jack_add_gpios(&tegra_alc5632_hs_jack,						1,						&tegra_alc5632_hp_jack_gpio);		machine->gpio_requested |= GPIO_HP_DET;	}	snd_soc_dapm_force_enable_pin(dapm, "MICBIAS1");	return 0;}

static int tobermory_late_probe(struct snd_soc_card *card){	struct snd_soc_codec *codec = card->rtd[0].codec;	struct snd_soc_dai *codec_dai = card->rtd[0].codec_dai;	int ret;	ret = snd_soc_dai_set_sysclk(codec_dai, WM8962_SYSCLK_MCLK,				     32768, SND_SOC_CLOCK_IN);	if (ret < 0)		return ret;	ret = snd_soc_jack_new(codec, "Headset",			       SND_JACK_HEADSET | SND_JACK_BTN_0,			       &tobermory_headset);	if (ret)		return ret;	ret = snd_soc_jack_add_pins(&tobermory_headset,				    ARRAY_SIZE(tobermory_headset_pins),				    tobermory_headset_pins);	if (ret)		return ret;	wm8962_mic_detect(codec, &tobermory_headset);	return 0;}

static int speyside_wm8996_init(struct snd_soc_pcm_runtime *rtd){	struct snd_soc_dai *dai = rtd->codec_dai;	struct snd_soc_codec *codec = rtd->codec;	int ret;	ret = snd_soc_dai_set_sysclk(dai, WM8996_SYSCLK_MCLK2, 32768, 0);	if (ret < 0)		return ret;	ret = gpio_request(WM8996_HPSEL_GPIO, "HP_SEL");	if (ret != 0)		pr_err("Failed to request HP_SEL GPIO: %d/n", ret);	gpio_direction_output(WM8996_HPSEL_GPIO, speyside_jack_polarity);	ret = snd_soc_jack_new(codec, "Headset",			       SND_JACK_HEADSET | SND_JACK_BTN_0,			       &speyside_headset);	if (ret)		return ret;	ret = snd_soc_jack_add_pins(&speyside_headset,				    ARRAY_SIZE(speyside_headset_pins),				    speyside_headset_pins);	if (ret)		return ret;	wm8996_detect(codec, &speyside_headset, speyside_set_polarity);	return 0;}

static int rt5631_codec_init(struct snd_soc_pcm_runtime *rtd){    struct snd_soc_codec *codec = rtd->codec;    //struct snd_soc_dai *codec_dai = rtd->codec_dai;    struct snd_soc_dapm_context *dapm = &codec->dapm;    int ret = 0;    printk(KERN_DEBUG "enter %s rt5631_snd_pdata: %p/n", __func__, rt5631_snd_pdata);    /* Add specific widgets */    snd_soc_dapm_new_controls(dapm, rt5631_dapm_widgets,                  ARRAY_SIZE(rt5631_dapm_widgets));    /* Set up specific audio path interconnects */    snd_soc_dapm_add_routes(dapm, rt5631_dapm_intercon, ARRAY_SIZE(rt5631_dapm_intercon));    /* Setup spk/hp/mono output */  //  rt5631_set_output(codec);    /* Setuo mic input */  //  rt5631_set_input(codec);    /* not connected */    snd_soc_dapm_nc_pin(dapm, "MONO");    snd_soc_dapm_nc_pin(dapm, "AUXO2");    snd_soc_dapm_nc_pin(dapm, "DMIC");    snd_soc_dapm_nc_pin(dapm, "AXIL");    snd_soc_dapm_nc_pin(dapm, "AXIR");    /* always connected */    snd_soc_dapm_enable_pin(dapm, "Ext Spk");	snd_soc_dapm_enable_pin(dapm, "MAIN MIC");    /* disable connected */    snd_soc_dapm_disable_pin(dapm, "HP");    snd_soc_dapm_sync(dapm);#if HP_DET    ret = snd_soc_jack_new(codec, "hp switch", SND_JACK_HEADPHONE, &rt5631_snd_priv->jack);    if (ret) {        printk(KERN_WARNING "Failed to alloc resource for hp switch/n");    } else {        ret = snd_soc_jack_add_pins(&rt5631_snd_priv->jack, ARRAY_SIZE(jack_pins), jack_pins);        if (ret) {            printk(KERN_WARNING "Failed to setup hp pins/n");        }    }    rt5631_snd_priv->data= (void*)codec;    init_timer(&rt5631_snd_priv->timer);    rt5631_snd_priv->timer.function = rt5631_timer_func;    rt5631_snd_priv->timer.data = (unsigned long)rt5631_snd_priv;    INIT_WORK(&rt5631_snd_priv->work, rt5631_work_func);    mutex_init(&rt5631_snd_priv->lock);#endif    return 0;}

/* * Logic for a ak4641 as connected on a HP iPAQ hx4700 */static int hx4700_ak4641_init(struct snd_soc_pcm_runtime *rtd){	struct snd_soc_codec *codec = rtd->codec;	struct snd_soc_dapm_context *dapm = &codec->dapm;	int err;	/* NC codec pins */	/* FIXME: is anything connected here? */	snd_soc_dapm_nc_pin(dapm, "MOUT1");	snd_soc_dapm_nc_pin(dapm, "MICEXT");	snd_soc_dapm_nc_pin(dapm, "AUX");	/* Jack detection API stuff */	err = snd_soc_jack_new(codec, "Headphone Jack",				SND_JACK_HEADPHONE, &hs_jack);	if (err)		return err;	err = snd_soc_jack_add_pins(&hs_jack, ARRAY_SIZE(hs_jack_pin),					hs_jack_pin);	if (err)		return err;	err = snd_soc_jack_add_gpios(&hs_jack, 1, &hs_jack_gpio);	return err;}

static int palm27x_ac97_init(struct snd_soc_pcm_runtime *rtd){	struct snd_soc_codec *codec = rtd->codec;	struct snd_soc_dapm_context *dapm = &codec->dapm;	int err;	/* not connected pins */	snd_soc_dapm_nc_pin(dapm, "OUT3");	snd_soc_dapm_nc_pin(dapm, "MONOOUT");	snd_soc_dapm_nc_pin(dapm, "LINEINL");	snd_soc_dapm_nc_pin(dapm, "LINEINR");	snd_soc_dapm_nc_pin(dapm, "PCBEEP");	snd_soc_dapm_nc_pin(dapm, "PHONE");	snd_soc_dapm_nc_pin(dapm, "MIC2");	/* Jack detection API stuff */	err = snd_soc_jack_new(codec, "Headphone Jack",				SND_JACK_HEADPHONE, &hs_jack);	if (err)		return err;	err = snd_soc_jack_add_pins(&hs_jack, ARRAY_SIZE(hs_jack_pins),				hs_jack_pins);	if (err)		return err;	err = snd_soc_jack_add_gpios(&hs_jack, ARRAY_SIZE(hs_jack_gpios),				hs_jack_gpios);	return err;}

static int sdp4430_twl6040_init(struct snd_soc_pcm_runtime *rtd){	struct snd_soc_codec *codec = rtd->codec;	int ret;	/* Add SDP4430 specific controls */	ret = snd_soc_add_controls(codec, sdp4430_controls,				ARRAY_SIZE(sdp4430_controls));	if (ret)		return ret;	/* Add SDP4430 specific widgets */	ret = snd_soc_dapm_new_controls(codec->dapm, sdp4430_twl6040_dapm_widgets,				ARRAY_SIZE(sdp4430_twl6040_dapm_widgets));	if (ret)		return ret;	/* Set up SDP4430 specific audio path audio_map */	snd_soc_dapm_add_routes(codec->dapm, audio_map, ARRAY_SIZE(audio_map));	/* SDP4430 connected pins */	snd_soc_dapm_enable_pin(codec->dapm, "Ext Mic");	snd_soc_dapm_enable_pin(codec->dapm, "Ext Spk");	snd_soc_dapm_enable_pin(codec->dapm, "AFML");	snd_soc_dapm_enable_pin(codec->dapm, "AFMR");	snd_soc_dapm_disable_pin(codec->dapm, "Headset Mic");	snd_soc_dapm_disable_pin(codec->dapm, "Headset Stereophone");	/* allow audio paths from the audio modem to run during suspend */	snd_soc_dapm_ignore_suspend(codec, "Ext Mic");	snd_soc_dapm_ignore_suspend(codec, "Ext Spk");	snd_soc_dapm_ignore_suspend(codec, "AFML");	snd_soc_dapm_ignore_suspend(codec, "AFMR");	snd_soc_dapm_ignore_suspend(codec, "Headset Mic");	snd_soc_dapm_ignore_suspend(codec, "Headset Stereophone");	ret = snd_soc_dapm_sync(codec->dapm);	if (ret)		return ret;	/*Headset jack detection */	ret = snd_soc_jack_new(codec, "Headset Jack",				SND_JACK_HEADSET, &hs_jack);	if (ret)		return ret;	ret = snd_soc_jack_add_pins(&hs_jack, ARRAY_SIZE(hs_jack_pins),				hs_jack_pins);	if (machine_is_omap_4430sdp())		twl6040_hs_jack_detect(codec, &hs_jack, SND_JACK_HEADSET);	else		snd_soc_jack_report(&hs_jack, SND_JACK_HEADSET, SND_JACK_HEADSET);	/* wait 500 ms before switching of HS power */	rtd->pmdown_time = 500;	return ret;}

static int aml_m1_codec_init(struct snd_soc_codec *codec){    struct snd_soc_card *card = codec->socdev->card;    int err;    //Add board specific DAPM widgets and routes    err = snd_soc_dapm_new_controls(codec, aml_m1_dapm_widgets, ARRAY_SIZE(aml_m1_dapm_widgets));    if(err){        dev_warn(card->dev, "Failed to register DAPM widgets/n");        return 0;    }    err = snd_soc_dapm_add_routes(codec, intercon,        ARRAY_SIZE(intercon));    if(err){        dev_warn(card->dev, "Failed to setup dapm widgets routine/n");        return 0;    }#if HP_DET    if ((soc_cs42l52_dai.ac97_pdata) && ((struct cs42l52_platform_data *) (soc_cs42l52_dai.ac97_pdata))->is_hp_pluged)        hp_detect_flag = ((struct cs42l52_platform_data *) (soc_cs42l52_dai.ac97_pdata))->is_hp_pluged() ? (0) : (1);    else        hp_detect_flag = 1; // If is_hp_pluged function is not registered in bsp, set speaker as default.    err = snd_soc_jack_new(card, "hp_switch",        SND_JACK_HEADSET, &hp_jack);    if(err){        dev_warn(card->dev, "Failed to alloc resource for hook switch/n");    }else{        err = snd_soc_jack_add_pins(&hp_jack, ARRAY_SIZE(hp_jack_pins), hp_jack_pins);        if(err){            dev_warn(card->dev, "Failed to setup hook hp jack pin/n");        }    }    // create a timer to poll the HP IN status    spin_lock_init(&lock);    timer.function = &cs42l52_hp_detect_timer;    timer.data = (unsigned long)codec;    timer.expires = jiffies + HZ*10;    init_timer(&timer);    INIT_WORK(&cs42l52_work.cs42l52_workqueue, cs42l52_hp_detect_queue);#endif    snd_soc_dapm_nc_pin(codec,"LINPUT1");    snd_soc_dapm_nc_pin(codec,"RINPUT1");    snd_soc_dapm_enable_pin(codec, "Ext Spk");    snd_soc_dapm_disable_pin(codec, "HP");    snd_soc_dapm_enable_pin(codec, "MIC IN");    snd_soc_dapm_disable_pin(codec, "HP MIC");    snd_soc_dapm_disable_pin(codec, "FM IN");    snd_soc_dapm_sync(codec);    return 0;}

static int sdp3430_twl4030_init(struct snd_soc_pcm_runtime *rtd){	struct snd_soc_codec *codec = rtd->codec;	struct snd_soc_dapm_context *dapm = &codec->dapm;	int ret;	/* Add SDP3430 specific widgets */	ret = snd_soc_dapm_new_controls(dapm, sdp3430_twl4030_dapm_widgets,				ARRAY_SIZE(sdp3430_twl4030_dapm_widgets));	if (ret)		return ret;	/* Set up SDP3430 specific audio path audio_map */	snd_soc_dapm_add_routes(dapm, audio_map, ARRAY_SIZE(audio_map));	/* SDP3430 connected pins */	snd_soc_dapm_enable_pin(dapm, "Ext Mic");	snd_soc_dapm_enable_pin(dapm, "Ext Spk");	snd_soc_dapm_disable_pin(dapm, "Headset Mic");	snd_soc_dapm_disable_pin(dapm, "Headset Stereophone");	/* TWL4030 not connected pins */	snd_soc_dapm_nc_pin(dapm, "AUXL");	snd_soc_dapm_nc_pin(dapm, "AUXR");	snd_soc_dapm_nc_pin(dapm, "CARKITMIC");	snd_soc_dapm_nc_pin(dapm, "DIGIMIC0");	snd_soc_dapm_nc_pin(dapm, "DIGIMIC1");	snd_soc_dapm_nc_pin(dapm, "OUTL");	snd_soc_dapm_nc_pin(dapm, "OUTR");	snd_soc_dapm_nc_pin(dapm, "EARPIECE");	snd_soc_dapm_nc_pin(dapm, "PREDRIVEL");	snd_soc_dapm_nc_pin(dapm, "PREDRIVER");	snd_soc_dapm_nc_pin(dapm, "CARKITL");	snd_soc_dapm_nc_pin(dapm, "CARKITR");	ret = snd_soc_dapm_sync(dapm);	if (ret)		return ret;	/* Headset jack detection */	ret = snd_soc_jack_new(codec, "Headset Jack",				SND_JACK_HEADSET, &hs_jack);	if (ret)		return ret;	ret = snd_soc_jack_add_pins(&hs_jack, ARRAY_SIZE(hs_jack_pins),				hs_jack_pins);	if (ret)		return ret;	ret = snd_soc_jack_add_gpios(&hs_jack, ARRAY_SIZE(hs_jack_gpios),				hs_jack_gpios);	return ret;}

static int omap_twl4030_init(struct snd_soc_pcm_runtime *rtd){	struct snd_soc_codec *codec = rtd->codec;	struct snd_soc_card *card = codec->card;	struct snd_soc_dapm_context *dapm = &codec->dapm;	struct omap_tw4030_pdata *pdata = dev_get_platdata(card->dev);	struct omap_twl4030 *priv = snd_soc_card_get_drvdata(card);	int ret = 0;	/* Headset jack detection only if it is supported */	if (priv->jack_detect > 0) {		hs_jack_gpios[0].gpio = priv->jack_detect;		ret = snd_soc_jack_new(codec, "Headset Jack", SND_JACK_HEADSET,				       &priv->hs_jack);		if (ret)			return ret;		ret = snd_soc_jack_add_pins(&priv->hs_jack,					    ARRAY_SIZE(hs_jack_pins),					    hs_jack_pins);		if (ret)			return ret;		ret = snd_soc_jack_add_gpios(&priv->hs_jack,					     ARRAY_SIZE(hs_jack_gpios),					     hs_jack_gpios);		if (ret)			return ret;	}	/*	 * NULL pdata means we booted with DT. In this case the routing is	 * provided and the card is fully routed, no need to mark pins.	 */	if (!pdata || !pdata->custom_routing)		return ret;	/* Disable not connected paths if not used */	twl4030_disconnect_pin(dapm, pdata->has_ear, "Earpiece Spk");	twl4030_disconnect_pin(dapm, pdata->has_hf, "Handsfree Spk");	twl4030_disconnect_pin(dapm, pdata->has_hs, "Headset Stereophone");	twl4030_disconnect_pin(dapm, pdata->has_predriv, "Ext Spk");	twl4030_disconnect_pin(dapm, pdata->has_carkit, "Carkit Spk");	twl4030_disconnect_pin(dapm, pdata->has_mainmic, "Main Mic");	twl4030_disconnect_pin(dapm, pdata->has_submic, "Sub Mic");	twl4030_disconnect_pin(dapm, pdata->has_hsmic, "Headset Mic");	twl4030_disconnect_pin(dapm, pdata->has_carkitmic, "Carkit Mic");	twl4030_disconnect_pin(dapm, pdata->has_digimic0, "Digital0 Mic");	twl4030_disconnect_pin(dapm, pdata->has_digimic1, "Digital1 Mic");	twl4030_disconnect_pin(dapm, pdata->has_linein, "Line In");	return ret;}

static int asoc_simple_card_dai_init(struct snd_soc_pcm_runtime *rtd){    struct simple_card_data *priv =	snd_soc_card_get_drvdata(rtd->card);    struct snd_soc_dai *codec = rtd->codec_dai;    struct snd_soc_dai *cpu = rtd->cpu_dai;    struct simple_dai_props *dai_props;    int num, ret;    num = rtd - rtd->card->rtd;    dai_props = &priv->dai_props[num];    ret = __asoc_simple_card_dai_init(codec, &dai_props->codec_dai);    if (ret < 0)        return ret;    ret = __asoc_simple_card_dai_init(cpu, &dai_props->cpu_dai);    if (ret < 0)        return ret;    if (gpio_is_valid(priv->gpio_hp_det)) {        snd_soc_jack_new(codec->codec, "Headphones", SND_JACK_HEADPHONE,                         &simple_card_hp_jack);        snd_soc_jack_add_pins(&simple_card_hp_jack,                              ARRAY_SIZE(simple_card_hp_jack_pins),                              simple_card_hp_jack_pins);        simple_card_hp_jack_gpio.gpio = priv->gpio_hp_det;        snd_soc_jack_add_gpios(&simple_card_hp_jack, 1,                               &simple_card_hp_jack_gpio);    }    if (gpio_is_valid(priv->gpio_mic_det)) {        snd_soc_jack_new(codec->codec, "Mic Jack", SND_JACK_MICROPHONE,                         &simple_card_mic_jack);        snd_soc_jack_add_pins(&simple_card_mic_jack,                              ARRAY_SIZE(simple_card_mic_jack_pins),                              simple_card_mic_jack_pins);        simple_card_mic_jack_gpio.gpio = priv->gpio_mic_det;        snd_soc_jack_add_gpios(&simple_card_mic_jack, 1,                               &simple_card_mic_jack_gpio);    }    return 0;}

static int palm27x_ac97_init(struct snd_soc_pcm_runtime *rtd){	struct snd_soc_codec *codec = rtd->codec;	int err;	/* add palm27x specific widgets */	err = snd_soc_dapm_new_controls(codec, palm27x_dapm_widgets,				ARRAY_SIZE(palm27x_dapm_widgets));	if (err)		return err;	/* set up palm27x specific audio path audio_map */	err = snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));	if (err)		return err;	/* connected pins */	if (machine_is_palmld())		snd_soc_dapm_enable_pin(codec, "MIC1");	snd_soc_dapm_enable_pin(codec, "HPOUTL");	snd_soc_dapm_enable_pin(codec, "HPOUTR");	snd_soc_dapm_enable_pin(codec, "LOUT2");	snd_soc_dapm_enable_pin(codec, "ROUT2");	/* not connected pins */	snd_soc_dapm_nc_pin(codec, "OUT3");	snd_soc_dapm_nc_pin(codec, "MONOOUT");	snd_soc_dapm_nc_pin(codec, "LINEINL");	snd_soc_dapm_nc_pin(codec, "LINEINR");	snd_soc_dapm_nc_pin(codec, "PCBEEP");	snd_soc_dapm_nc_pin(codec, "PHONE");	snd_soc_dapm_nc_pin(codec, "MIC2");	err = snd_soc_dapm_sync(codec);	if (err)		return err;	/* Jack detection API stuff */	err = snd_soc_jack_new(codec, "Headphone Jack",				SND_JACK_HEADPHONE, &hs_jack);	if (err)		return err;	err = snd_soc_jack_add_pins(&hs_jack, ARRAY_SIZE(hs_jack_pins),				hs_jack_pins);	if (err)		return err;	err = snd_soc_jack_add_gpios(&hs_jack, ARRAY_SIZE(hs_jack_gpios),				hs_jack_gpios);	return err;}

/* * 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;	struct snd_soc_dapm_context *dapm = &codec->dapm;	int ret = 0;//	int gpiostatus;	printk(KERN_INFO "entered the omap4_aic31xx_init function..../n");	/* Add OMAP4 specific widgets */	ret = snd_soc_dapm_new_controls(dapm, omap4_aic31xx_dapm_widgets,					ARRAY_SIZE(omap4_aic31xx_dapm_widgets));	if (ret) {		printk(KERN_INFO "snd_soc_dapm_new_controls failed./n");		return ret;	}	DBG("snd_soc_dapm_new_controls passed../n");	/* Set up OMAP4 specific audio path audio_map */	ret = snd_soc_dapm_add_routes(dapm, audio_map, ARRAY_SIZE(audio_map));	if (ret != 0)		printk(KERN_INFO "snd_soc_dapm_add_routes failed..%d/n", ret);	ret = snd_soc_dapm_sync(dapm);	if (ret != 0) {		printk(KERN_INFO "snd_soc_dapm_sync failed... %d/n", ret);		return ret;	}	/* 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);	DBG("%s: Exiting/n", __func__);	return ret;}

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));    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,"rt5631_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    return 0;}

/* Line discipline .receive_buf() */static void cx81801_receive(struct tty_struct *tty,				const unsigned char *cp, char *fp, int count){	struct snd_soc_codec *codec = tty->disc_data;	const unsigned char *c;	int apply, ret;	if (!codec)		return;	if (!codec->hw_write) {		/* First modem response, complete setup procedure */		/* Initialize timer used for config pulse generation */		setup_timer(&cx81801_timer, cx81801_timeout, 0);		v253_ops.receive_buf(tty, cp, fp, count);		/* Link hook switch to DAPM pins */		ret = snd_soc_jack_add_pins(&ams_delta_hook_switch,					ARRAY_SIZE(ams_delta_hook_switch_pins),					ams_delta_hook_switch_pins);		if (ret)			dev_warn(codec->dev,				"Failed to link hook switch to DAPM pins, "				"will continue with hook switch unlinked./n");		return;	}	v253_ops.receive_buf(tty, cp, fp, count);	for (c = &cp[count - 1]; c >= cp; c--) {		if (*c != '/r')			continue;		/* Complete modem response received, apply config to codec */		spin_lock_bh(&ams_delta_lock);		mod_timer(&cx81801_timer, jiffies + msecs_to_jiffies(150));		apply = !ams_delta_muted && !cx81801_cmd_pending;		cx81801_cmd_pending = 1;		spin_unlock_bh(&ams_delta_lock);		/* Apply config pulse by connecting the codec to the modem		 * if not already done */		if (apply)			ams_delta_latch2_write(AMS_DELTA_LATCH2_MODEM_CODEC,						AMS_DELTA_LATCH2_MODEM_CODEC);		break;	}}

static int omap_abe_twl6040_init(struct snd_soc_pcm_runtime *rtd){	struct snd_soc_codec *codec = rtd->codec;	struct snd_soc_card *card = codec->card;	struct snd_soc_dapm_context *dapm = &codec->dapm;	struct omap_abe_twl6040_data *pdata = dev_get_platdata(card->dev);	struct abe_twl6040 *priv = snd_soc_card_get_drvdata(card);	int hs_trim;	int ret = 0;	/*	 * Configure McPDM offset cancellation based on the HSOTRIM value from	 * twl6040.	 */	hs_trim = twl6040_get_trim_value(codec, TWL6040_TRIM_HSOTRIM);	omap_mcpdm_configure_dn_offsets(rtd, TWL6040_HSF_TRIM_LEFT(hs_trim),					TWL6040_HSF_TRIM_RIGHT(hs_trim));	/* Headset jack detection only if it is supported */	if (priv->jack_detection) {		ret = snd_soc_jack_new(codec, "Headset Jack",					SND_JACK_HEADSET, &hs_jack);		if (ret)			return ret;		ret = snd_soc_jack_add_pins(&hs_jack, ARRAY_SIZE(hs_jack_pins),					hs_jack_pins);		twl6040_hs_jack_detect(codec, &hs_jack, SND_JACK_HEADSET);	}	/*	 * NULL pdata means we booted with DT. In this case the routing is	 * provided and the card is fully routed, no need to mark pins.	 */	if (!pdata)		return ret;	/* Disable not connected paths if not used */	twl6040_disconnect_pin(dapm, pdata->has_hs, "Headset Stereophone");	twl6040_disconnect_pin(dapm, pdata->has_hf, "Ext Spk");	twl6040_disconnect_pin(dapm, pdata->has_ep, "Earphone Spk");	twl6040_disconnect_pin(dapm, pdata->has_aux, "Line Out");	twl6040_disconnect_pin(dapm, pdata->has_vibra, "Vibrator");	twl6040_disconnect_pin(dapm, pdata->has_hsmic, "Headset Mic");	twl6040_disconnect_pin(dapm, pdata->has_mainmic, "Main Handset Mic");	twl6040_disconnect_pin(dapm, pdata->has_submic, "Sub Handset Mic");	twl6040_disconnect_pin(dapm, pdata->has_afm, "Line In");	return ret;}

static int smartq_wm8987_init(struct snd_soc_codec *codec){	int err = 0;	/* Add SmartQ specific widgets */	snd_soc_dapm_new_controls(codec, wm8987_dapm_widgets,				  ARRAY_SIZE(wm8987_dapm_widgets));	/* add SmartQ specific controls */	err = snd_soc_add_controls(codec, wm8987_smartq_controls,				   ARRAY_SIZE(wm8987_smartq_controls));	if (err < 0)		return err;	/* setup SmartQ specific audio path */	snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));	/* set endpoints to not connected */	snd_soc_dapm_nc_pin(codec, "LINPUT1");	snd_soc_dapm_nc_pin(codec, "RINPUT1");	snd_soc_dapm_nc_pin(codec, "OUT3");	snd_soc_dapm_nc_pin(codec, "ROUT1");	/* set endpoints to default off mode */	snd_soc_dapm_enable_pin(codec, "Internal Speaker");	snd_soc_dapm_enable_pin(codec, "Internal Mic");	snd_soc_dapm_disable_pin(codec, "Headphone Jack");	err = snd_soc_dapm_sync(codec);	if (err)		return err;	/* Headphone jack detection */	err = snd_soc_jack_new(&snd_soc_smartq, "Headphone Jack",			       SND_JACK_HEADPHONE, &smartq_jack);	if (err)		return err;	err = snd_soc_jack_add_pins(&smartq_jack, ARRAY_SIZE(smartq_jack_pins),				    smartq_jack_pins);	if (err)		return err;	err = snd_soc_jack_add_gpios(&smartq_jack,				     ARRAY_SIZE(smartq_jack_gpios),				     smartq_jack_gpios);	return err;}

int tegra_jack_init(struct snd_soc_codec *codec){	int ret;	if (!codec)		return -1;	tegra_wired_jack = kzalloc(sizeof(*tegra_wired_jack), GFP_KERNEL);	if (!tegra_wired_jack) {		pr_err("failed to allocate tegra_wired_jack/n");		return -ENOMEM;	}	/* Add jack detection */	ret = snd_soc_jack_new(codec->socdev->card, "Headset Jack",			       SND_JACK_HEADSET, tegra_wired_jack);	if (ret < 0)		goto failed;	ret = snd_soc_jack_add_pins(tegra_wired_jack,				    ARRAY_SIZE(hs_jack_pins),				    hs_jack_pins);	if (ret < 0)		goto failed;	/* Addd h2w swith class support */	ret = switch_dev_register(&wired_switch_dev);	if (ret < 0)		goto switch_dev_failed;	snd_soc_jack_notifier_register(tegra_wired_jack,				       &wired_switch_nb);	ret = platform_driver_register(&tegra_wired_jack_driver);	if (ret < 0)		goto platform_dev_failed;	return 0;switch_dev_failed:	switch_dev_unregister(&wired_switch_dev);platform_dev_failed:	platform_driver_unregister(&tegra_wired_jack_driver);failed:	if (tegra_wired_jack) {		kfree(tegra_wired_jack);		tegra_wired_jack = 0;	}	return ret;}

static int sdp4430_twl6040_init(struct snd_soc_pcm_runtime *rtd){	struct snd_soc_codec *codec = rtd->codec;	struct snd_soc_dapm_context *dapm = &codec->dapm;	int ret;	/* Add SDP4430 specific controls */	ret = snd_soc_add_controls(codec, sdp4430_controls,				ARRAY_SIZE(sdp4430_controls));	if (ret)		return ret;	/* Add SDP4430 specific widgets */	ret = snd_soc_dapm_new_controls(dapm, sdp4430_twl6040_dapm_widgets,				ARRAY_SIZE(sdp4430_twl6040_dapm_widgets));	if (ret)		return ret;	/* Set up SDP4430 specific audio path audio_map */	snd_soc_dapm_add_routes(dapm, audio_map, ARRAY_SIZE(audio_map));	/* SDP4430 connected pins */	snd_soc_dapm_enable_pin(dapm, "Ext Mic");	snd_soc_dapm_enable_pin(dapm, "Ext Spk");	snd_soc_dapm_enable_pin(dapm, "AFML");	snd_soc_dapm_enable_pin(dapm, "AFMR");	snd_soc_dapm_enable_pin(dapm, "Headset Mic");	snd_soc_dapm_enable_pin(dapm, "Headset Stereophone");	ret = snd_soc_dapm_sync(dapm);	if (ret)		return ret;	/* Headset jack detection */	ret = snd_soc_jack_new(codec, "Headset Jack",				SND_JACK_HEADSET, &hs_jack);	if (ret)		return ret;	ret = snd_soc_jack_add_pins(&hs_jack, ARRAY_SIZE(hs_jack_pins),				hs_jack_pins);	if (machine_is_omap_4430sdp())		twl6040_hs_jack_detect(codec, &hs_jack, SND_JACK_HEADSET);	else		snd_soc_jack_report(&hs_jack, SND_JACK_HEADSET, SND_JACK_HEADSET);	return ret;}

static int rx1950_uda1380_init(struct snd_soc_pcm_runtime *rtd){	struct snd_soc_codec *codec = rtd->codec;	snd_soc_jack_new(codec, "Headphone Jack", SND_JACK_HEADPHONE,		&hp_jack);	snd_soc_jack_add_pins(&hp_jack, ARRAY_SIZE(hp_jack_pins),		hp_jack_pins);	snd_soc_jack_add_gpios(&hp_jack, ARRAY_SIZE(hp_jack_gpios),		hp_jack_gpios);	return 0;}