static int tegra_rt5677_asoc_init(struct snd_soc_pcm_runtime *rtd) { struct tegra_rt5677 *machine = snd_soc_card_get_drvdata(rtd->card); snd_soc_card_jack_new(rtd->card, "Headphone Jack", SND_JACK_HEADPHONE, &tegra_rt5677_hp_jack, &tegra_rt5677_hp_jack_pins, 1); if (gpio_is_valid(machine->gpio_hp_det)) { tegra_rt5677_hp_jack_gpio.gpio = machine->gpio_hp_det; snd_soc_jack_add_gpios(&tegra_rt5677_hp_jack, 1, &tegra_rt5677_hp_jack_gpio); } snd_soc_card_jack_new(rtd->card, "Mic Jack", SND_JACK_MICROPHONE, &tegra_rt5677_mic_jack, &tegra_rt5677_mic_jack_pins, 1); if (gpio_is_valid(machine->gpio_mic_present)) { tegra_rt5677_mic_jack_gpio.gpio = machine->gpio_mic_present; snd_soc_jack_add_gpios(&tegra_rt5677_mic_jack, 1, &tegra_rt5677_mic_jack_gpio); } snd_soc_dapm_force_enable_pin(&rtd->card->dapm, "MICBIAS1"); return 0; }
static int tegra_max98090_asoc_init(struct snd_soc_pcm_runtime *rtd) { struct tegra_max98090 *machine = snd_soc_card_get_drvdata(rtd->card); if (gpio_is_valid(machine->gpio_hp_det)) { snd_soc_card_jack_new(rtd->card, "Headphones", SND_JACK_HEADPHONE, &tegra_max98090_hp_jack, tegra_max98090_hp_jack_pins, ARRAY_SIZE(tegra_max98090_hp_jack_pins)); tegra_max98090_hp_jack_gpio.gpio = machine->gpio_hp_det; snd_soc_jack_add_gpios(&tegra_max98090_hp_jack, 1, &tegra_max98090_hp_jack_gpio); } if (gpio_is_valid(machine->gpio_mic_det)) { snd_soc_card_jack_new(rtd->card, "Mic Jack", SND_JACK_MICROPHONE, &tegra_max98090_mic_jack, tegra_max98090_mic_jack_pins, ARRAY_SIZE(tegra_max98090_mic_jack_pins)); tegra_max98090_mic_jack_gpio.gpio = machine->gpio_mic_det; snd_soc_jack_add_gpios(&tegra_max98090_mic_jack, 1, &tegra_max98090_mic_jack_gpio); } 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_card *card = rtd->card; struct tegra_wm8903 *machine = snd_soc_card_get_drvdata(card); if (gpio_is_valid(machine->gpio_hp_det)) { tegra_wm8903_hp_jack_gpio.gpio = machine->gpio_hp_det; snd_soc_card_jack_new(rtd->card, "Headphone Jack", SND_JACK_HEADPHONE, &tegra_wm8903_hp_jack, tegra_wm8903_hp_jack_pins, ARRAY_SIZE(tegra_wm8903_hp_jack_pins)); snd_soc_jack_add_gpios(&tegra_wm8903_hp_jack, 1, &tegra_wm8903_hp_jack_gpio); } snd_soc_card_jack_new(rtd->card, "Mic Jack", SND_JACK_MICROPHONE, &tegra_wm8903_mic_jack, tegra_wm8903_mic_jack_pins, ARRAY_SIZE(tegra_wm8903_mic_jack_pins)); wm8903_mic_detect(codec, &tegra_wm8903_mic_jack, SND_JACK_MICROPHONE, 0); snd_soc_dapm_force_enable_pin(&card->dapm, "MICBIAS"); return 0; }
static int cht_codec_init(struct snd_soc_pcm_runtime *runtime) { int ret; int jack_type; struct cht_mc_private *ctx = snd_soc_card_get_drvdata(runtime->card); struct snd_soc_jack *jack = &ctx->jack; /** * TI supports 4 butons headset detection * KEY_MEDIA * KEY_VOICECOMMAND * KEY_VOLUMEUP * KEY_VOLUMEDOWN */ if (ctx->ts3a227e_present) jack_type = SND_JACK_HEADPHONE | SND_JACK_MICROPHONE | SND_JACK_BTN_0 | SND_JACK_BTN_1 | SND_JACK_BTN_2 | SND_JACK_BTN_3; else jack_type = SND_JACK_HEADPHONE | SND_JACK_MICROPHONE; ret = snd_soc_card_jack_new(runtime->card, "Headset Jack", jack_type, jack, NULL, 0); if (ret) { dev_err(runtime->dev, "Headset Jack creation failed %d\n", ret); return ret; } if (ctx->ts3a227e_present) snd_soc_jack_notifier_register(jack, &cht_jack_nb); return ret; }
static int cht_max98090_headset_init(struct snd_soc_component *component) { struct snd_soc_card *card = component->card; struct cht_mc_private *ctx = snd_soc_card_get_drvdata(card); struct snd_soc_jack *jack = &ctx->jack; int jack_type; int ret; /* * TI supports 4 butons headset detection * KEY_MEDIA * KEY_VOICECOMMAND * KEY_VOLUMEUP * KEY_VOLUMEDOWN */ jack_type = SND_JACK_HEADPHONE | SND_JACK_MICROPHONE | SND_JACK_BTN_0 | SND_JACK_BTN_1 | SND_JACK_BTN_2 | SND_JACK_BTN_3; ret = snd_soc_card_jack_new(card, "Headset Jack", jack_type, jack, NULL, 0); if (ret) { dev_err(card->dev, "Headset Jack creation failed %d\n", ret); return ret; } return ts3a227e_enable_jack_detect(component, jack); }
static int littlemill_late_probe(struct snd_soc_card *card) { struct snd_soc_codec *codec = card->rtd[0].codec; struct snd_soc_dai *aif1_dai = card->rtd[0].codec_dai; struct snd_soc_dai *aif2_dai = card->rtd[1].cpu_dai; int ret; ret = snd_soc_dai_set_sysclk(aif1_dai, WM8994_SYSCLK_MCLK2, 32768, SND_SOC_CLOCK_IN); if (ret < 0) return ret; ret = snd_soc_dai_set_sysclk(aif2_dai, WM8994_SYSCLK_MCLK2, 32768, SND_SOC_CLOCK_IN); if (ret < 0) return ret; ret = snd_soc_card_jack_new(card, "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, NULL, 0); if (ret) return ret; /* This will check device compatibility itself */ wm8958_mic_detect(codec, &littlemill_headset, NULL, NULL, NULL, NULL); /* As will this */ wm8994_mic_detect(codec, &littlemill_headset, 1); return 0; }
static int smartq_wm8987_init(struct snd_soc_pcm_runtime *rtd) { struct snd_soc_dapm_context *dapm = &rtd->card->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"); /* Headphone jack detection */ err = snd_soc_card_jack_new(rtd->card, "Headphone Jack", SND_JACK_HEADPHONE, &smartq_jack, smartq_jack_pins, ARRAY_SIZE(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 mt8173_rt5650_rt5514_init(struct snd_soc_pcm_runtime *runtime) { struct snd_soc_card *card = runtime->card; struct snd_soc_codec *codec = runtime->codec_dais[0]->codec; int ret; rt5645_sel_asrc_clk_src(codec, RT5645_DA_STEREO_FILTER | RT5645_AD_STEREO_FILTER, RT5645_CLK_SEL_I2S1_ASRC); /* enable jack detection */ ret = snd_soc_card_jack_new(card, "Headset Jack", SND_JACK_HEADPHONE | SND_JACK_MICROPHONE | SND_JACK_BTN_0 | SND_JACK_BTN_1 | SND_JACK_BTN_2 | SND_JACK_BTN_3, &mt8173_rt5650_rt5514_jack, NULL, 0); if (ret) { dev_err(card->dev, "Can't new Headset Jack %d\n", ret); return ret; } return rt5645_set_jack_detect(codec, &mt8173_rt5650_rt5514_jack, &mt8173_rt5650_rt5514_jack, &mt8173_rt5650_rt5514_jack); }
static int cht_codec_init(struct snd_soc_pcm_runtime *runtime) { int ret; int jack_type; struct cht_mc_private *ctx = snd_soc_card_get_drvdata(runtime->card); struct snd_soc_jack *jack = &ctx->jack; if (ctx->ts3a227e_present) { /* * The jack has already been created in the * cht_max98090_headset_init() function. */ snd_soc_jack_notifier_register(jack, &cht_jack_nb); return 0; } jack_type = SND_JACK_HEADPHONE | SND_JACK_MICROPHONE; ret = snd_soc_card_jack_new(runtime->card, "Headset Jack", jack_type, jack, hs_jack_pins, ARRAY_SIZE(hs_jack_pins)); if (ret) { dev_err(runtime->dev, "Headset Jack creation failed %d\n", ret); return ret; } ret = snd_soc_jack_add_gpiods(runtime->card->dev->parent, jack, ARRAY_SIZE(hs_jack_gpios), hs_jack_gpios); if (ret) { /* * flag error but don't bail if jack detect is broken * due to platform issues or bad BIOS/configuration */ dev_err(runtime->dev, "jack detection gpios not added, error %d\n", ret); } /* * The firmware might enable the clock at * boot (this information may or may not * be reflected in the enable clock register). * To change the rate we must disable the clock * first to cover these cases. Due to common * clock framework restrictions that do not allow * to disable a clock that has not been enabled, * we need to enable the clock first. */ ret = clk_prepare_enable(ctx->mclk); if (!ret) clk_disable_unprepare(ctx->mclk); ret = clk_set_rate(ctx->mclk, CHT_PLAT_CLK_3_HZ); if (ret) dev_err(runtime->dev, "unable to set MCLK rate\n"); 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_card_jack_new(rtd->card, "Headphones", SND_JACK_HEADPHONE, &simple_card_hp_jack, simple_card_hp_jack_pins, ARRAY_SIZE(simple_card_hp_jack_pins)); simple_card_hp_jack_gpio.gpio = priv->gpio_hp_det; simple_card_hp_jack_gpio.invert = priv->gpio_hp_det_invert; 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_card_jack_new(rtd->card, "Mic Jack", SND_JACK_MICROPHONE, &simple_card_mic_jack, simple_card_mic_jack_pins, ARRAY_SIZE(simple_card_mic_jack_pins)); simple_card_mic_jack_gpio.gpio = priv->gpio_mic_det; simple_card_mic_jack_gpio.invert = priv->gpio_mic_det_invert; snd_soc_jack_add_gpios(&simple_card_mic_jack, 1, &simple_card_mic_jack_gpio); } return 0; }
static int h1940_uda1380_init(struct snd_soc_pcm_runtime *rtd) { snd_soc_card_jack_new(rtd->card, "Headphone Jack", SND_JACK_HEADPHONE, &hp_jack, hp_jack_pins, ARRAY_SIZE(hp_jack_pins)); snd_soc_jack_add_gpios(&hp_jack, ARRAY_SIZE(hp_jack_gpios), hp_jack_gpios); return 0; }
static int rk_init(struct snd_soc_pcm_runtime *runtime) { /* Enable Headset and 4 Buttons Jack detection */ return snd_soc_card_jack_new(runtime->card, "Headset Jack", SND_JACK_HEADSET | SND_JACK_BTN_0 | SND_JACK_BTN_1 | SND_JACK_BTN_2 | SND_JACK_BTN_3, &headset_jack, headset_jack_pins, ARRAY_SIZE(headset_jack_pins)); }
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_dai->component; /* 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_card_jack_new(card, "hook_switch", SND_JACK_HEADSET, &ams_delta_hook_switch, NULL, 0); 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 omap_twl4030_init(struct snd_soc_pcm_runtime *rtd) { struct snd_soc_codec *codec = rtd->codec; struct snd_soc_card *card = rtd->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_card_jack_new(rtd->card, "Headset Jack", SND_JACK_HEADSET, &priv->hs_jack, hs_jack_pins, ARRAY_SIZE(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_init_jack(struct snd_soc_card *card, struct asoc_simple_jack *sjack, int is_hp, char *prefix) { struct device *dev = card->dev; enum of_gpio_flags flags; char prop[128]; char *pin_name; char *gpio_name; int mask; int det; sjack->gpio.gpio = -ENOENT; if (is_hp) { snprintf(prop, sizeof(prop), "%shp-det-gpio", prefix); pin_name = "Headphones"; gpio_name = "Headphone detection"; mask = SND_JACK_HEADPHONE; } else { snprintf(prop, sizeof(prop), "%smic-det-gpio", prefix); pin_name = "Mic Jack"; gpio_name = "Mic detection"; mask = SND_JACK_MICROPHONE; } det = of_get_named_gpio_flags(dev->of_node, prop, 0, &flags); if (det == -EPROBE_DEFER) return -EPROBE_DEFER; if (gpio_is_valid(det)) { sjack->pin.pin = pin_name; sjack->pin.mask = mask; sjack->gpio.name = gpio_name; sjack->gpio.report = mask; sjack->gpio.gpio = det; sjack->gpio.invert = !!(flags & OF_GPIO_ACTIVE_LOW); sjack->gpio.debounce_time = 150; snd_soc_card_jack_new(card, pin_name, mask, &sjack->jack, &sjack->pin, 1); snd_soc_jack_add_gpios(&sjack->jack, 1, &sjack->gpio); } return 0; }
/* * Logic for a ak4641 as connected on a HP iPAQ hx4700 */ static int hx4700_ak4641_init(struct snd_soc_pcm_runtime *rtd) { int err; /* Jack detection API stuff */ err = snd_soc_card_jack_new(rtd->card, "Headphone Jack", SND_JACK_HEADPHONE, &hs_jack, hs_jack_pin, ARRAY_SIZE(hs_jack_pin)); if (err) return err; err = snd_soc_jack_add_gpios(&hs_jack, 1, &hs_jack_gpio); return err; }
static int skylake_rt286_codec_init(struct snd_soc_pcm_runtime *rtd) { struct snd_soc_codec *codec = rtd->codec; int ret; ret = snd_soc_card_jack_new(rtd->card, "Headset", SND_JACK_HEADSET | SND_JACK_BTN_0, &skylake_headset, skylake_headset_pins, ARRAY_SIZE(skylake_headset_pins)); if (ret) return ret; rt286_mic_detect(codec, &skylake_headset); return 0; }
static int sdm845_dai_init(struct snd_soc_pcm_runtime *rtd) { struct snd_soc_component *component; struct snd_soc_dai_link *dai_link = rtd->dai_link; struct snd_soc_card *card = rtd->card; struct sdm845_snd_data *pdata = snd_soc_card_get_drvdata(card); int i, rval; if (!pdata->jack_setup) { struct snd_jack *jack; rval = snd_soc_card_jack_new(card, "Headset Jack", SND_JACK_HEADSET | SND_JACK_HEADPHONE | SND_JACK_BTN_0 | SND_JACK_BTN_1 | SND_JACK_BTN_2 | SND_JACK_BTN_3, &pdata->jack, NULL, 0); if (rval < 0) { dev_err(card->dev, "Unable to add Headphone Jack\n"); return rval; } jack = pdata->jack.jack; snd_jack_set_key(jack, SND_JACK_BTN_0, KEY_PLAYPAUSE); snd_jack_set_key(jack, SND_JACK_BTN_1, KEY_VOICECOMMAND); snd_jack_set_key(jack, SND_JACK_BTN_2, KEY_VOLUMEUP); snd_jack_set_key(jack, SND_JACK_BTN_3, KEY_VOLUMEDOWN); pdata->jack_setup = true; } for (i = 0 ; i < dai_link->num_codecs; i++) { struct snd_soc_dai *dai = rtd->codec_dais[i]; component = dai->component; rval = snd_soc_component_set_jack( component, &pdata->jack, NULL); if (rval != 0 && rval != -ENOTSUPP) { dev_warn(card->dev, "Failed to set jack: %d\n", rval); return rval; } } return 0; }
static int mt8173_max98090_init(struct snd_soc_pcm_runtime *runtime) { int ret; struct snd_soc_card *card = runtime->card; struct snd_soc_codec *codec = runtime->codec; /* enable jack detection */ ret = snd_soc_card_jack_new(card, "Headphone", SND_JACK_HEADPHONE, &mt8173_max98090_jack, mt8173_max98090_jack_pins, ARRAY_SIZE(mt8173_max98090_jack_pins)); if (ret) { dev_err(card->dev, "Can't create a new Jack %d\n", ret); return ret; } return max98090_mic_detect(codec, &mt8173_max98090_jack); }
static int rk_98090_headset_init(struct snd_soc_component *component) { int ret; /* Enable Headset and 4 Buttons Jack detection */ ret = snd_soc_card_jack_new(&snd_soc_card_rk, "Headset Jack", SND_JACK_HEADSET | SND_JACK_BTN_0 | SND_JACK_BTN_1 | SND_JACK_BTN_2 | SND_JACK_BTN_3, &headset_jack, headset_jack_pins, ARRAY_SIZE(headset_jack_pins)); if (ret) return ret; ret = ts3a227e_enable_jack_detect(component, &headset_jack); 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); int err; 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_card_jack_new(rtd->card, "AV Jack", SND_JACK_HEADSET | SND_JACK_VIDEOOUT, &rx51_av_jack, NULL, 0); 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 tegra_rt5640_asoc_init(struct snd_soc_pcm_runtime *rtd) { struct tegra_rt5640 *machine = snd_soc_card_get_drvdata(rtd->card); snd_soc_card_jack_new(rtd->card, "Headphones", SND_JACK_HEADPHONE, &tegra_rt5640_hp_jack, tegra_rt5640_hp_jack_pins, ARRAY_SIZE(tegra_rt5640_hp_jack_pins)); if (gpio_is_valid(machine->gpio_hp_det)) { tegra_rt5640_hp_jack_gpio.gpio = machine->gpio_hp_det; tegra_rt5640_hp_jack_gpio.invert = !!(machine->gpio_hp_det_flags & OF_GPIO_ACTIVE_LOW); snd_soc_jack_add_gpios(&tegra_rt5640_hp_jack, 1, &tegra_rt5640_hp_jack_gpio); } return 0; }
/* * Logic for a wm8750 as connected on a Z2 Device */ static int z2_wm8750_init(struct snd_soc_pcm_runtime *rtd) { int ret; /* Jack detection API stuff */ ret = snd_soc_card_jack_new(rtd->card, "Headset Jack", SND_JACK_HEADSET, &hs_jack, hs_jack_pins, ARRAY_SIZE(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 rk_init(struct snd_soc_pcm_runtime *runtime) { struct snd_soc_card *card = runtime->card; int ret; /* Enable Headset and 4 Buttons Jack detection */ ret = snd_soc_card_jack_new(card, "Headset Jack", SND_JACK_HEADPHONE | SND_JACK_MICROPHONE | SND_JACK_BTN_0 | SND_JACK_BTN_1 | SND_JACK_BTN_2 | SND_JACK_BTN_3, &headset_jack, NULL, 0); if (ret) { dev_err(card->dev, "New Headset Jack failed! (%d)\n", ret); return ret; } return rt5645_set_jack_detect(runtime->codec_dai->component, &headset_jack, &headset_jack, &headset_jack); }
static int cz_init(struct snd_soc_pcm_runtime *rtd) { int ret; struct snd_soc_card *card; struct snd_soc_codec *codec; codec = rtd->codec; card = rtd->card; ret = snd_soc_card_jack_new(card, "Headset Jack", SND_JACK_HEADPHONE | SND_JACK_MICROPHONE | SND_JACK_BTN_0 | SND_JACK_BTN_1 | SND_JACK_BTN_2 | SND_JACK_BTN_3, &cz_jack, NULL, 0); if (ret) { dev_err(card->dev, "HP jack creation failed %d\n", ret); return ret; } rt5645_set_jack_detect(codec, &cz_jack, &cz_jack, &cz_jack); return 0; }
static int tegra_alc5632_asoc_init(struct snd_soc_pcm_runtime *rtd) { int ret; struct tegra_alc5632 *machine = snd_soc_card_get_drvdata(rtd->card); ret = snd_soc_card_jack_new(rtd->card, "Headset Jack", SND_JACK_HEADSET, &tegra_alc5632_hs_jack, tegra_alc5632_hs_jack_pins, ARRAY_SIZE(tegra_alc5632_hs_jack_pins)); if (ret) return ret; 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); } snd_soc_dapm_force_enable_pin(&rtd->card->dapm, "MICBIAS1"); return 0; }
static int cht_codec_init(struct snd_soc_pcm_runtime *runtime) { struct snd_soc_card *card = runtime->card; struct cht_mc_private *ctx = snd_soc_card_get_drvdata(runtime->card); struct snd_soc_component *component = runtime->codec_dai->component; int jack_type; int ret; if ((cht_rt5645_quirk & CHT_RT5645_SSP2_AIF2) || (cht_rt5645_quirk & CHT_RT5645_SSP0_AIF2)) { /* Select clk_i2s2_asrc as ASRC clock source */ rt5645_sel_asrc_clk_src(component, RT5645_DA_STEREO_FILTER | RT5645_DA_MONO_L_FILTER | RT5645_DA_MONO_R_FILTER | RT5645_AD_STEREO_FILTER, RT5645_CLK_SEL_I2S2_ASRC); } else { /* Select clk_i2s1_asrc as ASRC clock source */ rt5645_sel_asrc_clk_src(component, RT5645_DA_STEREO_FILTER | RT5645_DA_MONO_L_FILTER | RT5645_DA_MONO_R_FILTER | RT5645_AD_STEREO_FILTER, RT5645_CLK_SEL_I2S1_ASRC); } if (cht_rt5645_quirk & CHT_RT5645_SSP2_AIF2) { ret = snd_soc_dapm_add_routes(&card->dapm, cht_rt5645_ssp2_aif2_map, ARRAY_SIZE(cht_rt5645_ssp2_aif2_map)); } else if (cht_rt5645_quirk & CHT_RT5645_SSP0_AIF1) { ret = snd_soc_dapm_add_routes(&card->dapm, cht_rt5645_ssp0_aif1_map, ARRAY_SIZE(cht_rt5645_ssp0_aif1_map)); } else if (cht_rt5645_quirk & CHT_RT5645_SSP0_AIF2) { ret = snd_soc_dapm_add_routes(&card->dapm, cht_rt5645_ssp0_aif2_map, ARRAY_SIZE(cht_rt5645_ssp0_aif2_map)); } else { ret = snd_soc_dapm_add_routes(&card->dapm, cht_rt5645_ssp2_aif1_map, ARRAY_SIZE(cht_rt5645_ssp2_aif1_map)); } if (ret) return ret; if (ctx->acpi_card->codec_type == CODEC_TYPE_RT5650) jack_type = SND_JACK_HEADPHONE | SND_JACK_MICROPHONE | SND_JACK_BTN_0 | SND_JACK_BTN_1 | SND_JACK_BTN_2 | SND_JACK_BTN_3; else jack_type = SND_JACK_HEADPHONE | SND_JACK_MICROPHONE; ret = snd_soc_card_jack_new(runtime->card, "Headset", jack_type, &ctx->jack, cht_bsw_jack_pins, ARRAY_SIZE(cht_bsw_jack_pins)); if (ret) { dev_err(runtime->dev, "Headset jack creation failed %d\n", ret); return ret; } rt5645_set_jack_detect(component, &ctx->jack, &ctx->jack, &ctx->jack); /* * The firmware might enable the clock at * boot (this information may or may not * be reflected in the enable clock register). * To change the rate we must disable the clock * first to cover these cases. Due to common * clock framework restrictions that do not allow * to disable a clock that has not been enabled, * we need to enable the clock first. */ ret = clk_prepare_enable(ctx->mclk); if (!ret) clk_disable_unprepare(ctx->mclk); ret = clk_set_rate(ctx->mclk, CHT_PLAT_CLK_3_HZ); if (ret) dev_err(runtime->dev, "unable to set MCLK rate\n"); return ret; }
static int apq8016_sbc_dai_init(struct snd_soc_pcm_runtime *rtd) { struct snd_soc_dai *cpu_dai = rtd->cpu_dai; struct snd_soc_component *component; struct snd_soc_dai_link *dai_link = rtd->dai_link; struct snd_soc_card *card = rtd->card; struct apq8016_sbc_data *pdata = snd_soc_card_get_drvdata(card); int i, rval; switch (cpu_dai->id) { case MI2S_PRIMARY: writel(readl(pdata->spkr_iomux) | SPKR_CTL_PRI_WS_SLAVE_SEL_11, pdata->spkr_iomux); break; case MI2S_QUATERNARY: /* Configure the Quat MI2S to TLMM */ writel(readl(pdata->mic_iomux) | MIC_CTRL_QUA_WS_SLAVE_SEL_10 | MIC_CTRL_TLMM_SCLK_EN, pdata->mic_iomux); break; case MI2S_TERTIARY: writel(readl(pdata->mic_iomux) | MIC_CTRL_TER_WS_SLAVE_SEL | MIC_CTRL_TLMM_SCLK_EN, pdata->mic_iomux); break; default: dev_err(card->dev, "unsupported cpu dai configuration\n"); return -EINVAL; } if (!pdata->jack_setup) { struct snd_jack *jack; rval = snd_soc_card_jack_new(card, "Headset Jack", SND_JACK_HEADSET | SND_JACK_HEADPHONE | SND_JACK_BTN_0 | SND_JACK_BTN_1 | SND_JACK_BTN_2 | SND_JACK_BTN_3 | SND_JACK_BTN_4, &pdata->jack, NULL, 0); if (rval < 0) { dev_err(card->dev, "Unable to add Headphone Jack\n"); return rval; } jack = pdata->jack.jack; snd_jack_set_key(jack, SND_JACK_BTN_0, KEY_PLAYPAUSE); snd_jack_set_key(jack, SND_JACK_BTN_1, KEY_VOICECOMMAND); snd_jack_set_key(jack, SND_JACK_BTN_2, KEY_VOLUMEUP); snd_jack_set_key(jack, SND_JACK_BTN_3, KEY_VOLUMEDOWN); pdata->jack_setup = true; } for (i = 0 ; i < dai_link->num_codecs; i++) { struct snd_soc_dai *dai = rtd->codec_dais[i]; component = dai->component; /* Set default mclk for internal codec */ rval = snd_soc_component_set_sysclk(component, 0, 0, DEFAULT_MCLK_RATE, SND_SOC_CLOCK_IN); if (rval != 0 && rval != -ENOTSUPP) { dev_warn(card->dev, "Failed to set mclk: %d\n", rval); return rval; } rval = snd_soc_component_set_jack(component, &pdata->jack, NULL); if (rval != 0 && rval != -ENOTSUPP) { dev_warn(card->dev, "Failed to set jack: %d\n", rval); return rval; } } return 0; }
static int byt_rt5651_init(struct snd_soc_pcm_runtime *runtime) { struct snd_soc_card *card = runtime->card; struct snd_soc_component *codec = runtime->codec_dai->component; struct byt_rt5651_private *priv = snd_soc_card_get_drvdata(card); const struct snd_soc_dapm_route *custom_map; int num_routes; int ret; card->dapm.idle_bias_off = true; /* Start with RC clk for jack-detect (we disable MCLK below) */ if (byt_rt5651_quirk & BYT_RT5651_MCLK_EN) snd_soc_component_update_bits(codec, RT5651_GLB_CLK, RT5651_SCLK_SRC_MASK, RT5651_SCLK_SRC_RCCLK); switch (BYT_RT5651_MAP(byt_rt5651_quirk)) { case BYT_RT5651_IN1_MAP: custom_map = byt_rt5651_intmic_in1_map; num_routes = ARRAY_SIZE(byt_rt5651_intmic_in1_map); break; case BYT_RT5651_IN2_MAP: custom_map = byt_rt5651_intmic_in2_map; num_routes = ARRAY_SIZE(byt_rt5651_intmic_in2_map); break; case BYT_RT5651_IN1_IN2_MAP: custom_map = byt_rt5651_intmic_in1_in2_map; num_routes = ARRAY_SIZE(byt_rt5651_intmic_in1_in2_map); break; default: custom_map = byt_rt5651_intmic_dmic_map; num_routes = ARRAY_SIZE(byt_rt5651_intmic_dmic_map); } ret = snd_soc_dapm_add_routes(&card->dapm, custom_map, num_routes); if (ret) return ret; if (byt_rt5651_quirk & BYT_RT5651_SSP2_AIF2) { ret = snd_soc_dapm_add_routes(&card->dapm, byt_rt5651_ssp2_aif2_map, ARRAY_SIZE(byt_rt5651_ssp2_aif2_map)); } else if (byt_rt5651_quirk & BYT_RT5651_SSP0_AIF1) { ret = snd_soc_dapm_add_routes(&card->dapm, byt_rt5651_ssp0_aif1_map, ARRAY_SIZE(byt_rt5651_ssp0_aif1_map)); } else if (byt_rt5651_quirk & BYT_RT5651_SSP0_AIF2) { ret = snd_soc_dapm_add_routes(&card->dapm, byt_rt5651_ssp0_aif2_map, ARRAY_SIZE(byt_rt5651_ssp0_aif2_map)); } else { ret = snd_soc_dapm_add_routes(&card->dapm, byt_rt5651_ssp2_aif1_map, ARRAY_SIZE(byt_rt5651_ssp2_aif1_map)); } if (ret) return ret; ret = snd_soc_add_card_controls(card, byt_rt5651_controls, ARRAY_SIZE(byt_rt5651_controls)); if (ret) { dev_err(card->dev, "unable to add card controls\n"); return ret; } snd_soc_dapm_ignore_suspend(&card->dapm, "Headphone"); snd_soc_dapm_ignore_suspend(&card->dapm, "Speaker"); if (byt_rt5651_quirk & BYT_RT5651_MCLK_EN) { /* * The firmware might enable the clock at * boot (this information may or may not * be reflected in the enable clock register). * To change the rate we must disable the clock * first to cover these cases. Due to common * clock framework restrictions that do not allow * to disable a clock that has not been enabled, * we need to enable the clock first. */ ret = clk_prepare_enable(priv->mclk); if (!ret) clk_disable_unprepare(priv->mclk); if (byt_rt5651_quirk & BYT_RT5651_MCLK_25MHZ) ret = clk_set_rate(priv->mclk, 25000000); else ret = clk_set_rate(priv->mclk, 19200000); if (ret) dev_err(card->dev, "unable to set MCLK rate\n"); } if (BYT_RT5651_JDSRC(byt_rt5651_quirk)) { ret = snd_soc_card_jack_new(runtime->card, "Headset", SND_JACK_HEADSET | SND_JACK_BTN_0, &priv->jack, bytcr_jack_pins, ARRAY_SIZE(bytcr_jack_pins)); if (ret) { dev_err(runtime->dev, "jack creation failed %d\n", ret); return ret; } snd_jack_set_key(priv->jack.jack, SND_JACK_BTN_0, KEY_PLAYPAUSE); ret = snd_soc_component_set_jack(codec, &priv->jack, NULL); if (ret) return ret; } return 0; }