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 littlemill_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, WM8994_SYSCLK_MCLK2,
32768, SND_SOC_CLOCK_IN);
if (ret < 0)
return ret;
ret = snd_soc_jack_new(codec, "Headset",
SND_JACK_HEADSET | SND_JACK_MECHANICAL |
SND_JACK_BTN_0 | SND_JACK_BTN_1 |
SND_JACK_BTN_2 | SND_JACK_BTN_3 |
SND_JACK_BTN_4 | SND_JACK_BTN_5,
&littlemill_headset);
if (ret)
return ret;
/* This will check device compatibility itself */
wm8958_mic_detect(codec, &littlemill_headset, NULL, NULL);
/* As will this */
wm8994_mic_detect(codec, &littlemill_headset, 1);
return 0;
}
static int alc5623_dai_init(struct snd_soc_pcm_runtime *rtd)
{
struct snd_soc_codec *codec = rtd->codec;
struct snd_soc_jack_gpio *jack = &jack_gpio;
int ret;
pr_debug("%s: %s\n", __func__, jack->name);
alc5623 = codec;
if (NULL == jack->name)
return 0;
#if defined(CONFIG_PLAT_S5P4418_NBOX)
/***************************************/
// jimmy@zhongwei, 20140609 Testing
/***************************************/
ret = switch_dev_register(&switch_nxl_jack_detection);
if (ret < 0) {
printk("%s : Failed to register switch device\n", __func__);
}
//wake_lock_init(&detect_jack_wake_lock, WAKE_LOCK_SUSPEND, "nxl_jack_detect");
#endif
ret = snd_soc_jack_new(codec, "Headphone Jack", SND_JACK_HEADPHONE, &hp_jack);
if (ret)
return ret;
ret = snd_soc_jack_add_gpios(&hp_jack, 1, jack);
printk("%s: %s register audio jack detect, %d\n", ret?"Fail":"Done", __func__, jack->gpio);
return 0;
}
/*
* 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 smartq_wm8987_init(struct snd_soc_pcm_runtime *rtd)
{
struct snd_soc_codec *codec = rtd->codec;
struct snd_soc_dapm_context *dapm = &codec->dapm;
int err = 0;
/* set endpoints to not connected */
snd_soc_dapm_nc_pin(dapm, "LINPUT1");
snd_soc_dapm_nc_pin(dapm, "RINPUT1");
snd_soc_dapm_nc_pin(dapm, "OUT3");
snd_soc_dapm_nc_pin(dapm, "ROUT1");
/* set endpoints to default off mode */
snd_soc_dapm_disable_pin(dapm, "Headphone Jack");
/* Headphone jack detection */
err = snd_soc_jack_new(codec, "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;
}
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_LINEOUT | SND_JACK_HEADSET |
SND_JACK_BTN_0,
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 msm8930_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()\n", __func__);
snd_soc_dapm_new_controls(dapm, msm8930_dapm_widgets,
ARRAY_SIZE(msm8930_dapm_widgets));
snd_soc_dapm_add_routes(dapm, common_audio_map,
ARRAY_SIZE(common_audio_map));
snd_soc_dapm_enable_pin(dapm, "Ext Spk Left Pos");
snd_soc_dapm_enable_pin(dapm, "Ext Spk Left 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",
SITAR_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");
mbhc_cfg.gpio = 37;
mbhc_cfg.gpio_irq = gpio_to_irq(mbhc_cfg.gpio);
sitar_hs_detect(codec, &mbhc_cfg);
if (socinfo_get_pmic_model() != PMIC_MODEL_PM8917) {
/* Initialize default PMIC speaker gain */
pm8xxx_spk_gain(DEFAULT_PMIC_SPK_GAIN);
}
return 0;
}
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 ams_delta_cx20442_init(struct snd_soc_pcm_runtime *rtd)
{
struct snd_soc_dai *codec_dai = rtd->codec_dai;
struct snd_soc_card *card = rtd->card;
struct snd_soc_dapm_context *dapm = &card->dapm;
int ret;
/* Codec is ready, now add/activate board specific controls */
/* Store a pointer to the codec structure for tty ldisc use */
cx20442_codec = rtd->codec;
/* Set up digital mute if not provided by the codec */
if (!codec_dai->driver->ops) {
codec_dai->driver->ops = &ams_delta_dai_ops;
} else {
ams_delta_ops.startup = ams_delta_startup;
ams_delta_ops.shutdown = ams_delta_shutdown;
}
/* Add hook switch - can be used to control the codec from userspace
* even if line discipline fails */
ret = snd_soc_jack_new(rtd->codec, "hook_switch",
SND_JACK_HEADSET, &ams_delta_hook_switch);
if (ret)
dev_warn(card->dev,
"Failed to allocate resources for hook switch, "
"will continue without one.\n");
else {
ret = snd_soc_jack_add_gpios(&ams_delta_hook_switch,
ARRAY_SIZE(ams_delta_hook_switch_gpios),
ams_delta_hook_switch_gpios);
if (ret)
dev_warn(card->dev,
"Failed to set up hook switch GPIO line, "
"will continue with hook switch inactive.\n");
}
/* Register optional line discipline for over the modem control */
ret = tty_register_ldisc(N_V253, &cx81801_ops);
if (ret) {
dev_warn(card->dev,
"Failed to register line discipline, "
"will continue without any controls.\n");
return 0;
}
/* Set up initial pin constellation */
snd_soc_dapm_disable_pin(dapm, "Mouthpiece");
snd_soc_dapm_disable_pin(dapm, "Speaker");
snd_soc_dapm_disable_pin(dapm, "AGCIN");
snd_soc_dapm_disable_pin(dapm, "AGCOUT");
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;
}
static int rt5512_init(struct snd_soc_pcm_runtime *rtd)
{
struct snd_soc_codec *codec = rtd->codec;
struct snd_soc_dapm_context *dapm = &codec->dapm;
//struct rt5512_codec_chip *chip = snd_soc_codec_get_drvdata(codec);
//int err = 0;
snd_soc_dapm_new_controls(dapm, rt5512_dapm_widgets,
ARRAY_SIZE(rt5512_dapm_widgets));
snd_soc_dapm_add_routes(dapm, rt5512_audio_map,
ARRAY_SIZE(rt5512_audio_map));
#if FOR_MID
snd_soc_dapm_disable_pin(dapm, "Main Mic");
snd_soc_dapm_disable_pin(dapm, "LineIn");
snd_soc_dapm_disable_pin(dapm, "Ext Spk");
snd_soc_dapm_disable_pin(dapm, "Headphone Jack");
#endif
#if 0
if (!chip->rt_jack)
{
err = snd_soc_jack_new(codec, "Headset Jack" , SND_JACK_HEADSET, &rk29_soc_jack);
if (err)
return err;
#if 0
// How-to use gpio, just declare snd_soc_jack_gpios, then it will
// help you to register a interrupt and set wakeup, and delayed schedule
// work
err = snd_soc_jack_add_gpios(&odroid_soc_jack, gpio_count, odroid_soc_jack_gpios);
if (err)
return err;
// If use this, when trigger, just use snd_soc_jack_get_type
// then snd_soc_jack_report to send the event to upper layer
err = snd_soc_jack_add_zones(&odroid_soc_jack, zone_count, tcc_soc_zones);
if (err)
return err;
#endif
err = rt5512_headset_keys(&rk29_soc_jack);
if (err)
return err;
chip->rt_jack = &rk29_soc_jack;
}
#endif
snd_soc_dapm_sync(dapm);
return 0;
}
static int saarb_pm860x_init(struct snd_soc_pcm_runtime *rtd)
{
struct snd_soc_codec *codec = rtd->codec;
struct snd_soc_dapm_context *dapm = &codec->dapm;
int ret;
snd_soc_dapm_new_controls(dapm, saarb_dapm_widgets,
ARRAY_SIZE(saarb_dapm_widgets));
snd_soc_dapm_add_routes(dapm, audio_map, ARRAY_SIZE(audio_map));
/* connected pins */
snd_soc_dapm_enable_pin(dapm, "Ext Speaker");
snd_soc_dapm_enable_pin(dapm, "Ext Mic 1");
snd_soc_dapm_enable_pin(dapm, "Ext Mic 3");
snd_soc_dapm_disable_pin(dapm, "Headset Mic 2");
snd_soc_dapm_disable_pin(dapm, "Headset Stereophone");
ret = snd_soc_dapm_sync(dapm);
if (ret)
return ret;
/* Headset jack detection */
snd_soc_jack_new(codec, "Headphone Jack", SND_JACK_HEADPHONE
| SND_JACK_BTN_0 | SND_JACK_BTN_1 | SND_JACK_BTN_2,
&hs_jack);
snd_soc_jack_add_pins(&hs_jack, ARRAY_SIZE(hs_jack_pins),
hs_jack_pins);
snd_soc_jack_new(codec, "Microphone Jack", SND_JACK_MICROPHONE,
&mic_jack);
snd_soc_jack_add_pins(&mic_jack, ARRAY_SIZE(mic_jack_pins),
mic_jack_pins);
/* headphone, microphone detection & headset short detection */
pm860x_hs_jack_detect(codec, &hs_jack, SND_JACK_HEADPHONE,
SND_JACK_BTN_0, SND_JACK_BTN_1, SND_JACK_BTN_2);
pm860x_mic_jack_detect(codec, &hs_jack, SND_JACK_MICROPHONE);
return 0;
}
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 rx51_aic34_init(struct snd_soc_pcm_runtime *rtd)
{
struct snd_soc_codec *codec = rtd->codec;
struct snd_soc_card *card = rtd->card;
struct rx51_audio_pdata *pdata = snd_soc_card_get_drvdata(card);
struct snd_soc_dapm_context *dapm = &codec->dapm;
int err;
/* Set up NC codec pins */
snd_soc_dapm_nc_pin(dapm, "MIC3L");
snd_soc_dapm_nc_pin(dapm, "MIC3R");
snd_soc_dapm_nc_pin(dapm, "LINE1R");
err = tpa6130a2_add_controls(codec);
if (err < 0) {
dev_err(card->dev, "Failed to add TPA6130A2 controls\n");
return err;
}
snd_soc_limit_volume(codec, "TPA6130A2 Headphone Playback Volume", 42);
err = omap_mcbsp_st_add_controls(rtd, 2);
if (err < 0) {
dev_err(card->dev, "Failed to add MCBSP controls\n");
return err;
}
/* AV jack detection */
err = snd_soc_jack_new(codec, "AV Jack",
SND_JACK_HEADSET | SND_JACK_VIDEOOUT,
&rx51_av_jack);
if (err) {
dev_err(card->dev, "Failed to add AV Jack\n");
return err;
}
/* prepare gpio for snd_soc_jack_add_gpios */
rx51_av_jack_gpios[0].gpio = desc_to_gpio(pdata->jack_detection_gpio);
devm_gpiod_put(card->dev, pdata->jack_detection_gpio);
err = snd_soc_jack_add_gpios(&rx51_av_jack,
ARRAY_SIZE(rx51_av_jack_gpios),
rx51_av_jack_gpios);
if (err) {
dev_err(card->dev, "Failed to add GPIOs\n");
return err;
}
return err;
}
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;
}
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 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 err;
}
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 err;
}
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");
}
}
m1_data->codec = codec;
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, "Headset Jack");
snd_soc_dapm_enable_pin(codec, "Mic Jack");
snd_soc_dapm_sync(codec);
queue_delayed_work(m1_data->work_queue, &m1_data->work, HZ*2);
return 0;
}
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;
}
static int rx51_aic34_init(struct snd_soc_pcm_runtime *rtd)
{
struct snd_soc_codec *codec = rtd->codec;
struct snd_soc_dapm_context *dapm = &codec->dapm;
int err;
/* Set up NC codec pins */
snd_soc_dapm_nc_pin(dapm, "MIC3L");
snd_soc_dapm_nc_pin(dapm, "MIC3R");
snd_soc_dapm_nc_pin(dapm, "LINE1R");
/* Add RX-51 specific controls */
err = snd_soc_add_controls(codec, aic34_rx51_controls,
ARRAY_SIZE(aic34_rx51_controls));
if (err < 0)
return err;
/* Add RX-51 specific widgets */
snd_soc_dapm_new_controls(dapm, aic34_dapm_widgets,
ARRAY_SIZE(aic34_dapm_widgets));
/* Set up RX-51 specific audio path audio_map */
snd_soc_dapm_add_routes(dapm, audio_map, ARRAY_SIZE(audio_map));
err = tpa6130a2_add_controls(codec);
if (err < 0)
return err;
snd_soc_limit_volume(codec, "TPA6130A2 Headphone Playback Volume", 42);
err = omap_mcbsp_st_add_controls(codec, 1);
if (err < 0)
return err;
snd_soc_dapm_sync(dapm);
/* AV jack detection */
err = snd_soc_jack_new(codec, "AV Jack",
SND_JACK_HEADSET | SND_JACK_VIDEOOUT,
&rx51_av_jack);
if (err)
return err;
err = snd_soc_jack_add_gpios(&rx51_av_jack,
ARRAY_SIZE(rx51_av_jack_gpios),
rx51_av_jack_gpios);
return err;
}
static int sdp4430_twl6040_init(struct snd_soc_codec *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, 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, audio_map, ARRAY_SIZE(audio_map));
/* SDP4430 connected pins */
snd_soc_dapm_enable_pin(codec, "Ext Mic");
snd_soc_dapm_enable_pin(codec, "Ext Spk");
snd_soc_dapm_enable_pin(codec, "AFML");
snd_soc_dapm_enable_pin(codec, "AFMR");
snd_soc_dapm_disable_pin(codec, "Headset Mic");
snd_soc_dapm_disable_pin(codec, "Headset Stereophone");
ret = snd_soc_dapm_sync(codec);
if (ret)
return ret;
/*Headset jack detection */
ret = snd_soc_jack_new(&snd_soc_sdp4430, "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);
return ret;
}
/*
* Logic for a wm8750 as connected on a Z2 Device
*/
static int z2_wm8750_init(struct snd_soc_pcm_runtime *rtd)
{
struct snd_soc_codec *codec = rtd->codec;
int ret;
/* NC codec pins */
snd_soc_dapm_disable_pin(codec, "LINPUT3");
snd_soc_dapm_disable_pin(codec, "RINPUT3");
snd_soc_dapm_disable_pin(codec, "OUT3");
snd_soc_dapm_disable_pin(codec, "MONO");
/* Add z2 specific widgets */
snd_soc_dapm_new_controls(codec, wm8750_dapm_widgets,
ARRAY_SIZE(wm8750_dapm_widgets));
/* Set up z2 specific audio paths */
snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
ret = snd_soc_dapm_sync(codec);
if (ret)
goto err;
/* Jack detection API stuff */
ret = snd_soc_jack_new(codec, "Headset Jack", SND_JACK_HEADSET,
&hs_jack);
if (ret)
goto err;
ret = snd_soc_jack_add_pins(&hs_jack, ARRAY_SIZE(hs_jack_pins),
hs_jack_pins);
if (ret)
goto err;
ret = snd_soc_jack_add_gpios(&hs_jack, ARRAY_SIZE(hs_jack_gpios),
hs_jack_gpios);
if (ret)
goto err;
return 0;
err:
return ret;
}
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;
/* */
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");
/* */
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_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;
}
