Initial file dump from open source releaseHEADmaster

1 files changed, 566 insertions, 0 deletions

diff --git a/sound/soc/sprd/sprd-asoc-card.c b/sound/soc/sprd/sprd-asoc-card.c
new file mode 100644
index 00000000..ce60a47f
--- /dev/null
+++ b/sound/soc/sprd/sprd-asoc-card.c
@@ -0,0 +1,566 @@
+/*
+ * sound/soc/sprd/sprd-asoc-card.c
+ *
+ * Copyright (C) 2013 SpreadTrum Ltd.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+#include "sprd-asoc-debug.h"
+#define pr_fmt(fmt) pr_sprd_fmt("BOARD") fmt
+
+#include <linux/module.h>
+#include <linux/of.h>
+#include <sound/soc.h>
+#include <sound/soc-dapm.h>
+#include <sound/tlv.h>
+#include <sound/sprd-audio-hook.h>
+
+#include <soc/sprd/sprd-audio.h>
+#include "sprd-asoc-common.h"
+#include "dai/vbc/dfm.h"
+
+#define FUN_REG(f) ((unsigned short)(-(f+1)))
+
+#define SWITCH_FUN_ON    1
+#define SWITCH_FUN_OFF   0
+
+enum {
+	BOARD_FUNC_SPKL = 0,
+	BOARD_FUNC_SPKR,
+	BOARD_FUNC_EAR,
+	BOARD_FUNC_HP,
+	BOARD_FUNC_MUTE_MAX,
+	BOARD_FUNC_LINE = BOARD_FUNC_MUTE_MAX,
+	BOARD_FUNC_MIC,
+	BOARD_FUNC_AUXMIC,
+	BOARD_FUNC_HP_MIC,
+	BOARD_FUNC_DMIC,
+	BOARD_FUNC_DMIC1,
+	BOARD_FUNC_DFM,
+	BOARD_FUNC_MAX
+};
+
+struct board_mute {
+	int need_mute;
+	int is_on;
+	int (*mute_func) (struct snd_soc_card *, int);
+};
+
+static struct board_priv {
+	int func[BOARD_FUNC_MAX];
+	struct board_mute m[BOARD_FUNC_MUTE_MAX];
+	int pa_type[BOARD_FUNC_MUTE_MAX];
+} board;
+
+#define BOARD_EXT_SPK "Ext Spk"
+#define BOARD_EXT_SPK2 "Ext Spk2"
+#define BOARD_EXT_EAR "Ext Ear"
+#define BOARD_HEADPHONE_JACK "HeadPhone Jack"
+#define BOARD_LINE_JACK "Line Jack"
+#define BOARD_MIC_JACK "Mic Jack"
+#define BOARD_AUX_MIC_JACK "Aux Mic Jack"
+#define BOARD_HP_MIC_JACK "HP Mic Jack"
+#define BOARD_DMIC_JACK "DMic Jack"
+#define BOARD_DMIC1_JACK "DMic1 Jack"
+#define BOARD_DIG_FM_JACK "Dig FM Jack"
+#define BOARD_INTER_HP_PA "inter HP PA"
+#define BOARD_INTER_SPK_PA "inter Spk PA"
+#define BOARD_INTER_SPK2_PA "inter Spk2 PA"
+
+static const char *func_name[BOARD_FUNC_MAX] = {
+	BOARD_EXT_SPK,
+	BOARD_EXT_SPK2,
+	BOARD_EXT_EAR,
+	BOARD_HEADPHONE_JACK,
+	BOARD_LINE_JACK,
+	BOARD_MIC_JACK,
+	BOARD_AUX_MIC_JACK,
+	BOARD_HP_MIC_JACK,
+	BOARD_DMIC_JACK,
+	BOARD_DMIC1_JACK,
+	BOARD_DIG_FM_JACK,
+};
+
+static void board_ext_control(struct snd_soc_dapm_context *dapm, int s, int e)
+{
+	int i;
+	BUG_ON(e > BOARD_FUNC_MAX);
+	for (i = s; i < e; i++) {
+		if (board.func[i] == SWITCH_FUN_ON)
+			snd_soc_dapm_enable_pin(dapm, func_name[i]);
+		else
+			snd_soc_dapm_disable_pin(dapm, func_name[i]);
+	}
+
+	/* signal a DAPM event */
+	snd_soc_dapm_sync(dapm);
+}
+
+static inline void local_cpu_pa_control(struct snd_soc_card *card,
+					const char *id, bool enable, bool sync)
+{
+	if (enable) {
+		snd_soc_dapm_enable_pin(&card->dapm, id);
+	} else {
+		snd_soc_dapm_disable_pin(&card->dapm, id);
+	}
+
+	if (sync) {
+		/* signal a DAPM event */
+		snd_soc_dapm_sync(&card->dapm);
+	}
+}
+
+static void board_try_inter_pa_control(struct snd_soc_card *card, int id,
+				       bool sync)
+{
+	char *pa_name;
+
+	if (id >= BOARD_FUNC_MUTE_MAX)
+		return;
+
+	switch (id) {
+	case BOARD_FUNC_SPKL:
+		pa_name = BOARD_INTER_SPK_PA;
+		break;
+	case BOARD_FUNC_SPKR:
+		pa_name = BOARD_INTER_SPK2_PA;
+		break;
+	case BOARD_FUNC_HP:
+		pa_name = BOARD_INTER_HP_PA;
+		break;
+	default:
+		return;
+	}
+
+	if (board.pa_type[id] & HOOK_BPY) {
+		int enable = 1;
+		if (board.func[id] == SWITCH_FUN_ON) {
+			if (board.m[id].need_mute) {
+				enable = 0;
+			}
+		} else {
+			enable = 0;
+		}
+		local_cpu_pa_control(card, pa_name, enable, sync);
+	}
+}
+
+static int audio_speaker_enable_inter(struct snd_soc_card *card, int enable)
+{
+	int ret;
+	if (enable && board.m[BOARD_FUNC_SPKL].need_mute) {
+		enable = 0;
+	}
+	ret = sprd_ext_speaker_ctrl(SPRD_AUDIO_ID_SPEAKER, enable);
+	if (ret < 0) {
+		pr_err("ERR:Call external speaker control failed %d!\n", ret);
+		return ret;
+	}
+	return ret;
+}
+
+static void audio_speaker_enable(struct snd_soc_card *card, int enable)
+{
+	board.m[BOARD_FUNC_SPKL].is_on = enable;
+	board.m[BOARD_FUNC_SPKL].mute_func(card, enable);
+}
+
+static int audio_speaker2_enable_inter(struct snd_soc_card *card, int enable)
+{
+	int ret;
+	if (enable && board.m[BOARD_FUNC_SPKR].need_mute) {
+		enable = 0;
+	}
+	ret = sprd_ext_speaker_ctrl(SPRD_AUDIO_ID_SPEAKER2, enable);
+	if (ret < 0) {
+		pr_err("ERR:Call external speaker2 control failed %d!\n", ret);
+		return ret;
+	}
+	return ret;
+}
+
+static void audio_speaker2_enable(struct snd_soc_card *card, int enable)
+{
+	board.m[BOARD_FUNC_SPKR].is_on = enable;
+	board.m[BOARD_FUNC_SPKR].mute_func(card, enable);
+}
+
+static int audio_headphone_enable_inter(struct snd_soc_card *card, int enable)
+{
+	int ret;
+	if (enable && board.m[BOARD_FUNC_HP].need_mute) {
+		enable = 0;
+	}
+	ret = sprd_ext_headphone_ctrl(SPRD_AUDIO_ID_HEADPHONE, enable);
+	if (ret < 0) {
+		pr_err("ERR:Call external headphone control failed %d!\n", ret);
+		return ret;
+	}
+	return ret;
+}
+
+static void audio_headphone_enable(struct snd_soc_card *card, int enable)
+{
+	board.m[BOARD_FUNC_HP].is_on = enable;
+	board.m[BOARD_FUNC_HP].mute_func(card, enable);
+}
+
+static int audio_earpiece_enable_inter(struct snd_soc_card *card, int enable)
+{
+	int ret;
+	if (enable && board.m[BOARD_FUNC_EAR].need_mute) {
+		enable = 0;
+	}
+	ret = sprd_ext_earpiece_ctrl(SPRD_AUDIO_ID_EARPIECE, enable);
+	if (ret < 0) {
+		pr_err("ERR:Call external earpiece control failed %d!\n", ret);
+	}
+	return ret;
+}
+
+static void audio_earpiece_enable(struct snd_soc_card *card, int enable)
+{
+	board.m[BOARD_FUNC_EAR].is_on = enable;
+	board.m[BOARD_FUNC_EAR].mute_func(card, enable);
+}
+
+static int board_headphone_event(struct snd_soc_dapm_widget *w,
+				 struct snd_kcontrol *k, int event)
+{
+	int on = ! !SND_SOC_DAPM_EVENT_ON(event);
+	sp_asoc_pr_dbg("Headphone Switch %s\n", STR_ON_OFF(on));
+	audio_headphone_enable(w->dapm->card, on);
+	return 0;
+}
+
+static int board_earpiece_event(struct snd_soc_dapm_widget *w,
+				struct snd_kcontrol *k, int event)
+{
+	int on = ! !SND_SOC_DAPM_EVENT_ON(event);
+	sp_asoc_pr_dbg("Earpiece Switch %s\n", STR_ON_OFF(on));
+	audio_earpiece_enable(w->dapm->card, on);
+	return 0;
+}
+
+static int board_speaker_event(struct snd_soc_dapm_widget *w,
+			       struct snd_kcontrol *k, int event)
+{
+	int on = ! !SND_SOC_DAPM_EVENT_ON(event);
+	sp_asoc_pr_dbg("Speaker Switch %s\n", STR_ON_OFF(on));
+	audio_speaker_enable(w->dapm->card, on);
+	return 0;
+}
+
+static int board_speaker2_event(struct snd_soc_dapm_widget *w,
+				struct snd_kcontrol *k, int event)
+{
+	int on = ! !SND_SOC_DAPM_EVENT_ON(event);
+	sp_asoc_pr_dbg("Speaker2 Switch %s\n", STR_ON_OFF(on));
+	audio_speaker2_enable(w->dapm->card, on);
+	return 0;
+}
+
+static int board_main_mic_event(struct snd_soc_dapm_widget *w,
+				struct snd_kcontrol *k, int event)
+{
+	int on = ! !SND_SOC_DAPM_EVENT_ON(event);
+	sp_asoc_pr_dbg("Main MIC Switch %s\n", STR_ON_OFF(on));
+	sprd_ext_mic_ctrl(SPRD_AUDIO_ID_MAIN_MIC, on);
+	return 0;
+}
+
+static int board_sub_mic_event(struct snd_soc_dapm_widget *w,
+			       struct snd_kcontrol *k, int event)
+{
+	int on = ! !SND_SOC_DAPM_EVENT_ON(event);
+	sp_asoc_pr_dbg("Sub MIC Switch %s\n", STR_ON_OFF(on));
+	sprd_ext_mic_ctrl(SPRD_AUDIO_ID_SUB_MIC, on);
+	return 0;
+}
+
+static int board_head_mic_event(struct snd_soc_dapm_widget *w,
+				struct snd_kcontrol *k, int event)
+{
+	int on = ! !SND_SOC_DAPM_EVENT_ON(event);
+	sp_asoc_pr_dbg("Head MIC Switch %s\n", STR_ON_OFF(on));
+	sprd_ext_mic_ctrl(SPRD_AUDIO_ID_HEAD_MIC, on);
+	return 0;
+}
+
+static int board_dig0_mic_event(struct snd_soc_dapm_widget *w,
+				struct snd_kcontrol *k, int event)
+{
+	int on = ! !SND_SOC_DAPM_EVENT_ON(event);
+	sp_asoc_pr_dbg("Digtial0 MIC Switch %s\n", STR_ON_OFF(on));
+	sprd_ext_mic_ctrl(SPRD_AUDIO_ID_DIG0_MIC, on);
+	return 0;
+}
+
+static int board_dig1_mic_event(struct snd_soc_dapm_widget *w,
+				struct snd_kcontrol *k, int event)
+{
+	int on = ! !SND_SOC_DAPM_EVENT_ON(event);
+	sp_asoc_pr_dbg("Digtial1 MIC Switch %s\n", STR_ON_OFF(on));
+	sprd_ext_mic_ctrl(SPRD_AUDIO_ID_DIG1_MIC, on);
+	return 0;
+}
+
+static int board_line_in_event(struct snd_soc_dapm_widget *w,
+			       struct snd_kcontrol *k, int event)
+{
+	int on = ! !SND_SOC_DAPM_EVENT_ON(event);
+	sp_asoc_pr_dbg("LINE IN Switch %s\n", STR_ON_OFF(on));
+	sprd_ext_mic_ctrl(SPRD_AUDIO_ID_LINE_IN, on);
+	return 0;
+}
+
+static int board_dig_fm_event(struct snd_soc_dapm_widget *w,
+			      struct snd_kcontrol *k, int event)
+{
+	int on = ! !SND_SOC_DAPM_EVENT_ON(event);
+	sp_asoc_pr_dbg("Digtial FM Switch %s\n", STR_ON_OFF(on));
+	sprd_ext_fm_ctrl(SPRD_AUDIO_ID_DIG_FM, on);
+	return 0;
+}
+
+static const struct snd_soc_dapm_widget sprd_codec_dapm_widgets[] = {
+	SND_SOC_DAPM_MIC(BOARD_MIC_JACK, board_main_mic_event),
+	SND_SOC_DAPM_MIC(BOARD_AUX_MIC_JACK, board_sub_mic_event),
+	SND_SOC_DAPM_MIC(BOARD_HP_MIC_JACK, board_head_mic_event),
+	SND_SOC_DAPM_MIC(BOARD_DMIC_JACK, board_dig0_mic_event),
+	SND_SOC_DAPM_MIC(BOARD_DMIC1_JACK, board_dig1_mic_event),
+	/*digital fm input */
+	SND_SOC_DAPM_LINE(BOARD_DIG_FM_JACK, board_dig_fm_event),
+
+	SND_SOC_DAPM_SPK(BOARD_EXT_SPK, board_speaker_event),
+	SND_SOC_DAPM_SPK(BOARD_EXT_SPK2, board_speaker2_event),
+	SND_SOC_DAPM_SPK(BOARD_EXT_EAR, board_earpiece_event),
+	SND_SOC_DAPM_LINE(BOARD_LINE_JACK, board_line_in_event),
+	SND_SOC_DAPM_HP(BOARD_HEADPHONE_JACK, board_headphone_event),
+	SND_SOC_DAPM_HP(BOARD_INTER_HP_PA, NULL),
+	SND_SOC_DAPM_SPK(BOARD_INTER_SPK_PA, NULL),
+	SND_SOC_DAPM_SPK(BOARD_INTER_SPK2_PA, NULL),
+};
+
+static int board_func_get(struct snd_kcontrol *kcontrol,
+			  struct snd_ctl_elem_value *ucontrol)
+{
+	struct soc_mixer_control *mc =
+	    (struct soc_mixer_control *)kcontrol->private_value;
+	int id = FUN_REG(mc->reg);
+	ucontrol->value.integer.value[0] = board.func[id];
+	return 0;
+}
+
+static int board_func_set(struct snd_kcontrol *kcontrol,
+			  struct snd_ctl_elem_value *ucontrol)
+{
+	struct soc_mixer_control *mc =
+	    (struct soc_mixer_control *)kcontrol->private_value;
+	struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
+	int id = FUN_REG(mc->reg);
+
+	sp_asoc_pr_info("%s Switch %s\n", func_name[id],
+			STR_ON_OFF(ucontrol->value.integer.value[0]));
+
+	if (board.func[id] == ucontrol->value.integer.value[0])
+		return 0;
+
+	board.func[id] = ucontrol->value.integer.value[0];
+	board_try_inter_pa_control(card, id, 1);
+	board_ext_control(&card->dapm, id, id + 1);
+	return 1;
+}
+
+static int board_mute_get(struct snd_kcontrol *kcontrol,
+			  struct snd_ctl_elem_value *ucontrol)
+{
+	struct soc_mixer_control *mc =
+	    (struct soc_mixer_control *)kcontrol->private_value;
+	int id = FUN_REG(mc->reg);
+	ucontrol->value.integer.value[0] = board.m[id].need_mute;
+	return 0;
+}
+
+static int board_mute_set(struct snd_kcontrol *kcontrol,
+			  struct snd_ctl_elem_value *ucontrol)
+{
+	struct soc_mixer_control *mc =
+	    (struct soc_mixer_control *)kcontrol->private_value;
+	struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
+	int id = FUN_REG(mc->reg);
+
+	sp_asoc_pr_info("%s Switch %s\n", func_name[id],
+			ucontrol->value.integer.value[0] ? "Mute" : "Unmute");
+
+	if (board.m[id].need_mute == ucontrol->value.integer.value[0])
+		return 0;
+
+	board.m[id].need_mute = ucontrol->value.integer.value[0];
+	board.m[id].mute_func(card, board.m[id].is_on);
+	board_try_inter_pa_control(card, id, 1);
+	return 1;
+}
+
+static void board_inter_pa_check(int func_id)
+{
+	switch (func_id) {
+	case BOARD_FUNC_SPKL:
+		board.pa_type[func_id] =
+		    sprd_ext_speaker_ctrl(SPRD_AUDIO_ID_SPEAKER, 0);
+		break;
+	case BOARD_FUNC_SPKR:
+		board.pa_type[func_id] =
+		    sprd_ext_speaker_ctrl(SPRD_AUDIO_ID_SPEAKER2, 0);
+		break;
+	case BOARD_FUNC_EAR:
+		board.pa_type[func_id] =
+		    sprd_ext_earpiece_ctrl(SPRD_AUDIO_ID_EARPIECE, 0);
+		break;
+	case BOARD_FUNC_HP:
+		board.pa_type[func_id] =
+		    sprd_ext_headphone_ctrl(SPRD_AUDIO_ID_HEADPHONE, 0);
+		break;
+	default:
+		return;
+	}
+}
+
+static void board_inter_pa_init(void)
+{
+	int id;
+	for (id = BOARD_FUNC_SPKL; id < BOARD_FUNC_MUTE_MAX; id++)
+		board_inter_pa_check(id);
+}
+
+static void board_inter_pa_control(struct snd_soc_card *card)
+{
+	int id;
+	for (id = BOARD_FUNC_SPKL; id < BOARD_FUNC_MUTE_MAX; id++)
+		board_try_inter_pa_control(card, id, 0);
+}
+
+static int board_late_probe(struct snd_soc_card *card)
+{
+	int i;
+	sprd_audio_debug_init(card->snd_card);
+
+	board_inter_pa_control(card);
+	board_ext_control(&card->dapm, 0, BOARD_FUNC_MAX);
+
+	for (i = 0; i < BOARD_FUNC_MAX; i++) {
+		snd_soc_dapm_ignore_suspend(&card->dapm, func_name[i]);
+	}
+
+	snd_soc_dapm_ignore_suspend(&card->dapm, BOARD_INTER_HP_PA);
+	snd_soc_dapm_ignore_suspend(&card->dapm, BOARD_INTER_SPK_PA);
+	snd_soc_dapm_ignore_suspend(&card->dapm, BOARD_INTER_SPK2_PA);
+	snd_soc_dapm_ignore_suspend(&card->rtd->codec->dapm, "Playback-Vaudio");
+	snd_soc_dapm_ignore_suspend(&card->rtd->codec->dapm,
+				    "Main-Capture-Vaudio");
+	snd_soc_dapm_ignore_suspend(&card->rtd->codec->dapm,
+				    "Ext-Capture-Vaudio");
+	snd_soc_dapm_ignore_suspend(&card->rtd->codec->dapm, "DFM-Output");
+	return 0;
+}
+
+static void board_mute_init(void)
+{
+	board.m[BOARD_FUNC_SPKL].mute_func = audio_speaker_enable_inter;
+	board.m[BOARD_FUNC_SPKR].mute_func = audio_speaker2_enable_inter;
+	board.m[BOARD_FUNC_HP].mute_func = audio_headphone_enable_inter;
+	board.m[BOARD_FUNC_EAR].mute_func = audio_earpiece_enable_inter;
+}
+
+static int sprd_asoc_probe(struct platform_device *pdev,
+			   struct snd_soc_card *card)
+{
+	struct device_node *node = pdev->dev.of_node;
+	card->dev = &pdev->dev;
+	if (node) {
+		int i;
+		struct device_node *pcm_node;
+		struct device_node *codec_node;
+
+		if (snd_soc_of_parse_card_name(card, "sprd,model")) {
+			pr_err("ERR:Card name is not provided\n");
+			return -ENODEV;
+		}
+#if 0
+		ret = snd_soc_of_parse_audio_routing(card,
+						     "sprd,audio-routing");
+		if (ret) {
+			pr_err("ERR:Error while parsing DAPM routing\n");
+			return ret;
+		}
+#endif
+
+		pcm_node = of_parse_phandle(node, "sprd,pcm", 0);
+		if (!pcm_node) {
+			pr_err("ERR:PCM node is not provided\n");
+			return -EINVAL;
+		}
+
+		codec_node = of_parse_phandle(node, "sprd,codec", 0);
+		if (!codec_node) {
+			pr_err("ERR:CODEC node is not provided\n");
+			of_node_put(pcm_node);
+			return -EINVAL;
+		}
+
+		for (i = 0; i < card->num_links; i++) {
+			card->dai_link[i].platform_name = NULL;
+			card->dai_link[i].platform_of_node = pcm_node;
+			card->dai_link[i].codec_name = NULL;
+			card->dai_link[i].codec_of_node = codec_node;
+		}
+		of_node_put(pcm_node);
+		of_node_put(codec_node);
+	}
+
+	board_mute_init();
+	board_inter_pa_init();
+	return snd_soc_register_card(card);
+}
+
+static int sprd_asoc_remove(struct platform_device *pdev)
+{
+	struct snd_soc_card *card = platform_get_drvdata(pdev);
+	snd_soc_unregister_card(card);
+	return 0;
+}
+
+static void sprd_asoc_shutdown(struct platform_device *pdev)
+{
+	struct snd_soc_card *card = platform_get_drvdata(pdev);
+	memset(&board.func, 0, sizeof(board.func));
+	board_inter_pa_control(card);
+	board_ext_control(&card->dapm, 0, BOARD_FUNC_MAX);
+}
+
+#define BOARD_CODEC_FUNC(xname, xreg) \
+	SOC_SINGLE_EXT(xname, FUN_REG(xreg), 0, 1, 0, board_func_get, board_func_set)
+
+#define BOARD_CODEC_MUTE(xname, xreg) \
+	SOC_SINGLE_EXT(xname, FUN_REG(xreg), 0, 1, 0, board_mute_get, board_mute_set)
+
+#if defined(CONFIG_SND_SOC_SPRD_VBC_R2P0_SPRD_CODEC_V4)
+#include "vbc-r2p0-sprd-codec-v4.h"
+#else
+#include "vbc-r1p0-sprd-codec-v1.h"
+#include "vbc-r2p0-sprd-codec-v3.h"
+#endif
+
+MODULE_DESCRIPTION("ALSA ASoC SpreadTrum VBC SPRD-CODEC");
+MODULE_AUTHOR("Zhenfang Wang <zhenfang.wang@spreadtrum.com>");
+MODULE_AUTHOR("Ken Kuang <ken.kuang@spreadtrum.com>");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("machine:vbc-sprd-codec");