int ctp_vb_init(struct snd_soc_pcm_runtime *runtime)
{
struct snd_soc_codec *codec = runtime->codec;
struct snd_soc_dapm_context *dapm = &codec->dapm;
int ret;
struct snd_soc_card *card = runtime->card;
struct ctp_mc_private *ctx = snd_soc_card_get_drvdata(runtime->card);
ret = snd_soc_add_card_controls(card, ctp_vb_snd_controls,
ARRAY_SIZE(ctp_vb_snd_controls));
if (ret) {
pr_err("soc_add_controls failed %d", ret);
return ret;
}
/* Set codec bias level */
ctp_set_bias_level(card, dapm, SND_SOC_BIAS_OFF);
card->dapm.idle_bias_off = true;
/* Add Jack specific widgets */
ret = snd_soc_dapm_new_controls(dapm, ctp_vb_dapm_widgets,
ARRAY_SIZE(ctp_vb_dapm_widgets));
if (ret)
return ret;
/* Set up Jack specific audio path audio_map */
snd_soc_dapm_add_routes(dapm, ctp_vb_audio_map,
ARRAY_SIZE(ctp_vb_audio_map));
/* Add Comms specefic controls */
ctx->comms_ctl.ssp_bt_sco_master_mode = false;
ctx->comms_ctl.ssp_voip_master_mode = false;
ctx->comms_ctl.ssp_modem_master_mode = false;
ret = snd_soc_add_card_controls(card, ssp_comms_controls,
ARRAY_SIZE(ssp_comms_controls));
if (ret) {
pr_err("Add Comms Controls failed %d",
ret);
return ret;
}
/* Keep the voice call paths active during
suspend. Mark the end points ignore_suspend */
snd_soc_dapm_ignore_suspend(dapm, "EAROUT");
snd_soc_dapm_ignore_suspend(dapm, "Ext Spk");
snd_soc_dapm_ignore_suspend(dapm, "Headphone");
snd_soc_dapm_ignore_suspend(dapm, "Headset Mic");
snd_soc_dapm_ignore_suspend(dapm, "DMICA");
snd_soc_dapm_ignore_suspend(dapm, "DMICB");
snd_soc_dapm_disable_pin(dapm, "MIC2");
snd_soc_dapm_disable_pin(dapm, "SPKLINEOUT");
mutex_lock(&codec->mutex);
snd_soc_dapm_sync(dapm);
mutex_unlock(&codec->mutex);
return ret;
}
static int neo1973_gta02_wm8753_init(struct snd_soc_codec *codec)
{
struct snd_soc_dapm_context *dapm = &codec->dapm;
int ret;
ret = snd_soc_dapm_new_controls(dapm, neo1973_gta02_wm8753_dapm_widgets,
ARRAY_SIZE(neo1973_gta02_wm8753_dapm_widgets));
if (ret)
return ret;
ret = snd_soc_dapm_add_routes(dapm, neo1973_gta02_routes,
ARRAY_SIZE(neo1973_gta02_routes));
if (ret)
return ret;
ret = snd_soc_add_card_controls(codec->card, neo1973_gta02_wm8753_controls,
ARRAY_SIZE(neo1973_gta02_wm8753_controls));
if (ret)
return ret;
snd_soc_dapm_disable_pin(dapm, "Stereo Out");
snd_soc_dapm_disable_pin(dapm, "Handset Spk");
snd_soc_dapm_ignore_suspend(dapm, "Stereo Out");
snd_soc_dapm_ignore_suspend(dapm, "Handset Spk");
return 0;
}
static int byt_rt5640_init(struct snd_soc_pcm_runtime *runtime)
{
int ret;
struct snd_soc_codec *codec = runtime->codec;
struct snd_soc_dapm_context *dapm = &codec->dapm;
struct snd_soc_card *card = runtime->card;
card->dapm.idle_bias_off = true;
ret = snd_soc_add_card_controls(card, byt_rt5640_controls,
ARRAY_SIZE(byt_rt5640_controls));
if (ret) {
dev_err(card->dev, "unable to add card controls\n");
return ret;
}
snd_soc_dapm_ignore_suspend(dapm, "HPOL");
snd_soc_dapm_ignore_suspend(dapm, "HPOR");
snd_soc_dapm_ignore_suspend(dapm, "SPOLP");
snd_soc_dapm_ignore_suspend(dapm, "SPOLN");
snd_soc_dapm_ignore_suspend(dapm, "SPORP");
snd_soc_dapm_ignore_suspend(dapm, "SPORN");
return ret;
}
static int byt_rt5651_init(struct snd_soc_pcm_runtime *runtime)
{
int ret;
struct snd_soc_card *card = runtime->card;
const struct snd_soc_dapm_route *custom_map;
int num_routes;
card->dapm.idle_bias_off = true;
dmi_check_system(byt_rt5651_quirk_table);
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_DMIC2_MAP:
custom_map = byt_rt5651_intmic_dmic2_map;
num_routes = ARRAY_SIZE(byt_rt5651_intmic_dmic2_map);
break;
default:
custom_map = byt_rt5651_intmic_dmic1_map;
num_routes = ARRAY_SIZE(byt_rt5651_intmic_dmic1_map);
}
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");
return ret;
}
void simtec_audio_init(struct snd_soc_pcm_runtime *rtd)
{
struct snd_soc_card *card = rtd->card;
if (pdata->amp_gpio > 0) {
pr_debug("%s: adding amp routes\n", __func__);
snd_soc_add_card_controls(card, amp_unmute_controls,
ARRAY_SIZE(amp_unmute_controls));
}
if (pdata->amp_gain[0] > 0) {
pr_debug("%s: adding amp controls\n", __func__);
snd_soc_add_card_controls(card, amp_gain_controls,
ARRAY_SIZE(amp_gain_controls));
}
}
static int byt_rt5640_init(struct snd_soc_pcm_runtime *runtime)
{
int ret;
struct snd_soc_codec *codec = runtime->codec;
struct snd_soc_dapm_context *dapm = &codec->dapm;
struct snd_soc_card *card = runtime->card;
const struct snd_soc_dapm_route *custom_map;
int num_routes;
card->dapm.idle_bias_off = true;
ret = snd_soc_add_card_controls(card, byt_rt5640_controls,
ARRAY_SIZE(byt_rt5640_controls));
if (ret) {
dev_err(card->dev, "unable to add card controls\n");
return ret;
}
dmi_check_system(byt_rt5640_quirk_table);
switch (BYT_RT5640_MAP(byt_rt5640_quirk)) {
case BYT_RT5640_IN1_MAP:
custom_map = byt_rt5640_intmic_in1_map;
num_routes = ARRAY_SIZE(byt_rt5640_intmic_in1_map);
break;
case BYT_RT5640_DMIC2_MAP:
custom_map = byt_rt5640_intmic_dmic2_map;
num_routes = ARRAY_SIZE(byt_rt5640_intmic_dmic2_map);
break;
default:
custom_map = byt_rt5640_intmic_dmic1_map;
num_routes = ARRAY_SIZE(byt_rt5640_intmic_dmic1_map);
}
ret = snd_soc_dapm_add_routes(dapm, custom_map, num_routes);
if (ret)
return ret;
if (byt_rt5640_quirk & BYT_RT5640_DMIC_EN) {
ret = rt5640_dmic_enable(codec, 0, 0);
if (ret)
return ret;
}
snd_soc_dapm_ignore_suspend(dapm, "HPOL");
snd_soc_dapm_ignore_suspend(dapm, "HPOR");
snd_soc_dapm_ignore_suspend(dapm, "SPOLP");
snd_soc_dapm_ignore_suspend(dapm, "SPOLN");
snd_soc_dapm_ignore_suspend(dapm, "SPORP");
snd_soc_dapm_ignore_suspend(dapm, "SPORN");
return ret;
}
static int neo1973_wm8753_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_nc_pin(dapm, "OUT3");
snd_soc_dapm_nc_pin(dapm, "OUT4");
snd_soc_dapm_nc_pin(dapm, "LINE1");
snd_soc_dapm_nc_pin(dapm, "LINE2");
/* */
ret = snd_soc_dapm_new_controls(dapm, neo1973_wm8753_dapm_widgets,
ARRAY_SIZE(neo1973_wm8753_dapm_widgets));
if (ret)
return ret;
/* */
ret = snd_soc_add_card_controls(rtd->card, neo1973_wm8753_controls,
ARRAY_SIZE(neo1973_wm8753_controls));
if (ret)
return ret;
/* */
ret = snd_soc_dapm_add_routes(dapm, neo1973_wm8753_routes,
ARRAY_SIZE(neo1973_wm8753_routes));
if (ret)
return ret;
/* */
snd_soc_dapm_disable_pin(dapm, "GSM Line Out");
snd_soc_dapm_disable_pin(dapm, "GSM Line In");
snd_soc_dapm_disable_pin(dapm, "Headset Mic");
snd_soc_dapm_disable_pin(dapm, "Handset Mic");
/* */
snd_soc_dapm_ignore_suspend(dapm, "GSM Line Out");
snd_soc_dapm_ignore_suspend(dapm, "GSM Line In");
snd_soc_dapm_ignore_suspend(dapm, "Headset Mic");
snd_soc_dapm_ignore_suspend(dapm, "Handset Mic");
if (machine_is_neo1973_gta02()) {
ret = neo1973_gta02_wm8753_init(codec);
if (ret)
return ret;
}
return 0;
}
static int rx51_aic34b_init(struct snd_soc_dapm_context *dapm)
{
int err;
err = snd_soc_add_card_controls(dapm->card, aic34_rx51_controlsb,
ARRAY_SIZE(aic34_rx51_controlsb));
if (err < 0)
return err;
err = snd_soc_dapm_new_controls(dapm, aic34_dapm_widgetsb,
ARRAY_SIZE(aic34_dapm_widgetsb));
if (err < 0)
return 0;
return snd_soc_dapm_add_routes(dapm, audio_mapb,
ARRAY_SIZE(audio_mapb));
}
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_card_controls(rtd->card, 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(rtd);
if (err < 0)
return err;
/* AV jack detection */
err = snd_soc_jack_new(codec, "AV Jack",
SND_JACK_HEADSET | SND_JACK_VIDEOOUT,
0, &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 tegra_wm8753_init(struct snd_soc_pcm_runtime *rtd)
{
struct snd_soc_codec *codec = rtd->codec;
struct snd_soc_dapm_context *dapm = &codec->dapm;
struct snd_soc_card *card = codec->card;
struct tegra_wm8753 *machine = snd_soc_card_get_drvdata(card);
struct tegra_asoc_platform_data *pdata = machine->pdata;
int ret;
if (machine_is_whistler()) {
machine->audio_reg = regulator_get(NULL, "avddio_audio");
if (IS_ERR(machine->audio_reg)) {
dev_err(card->dev, "cannot get avddio_audio reg\n");
ret = PTR_ERR(machine->audio_reg);
return ret;
}
ret = regulator_enable(machine->audio_reg);
if (ret) {
dev_err(card->dev, "cannot enable avddio_audio reg\n");
regulator_put(machine->audio_reg);
machine->audio_reg = NULL;
return ret;
}
}
if (gpio_is_valid(pdata->gpio_spkr_en)) {
ret = gpio_request(pdata->gpio_spkr_en, "spkr_en");
if (ret) {
dev_err(card->dev, "cannot get spkr_en gpio\n");
return ret;
}
machine->gpio_requested |= GPIO_SPKR_EN;
gpio_direction_output(pdata->gpio_spkr_en, 0);
}
if (gpio_is_valid(pdata->gpio_hp_mute)) {
ret = gpio_request(pdata->gpio_hp_mute, "hp_mute");
if (ret) {
dev_err(card->dev, "cannot get hp_mute gpio\n");
return ret;
}
machine->gpio_requested |= GPIO_HP_MUTE;
gpio_direction_output(pdata->gpio_hp_mute, 0);
}
if (gpio_is_valid(pdata->gpio_int_mic_en)) {
ret = gpio_request(pdata->gpio_int_mic_en, "int_mic_en");
if (ret) {
dev_err(card->dev, "cannot get int_mic_en gpio\n");
return ret;
}
machine->gpio_requested |= GPIO_INT_MIC_EN;
/* Disable int mic; enable signal is active-high */
gpio_direction_output(pdata->gpio_int_mic_en, 0);
}
if (gpio_is_valid(pdata->gpio_ext_mic_en)) {
ret = gpio_request(pdata->gpio_ext_mic_en, "ext_mic_en");
if (ret) {
dev_err(card->dev, "cannot get ext_mic_en gpio\n");
return ret;
}
machine->gpio_requested |= GPIO_EXT_MIC_EN;
/* Enable ext mic; enable signal is active-low */
gpio_direction_output(pdata->gpio_ext_mic_en, 0);
}
ret = snd_soc_add_card_controls(card, tegra_wm8753_controls,
ARRAY_SIZE(tegra_wm8753_controls));
if (ret < 0)
return ret;
snd_soc_dapm_new_controls(dapm, tegra_wm8753_dapm_widgets,
ARRAY_SIZE(tegra_wm8753_dapm_widgets));
snd_soc_dapm_add_routes(dapm, whistler_audio_map,
ARRAY_SIZE(whistler_audio_map));
snd_soc_jack_new(codec, "Headphone Jack", SND_JACK_HEADPHONE,
&tegra_wm8753_hp_jack);
wm8753_headphone_detect(codec, &tegra_wm8753_hp_jack,
SND_JACK_HEADPHONE, pdata->debounce_time_hp);
#ifdef CONFIG_SWITCH
snd_soc_jack_notifier_register(&tegra_wm8753_hp_jack,
&headset_switch_nb);
#else
snd_soc_jack_add_pins(&tegra_wm8753_hp_jack,
ARRAY_SIZE(tegra_wm8753_hp_jack_pins),
tegra_wm8753_hp_jack_pins);
#endif
/* Add call mode switch control */
ret = snd_ctl_add(codec->card->snd_card,
snd_ctl_new1(&tegra_call_mode_control, machine));
if (ret < 0)
return ret;
ret = tegra_asoc_utils_register_ctls(&machine->util_data);
if (ret < 0)
return ret;
snd_soc_dapm_nc_pin(dapm, "ACIN");
snd_soc_dapm_nc_pin(dapm, "ACOP");
snd_soc_dapm_nc_pin(dapm, "OUT3");
snd_soc_dapm_nc_pin(dapm, "OUT4");
snd_soc_dapm_sync(dapm);
return 0;
}
static int tegra_max98095_init(struct snd_soc_pcm_runtime *rtd)
{
struct snd_soc_codec *codec = rtd->codec;
struct snd_soc_dapm_context *dapm = &codec->dapm;
struct snd_soc_card *card = codec->card;
struct tegra_max98095 *machine = snd_soc_card_get_drvdata(card);
struct tegra_asoc_platform_data *pdata = machine->pdata;
#ifndef CONFIG_ARCH_TEGRA_2x_SOC
struct tegra30_i2s *i2s = snd_soc_dai_get_drvdata(rtd->cpu_dai);
#endif
int ret;
#ifndef CONFIG_ARCH_TEGRA_2x_SOC
if (machine->codec_info[BASEBAND].i2s_id != -1)
i2s->is_dam_used = true;
#endif
if (machine->init_done)
return 0;
machine->init_done = true;
if (gpio_is_valid(pdata->gpio_spkr_en)) {
ret = gpio_request(pdata->gpio_spkr_en, "spkr_en");
if (ret) {
dev_err(card->dev, "cannot get spkr_en gpio\n");
return ret;
}
machine->gpio_requested |= GPIO_SPKR_EN;
gpio_direction_output(pdata->gpio_spkr_en, 0);
}
if (gpio_is_valid(pdata->gpio_hp_mute)) {
ret = gpio_request(pdata->gpio_hp_mute, "hp_mute");
if (ret) {
dev_err(card->dev, "cannot get hp_mute gpio\n");
return ret;
}
machine->gpio_requested |= GPIO_HP_MUTE;
gpio_direction_output(pdata->gpio_hp_mute, 0);
}
if (gpio_is_valid(pdata->gpio_int_mic_en)) {
ret = gpio_request(pdata->gpio_int_mic_en, "int_mic_en");
if (ret) {
dev_err(card->dev, "cannot get int_mic_en gpio\n");
return ret;
}
machine->gpio_requested |= GPIO_INT_MIC_EN;
/* Disable int mic; enable signal is active-high */
gpio_direction_output(pdata->gpio_int_mic_en, 0);
}
if (gpio_is_valid(pdata->gpio_ext_mic_en)) {
ret = gpio_request(pdata->gpio_ext_mic_en, "ext_mic_en");
if (ret) {
dev_err(card->dev, "cannot get ext_mic_en gpio\n");
return ret;
}
machine->gpio_requested |= GPIO_EXT_MIC_EN;
/* Enable ext mic; enable signal is active-low */
gpio_direction_output(pdata->gpio_ext_mic_en, 0);
}
ret = snd_soc_add_card_controls(card, tegra_max98095_controls,
ARRAY_SIZE(tegra_max98095_controls));
if (ret < 0)
return ret;
snd_soc_dapm_new_controls(dapm, tegra_max98095_dapm_widgets,
ARRAY_SIZE(tegra_max98095_dapm_widgets));
snd_soc_dapm_add_routes(dapm, enterprise_audio_map,
ARRAY_SIZE(enterprise_audio_map));
ret = snd_soc_jack_new(codec, "Headset Jack", SND_JACK_HEADSET,
&tegra_max98095_hp_jack);
if (ret < 0)
return ret;
#ifdef CONFIG_SWITCH
snd_soc_jack_notifier_register(&tegra_max98095_hp_jack,
&headset_switch_nb);
#else /*gpio based headset detection*/
snd_soc_jack_add_pins(&tegra_max98095_hp_jack,
ARRAY_SIZE(tegra_max98095_hp_jack_pins),
tegra_max98095_hp_jack_pins);
#endif
ret = tegra_asoc_utils_register_ctls(&machine->util_data);
if (ret < 0)
return ret;
/* max98095_headset_detect(codec, &tegra_max98095_hp_jack,
SND_JACK_HEADSET); */
snd_soc_dapm_nc_pin(dapm, "INA1");
snd_soc_dapm_nc_pin(dapm, "INA2");
snd_soc_dapm_nc_pin(dapm, "INB1");
snd_soc_dapm_nc_pin(dapm, "INB2");
snd_soc_dapm_sync(dapm);
return 0;
}
static int ctp_wm5102_init(struct snd_soc_pcm_runtime *runtime)
{
int ret;
struct snd_soc_card *card = runtime->card;
struct ctp_mc_private *ctx = snd_soc_card_get_drvdata(runtime->card);
struct snd_soc_codec *codec;
struct snd_soc_dapm_context *dapm;
codec = ctp_get_codec(card, "wm5102-codec");
if (!codec)
return -EIO;
dapm = &codec->dapm;
/* Set codec bias level */
ctp_set_bias_level(card, dapm, SND_SOC_BIAS_OFF);
card->dapm.idle_bias_off = true;
/* Disable MICBIAS3 bypass mode and set CAP mode.
* Capacitors are connected to DMIC on 1525-EV1 board */
snd_soc_update_bits(codec, ARIZONA_MIC_BIAS_CTRL_3,
ARIZONA_MICB1_BYPASS_MASK | ARIZONA_MICB1_EXT_CAP_MASK,
ARIZONA_MICB1_EXT_CAP);
/* Set codec clock */
ret = snd_soc_codec_set_sysclk(codec, ARIZONA_CLK_SYSCLK,
ARIZONA_CLK_SRC_FLL1,
SYSCLK_RATE,
SND_SOC_CLOCK_IN);
if (ret != 0) {
pr_err("failed: %d\n", ret);
return ret;
}
/* Add Jack specific widgets */
ret = snd_soc_dapm_new_controls(dapm, ctp_dapm_widgets,
ARRAY_SIZE(ctp_dapm_widgets));
if (ret)
return ret;
/* Set up Jack specific audio path audio_map */
snd_soc_dapm_add_routes(dapm, ctp_audio_map,
ARRAY_SIZE(ctp_audio_map));
/* Add Comms specefic controls */
ctx->comms_ctl.ssp_bt_sco_master_mode = false;
ctx->comms_ctl.ssp_voip_master_mode = false;
ctx->comms_ctl.ssp_modem_master_mode = false;
ret = snd_soc_add_card_controls(card, ssp_comms_controls,
ARRAY_SIZE(ssp_comms_controls));
if (ret) {
pr_err("Add Comms Controls failed %d",
ret);
return ret;
}
/* Keep the voice call paths active during
suspend. Mark the end points ignore_suspend */
snd_soc_dapm_ignore_suspend(dapm, "HPOUT1R");
snd_soc_dapm_ignore_suspend(dapm, "HPOUT1L");
snd_soc_dapm_disable_pin(dapm, "MICBIAS1");
snd_soc_dapm_disable_pin(dapm, "SPKOUTLP");
snd_soc_dapm_disable_pin(dapm, "SPKOUTLN");
snd_soc_dapm_ignore_suspend(dapm, "SPKOUTRP");
snd_soc_dapm_ignore_suspend(dapm, "SPKOUTRN");
mutex_lock(&codec->mutex);
snd_soc_dapm_sync(dapm);
mutex_unlock(&codec->mutex);
return ret;
}
int ctp_init(struct snd_soc_pcm_runtime *runtime)
{
int ret;
struct snd_soc_codec *codec = runtime->codec;
struct snd_soc_dapm_context *dapm = &codec->dapm;
struct snd_soc_card *card = runtime->card;
struct ctp_mc_private *ctx = snd_soc_card_get_drvdata(runtime->card);
//#ifndef UART_DEBUG
// static int hp_enable;
//#endif
pr_debug("%s\n", __func__);
/* Set codec bias level */
ctp_set_bias_level(card, dapm, SND_SOC_BIAS_OFF);
card->dapm.idle_bias_off = true;
/* Add Jack specific widgets */
ret = snd_soc_dapm_new_controls(dapm, ctp_dapm_widgets,
ARRAY_SIZE(ctp_dapm_widgets));
if (ret)
return ret;
/* Set up Jack specific audio path audio_map */
snd_soc_dapm_add_routes(dapm, ctp_audio_map,
ARRAY_SIZE(ctp_audio_map));
/* Add Comms specefic controls */
ctx->comms_ctl.ssp_bt_sco_master_mode = false;
/* Set ssp_voip to master mode by default */
#if 0
ctx->comms_ctl.ssp_voip_master_mode = false;
#else
ctx->comms_ctl.ssp_voip_master_mode = true;
pr_debug("ctp_init ssp_voip_master_mode %d\n",
ctx->comms_ctl.ssp_voip_master_mode);
#endif
ctx->comms_ctl.ssp_modem_master_mode = false;
ret = snd_soc_add_card_controls(card, ssp_comms_controls,
ARRAY_SIZE(ssp_comms_controls));
if (ret) {
pr_err("Add Comms Controls failed %d",
ret);
return ret;
}
/* Keep the voice call paths active during
suspend. Mark the end points ignore_suspend */
snd_soc_dapm_ignore_suspend(dapm, "HPOL");
snd_soc_dapm_ignore_suspend(dapm, "HPOR");
snd_soc_dapm_ignore_suspend(dapm, "SPOL");
snd_soc_dapm_ignore_suspend(dapm, "SPOR");
snd_soc_dapm_ignore_suspend(dapm, "AIF2 Playback");
snd_soc_dapm_ignore_suspend(dapm, "AIF2 Capture");
snd_soc_dapm_ignore_suspend(dapm, "AIF2TX");
snd_soc_dapm_ignore_suspend(dapm, "AIF2RX");
snd_soc_dapm_ignore_suspend(dapm, "MonoP");
snd_soc_dapm_ignore_suspend(dapm, "MonoN");
snd_soc_dapm_ignore_suspend(dapm, "Headset Mic");
snd_soc_dapm_ignore_suspend(dapm, "Headphone");
snd_soc_dapm_ignore_suspend(dapm, "Ext Spk");
snd_soc_dapm_ignore_suspend(dapm, "Int Mic");
snd_soc_dapm_ignore_suspend(dapm, "Receiver");
snd_soc_dapm_ignore_suspend(dapm, "DMIC L2");
snd_soc_dapm_ignore_suspend(dapm, "DMIC R2");
snd_soc_dapm_ignore_suspend(dapm, "IN1P");
snd_soc_dapm_ignore_suspend(dapm, "IN1N");
snd_soc_dapm_ignore_suspend(dapm, "IN2P");
snd_soc_dapm_ignore_suspend(dapm, "IN2N");
snd_soc_dapm_enable_pin(dapm, "Headset Mic");
snd_soc_dapm_enable_pin(dapm, "Headphone");
snd_soc_dapm_enable_pin(dapm, "Ext Spk");
snd_soc_dapm_enable_pin(dapm, "Int Mic");
snd_soc_dapm_enable_pin(dapm, "Receiver");
mutex_lock(&codec->mutex);
snd_soc_dapm_sync(dapm);
mutex_unlock(&codec->mutex);
/*Register switch Control as misc driver*/
ret = misc_register(&switch_ctrl);
if (ret)
pr_err("%s: couldn't register control device\n",
__func__);
rt5647_codec = codec;
//#ifndef UART_DEBUG
// /* use hard-coded GPIO value before IFWI ready */
// /* hp_enable = get_gpio_by_name("AUDIO_DEBUG"); */
// hp_enable = 172;
// if (hp_enable > 0) {
// pr_info("Get AUDIO_DEBUG name!\n");
// ret = gpio_request_one(hp_enable, GPIOF_DIR_OUT, "AUDIO_DEBUG");
// if (ret)
// pr_err("gpio_request AUDIO_DEBUG failed!\n");
//
// /*Set GPIO O(H) to default => Low:UART; High:headset */
// gpio_direction_output(hp_enable, 1);
// pr_info("AUDIO_DEBUG value = %d\n", gpio_get_value(hp_enable));
// } else
// pr_err("get_gpio AUDIO_DEBUG failed!\n");
//#endif
return ret;
}
int mop500_ab8500_machine_init(struct snd_soc_pcm_runtime *rtd)
{
struct snd_soc_codec *codec = rtd->codec;
struct device *dev = rtd->card->dev;
struct mop500_ab8500_drvdata *drvdata;
int ret;
dev_dbg(dev, "%s Enter.\n", __func__);
/* Create driver private-data struct */
drvdata = devm_kzalloc(dev, sizeof(struct mop500_ab8500_drvdata),
GFP_KERNEL);
snd_soc_card_set_drvdata(rtd->card, drvdata);
/* Setup clocks */
drvdata->clk_ptr_sysclk = clk_get(dev, "sysclk");
if (IS_ERR(drvdata->clk_ptr_sysclk))
dev_warn(dev, "%s: WARNING: clk_get failed for 'sysclk'!\n",
__func__);
drvdata->clk_ptr_ulpclk = clk_get(dev, "ulpclk");
if (IS_ERR(drvdata->clk_ptr_ulpclk))
dev_warn(dev, "%s: WARNING: clk_get failed for 'ulpclk'!\n",
__func__);
drvdata->clk_ptr_intclk = clk_get(dev, "intclk");
if (IS_ERR(drvdata->clk_ptr_intclk))
dev_warn(dev, "%s: WARNING: clk_get failed for 'intclk'!\n",
__func__);
/* Set intclk default parent to ulpclk */
drvdata->mclk_sel = MCLK_ULPCLK;
ret = mop500_ab8500_set_mclk(dev, drvdata);
if (ret < 0)
dev_warn(dev, "%s: WARNING: mop500_ab8500_set_mclk!\n",
__func__);
drvdata->mclk_sel = MCLK_ULPCLK;
/* Add controls */
ret = snd_soc_add_card_controls(codec->card, mop500_ab8500_ctrls,
ARRAY_SIZE(mop500_ab8500_ctrls));
if (ret < 0) {
pr_err("%s: Failed to add machine-controls (%d)!\n",
__func__, ret);
return ret;
}
ret = snd_soc_dapm_disable_pin(&codec->dapm, "Earpiece");
ret |= snd_soc_dapm_disable_pin(&codec->dapm, "Speaker Left");
ret |= snd_soc_dapm_disable_pin(&codec->dapm, "Speaker Right");
ret |= snd_soc_dapm_disable_pin(&codec->dapm, "LineOut Left");
ret |= snd_soc_dapm_disable_pin(&codec->dapm, "LineOut Right");
ret |= snd_soc_dapm_disable_pin(&codec->dapm, "Vibra 1");
ret |= snd_soc_dapm_disable_pin(&codec->dapm, "Vibra 2");
ret |= snd_soc_dapm_disable_pin(&codec->dapm, "Mic 1");
ret |= snd_soc_dapm_disable_pin(&codec->dapm, "Mic 2");
ret |= snd_soc_dapm_disable_pin(&codec->dapm, "LineIn Left");
ret |= snd_soc_dapm_disable_pin(&codec->dapm, "LineIn Right");
ret |= snd_soc_dapm_disable_pin(&codec->dapm, "DMic 1");
ret |= snd_soc_dapm_disable_pin(&codec->dapm, "DMic 2");
ret |= snd_soc_dapm_disable_pin(&codec->dapm, "DMic 3");
ret |= snd_soc_dapm_disable_pin(&codec->dapm, "DMic 4");
ret |= snd_soc_dapm_disable_pin(&codec->dapm, "DMic 5");
ret |= snd_soc_dapm_disable_pin(&codec->dapm, "DMic 6");
return ret;
}
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;
}
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_dapm_context *dapm = &codec->dapm;
struct aml_audio_private_data * p_aml_audio;
int ret = 0;
int hp_paraments[5];
printk(KERN_DEBUG "enter %s \n", __func__);
p_aml_audio = snd_soc_card_get_drvdata(card);
ret = snd_soc_add_card_controls(codec->card, aml_m8_controls,
ARRAY_SIZE(aml_m8_controls));
if (ret)
return ret;
/* Add specific widgets */
snd_soc_dapm_new_controls(dapm, aml_asoc_dapm_widgets,
ARRAY_SIZE(aml_asoc_dapm_widgets));
if (ret)
return ret;
#if HP_DET
p_aml_audio->sdev.name = "h2w";//for report headphone to android
ret = switch_dev_register(&p_aml_audio->sdev);
if (ret < 0){
printk(KERN_ERR "ASoC: register hp switch dev failed\n");
return ret;
}
p_aml_audio->mic_sdev.name = "mic_dev";//for micphone detect
ret = switch_dev_register(&p_aml_audio->mic_sdev);
if (ret < 0){
printk(KERN_ERR "ASoC: register mic switch dev failed\n");
return ret;
}
ret = snd_soc_jack_new(codec, "hp switch", SND_JACK_HEADPHONE, &p_aml_audio->jack);
if (ret < 0) {
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 < 0) {
printk(KERN_WARNING "Failed to setup hp pins\n");
}
}
p_aml_audio->mic_det = of_property_read_bool(card->dev->of_node,"mic_det");
printk("entern %s : mic_det=%d \n",__func__,p_aml_audio->mic_det);
ret = of_property_read_u32_array(card->dev->of_node, "hp_paraments", &hp_paraments[0], 5);
if(ret){
printk("falied to get hp detect paraments from dts file\n");
}else{
p_aml_audio->hp_val_h = hp_paraments[0]; // hp adc value higher base, hp unplugged
p_aml_audio->hp_val_l = hp_paraments[1]; // hp adc value low base, 3 section hp plugged.
p_aml_audio->mic_val = hp_paraments[2]; // hp adc value mic detect value.
p_aml_audio->hp_detal = hp_paraments[3]; // hp adc value test toerance
p_aml_audio->hp_adc_ch = hp_paraments[4]; // get adc value from which adc port for hp detect
printk("hp detect paraments: h=%d,l=%d,mic=%d,det=%d,ch=%d \n",p_aml_audio->hp_val_h,p_aml_audio->hp_val_l,
p_aml_audio->mic_val,p_aml_audio->hp_detal,p_aml_audio->hp_adc_ch);
}
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 tegra_aic326x_init(struct snd_soc_pcm_runtime *rtd)
{
struct snd_soc_codec *codec = rtd->codec;
struct snd_soc_dapm_context *dapm = &codec->dapm;
struct snd_soc_card *card = codec->card;
struct tegra_aic326x *machine = snd_soc_card_get_drvdata(card);
struct tegra_asoc_platform_data *pdata = machine->pdata;
#ifndef CONFIG_ARCH_TEGRA_2x_SOC
struct tegra30_i2s *i2s = snd_soc_dai_get_drvdata(rtd->cpu_dai);
#endif
int ret;
#ifndef CONFIG_ARCH_TEGRA_2x_SOC
if (machine->codec_info[BASEBAND].i2s_id != -1)
i2s->is_dam_used = true;
#endif
if (machine->init_done)
return 0;
machine->init_done = true;
#ifndef CONFIG_ARCH_TEGRA_2x_SOC
machine->pcard = card;
#endif
if (machine_is_whistler()) {
machine->audio_reg = regulator_get(NULL, "avddio_audio");
if (IS_ERR(machine->audio_reg)) {
dev_err(card->dev, "cannot get avddio_audio reg\n");
ret = PTR_ERR(machine->audio_reg);
return ret;
}
ret = regulator_enable(machine->audio_reg);
if (ret) {
dev_err(card->dev, "cannot enable avddio_audio reg\n");
regulator_put(machine->audio_reg);
machine->audio_reg = NULL;
return ret;
}
}
if (gpio_is_valid(pdata->gpio_spkr_en)) {
ret = gpio_request(pdata->gpio_spkr_en, "spkr_en");
if (ret) {
dev_err(card->dev, "cannot get spkr_en gpio\n");
return ret;
}
machine->gpio_requested |= GPIO_SPKR_EN;
gpio_direction_output(pdata->gpio_spkr_en, 0);
}
if (gpio_is_valid(pdata->gpio_hp_mute)) {
ret = gpio_request(pdata->gpio_hp_mute, "hp_mute");
if (ret) {
dev_err(card->dev, "cannot get hp_mute gpio\n");
return ret;
}
machine->gpio_requested |= GPIO_HP_MUTE;
gpio_direction_output(pdata->gpio_hp_mute, 0);
}
if (gpio_is_valid(pdata->gpio_int_mic_en)) {
ret = gpio_request(pdata->gpio_int_mic_en, "int_mic_en");
if (ret) {
dev_err(card->dev, "cannot get int_mic_en gpio\n");
return ret;
}
machine->gpio_requested |= GPIO_INT_MIC_EN;
/* Disable int mic; enable signal is active-high */
gpio_direction_output(pdata->gpio_int_mic_en, 0);
}
if (gpio_is_valid(pdata->gpio_ext_mic_en)) {
ret = gpio_request(pdata->gpio_ext_mic_en, "ext_mic_en");
if (ret) {
dev_err(card->dev, "cannot get ext_mic_en gpio\n");
return ret;
}
machine->gpio_requested |= GPIO_EXT_MIC_EN;
/* Enable ext mic; enable signal is active-low */
gpio_direction_output(pdata->gpio_ext_mic_en, 0);
}
ret = snd_soc_add_card_controls(card, tegra_aic326x_controls,
ARRAY_SIZE(tegra_aic326x_controls));
if (ret < 0)
return ret;
snd_soc_dapm_new_controls(dapm, tegra_aic326x_dapm_widgets,
ARRAY_SIZE(tegra_aic326x_dapm_widgets));
snd_soc_dapm_add_routes(dapm, aic326x_audio_map,
ARRAY_SIZE(aic326x_audio_map));
ret = snd_soc_jack_new(codec, "Headset Jack", SND_JACK_HEADSET,
&tegra_aic326x_hp_jack);
if (ret < 0)
return ret;
if (gpio_is_valid(pdata->gpio_hp_det)) {
/* Headphone detection */
tegra_aic326x_hp_jack_gpio.gpio = pdata->gpio_hp_det;
snd_soc_jack_new(codec, "Headphone Jack",
SND_JACK_HEADSET, &tegra_aic326x_hp_jack);
#ifndef CONFIG_SWITCH
snd_soc_jack_add_pins(&tegra_aic326x_hp_jack,
ARRAY_SIZE(tegra_aic326x_hp_jack_pins),
tegra_aic326x_hp_jack_pins);
#else
snd_soc_jack_notifier_register(&tegra_aic326x_hp_jack,
&aic326x_headset_switch_nb);
#endif
snd_soc_jack_add_gpios(&tegra_aic326x_hp_jack,
1,
&tegra_aic326x_hp_jack_gpio);
machine->gpio_requested |= GPIO_HP_DET;
}
#ifndef CONFIG_ARCH_TEGRA_11x_SOC
/* update jack status during boot */
aic3262_hs_jack_detect(codec, &tegra_aic326x_hp_jack,
SND_JACK_HEADSET);
#endif
/* Add call mode switch control */
ret = snd_ctl_add(codec->card->snd_card,
snd_ctl_new1(&tegra_aic326x_call_mode_control,
machine));
if (ret < 0)
return ret;
ret = tegra_asoc_utils_register_ctls(&machine->util_data);
if (ret < 0)
return ret;
return 0;
}