[PATCH 4/5] ASoC: qcom: sc8280xp: Add per-card data

[Hongyang Zhao]

The sc8280xp machine driver currently uses the OF match data only as a
driver name, which makes it difficult to describe board-specific MI2S
codec requirements.

Convert the match data to a per-card data structure and add data for
the QCS6490 RubikPi3. The RubikPi3 data configures the ES8316 MI2S DAI
format, MCLK rate, BE hardware parameters and headset jack pins.

Add a common headset jack helper which accepts board-specific DAPM pins
for codecs that are not connected through the WCD TX codec DMA path.

Signed-off-by: Hongyang Zhao <hongyang.zhao@xxxxxxxxxxxxxxx>
---
 sound/soc/qcom/common.c   |  75 ++++++++---
 sound/soc/qcom/common.h   |   6 +-
 sound/soc/qcom/sc8280xp.c | 319 ++++++++++++++++++++++++++++++++++++++++++----
 3 files changed, 357 insertions(+), 43 deletions(-)

diff --git a/sound/soc/qcom/common.c b/sound/soc/qcom/common.c
index cf1f3a767cee..5e7a01418ad8 100644
--- a/sound/soc/qcom/common.c
+++ b/sound/soc/qcom/common.c
@@ -201,26 +201,30 @@ static struct snd_soc_jack_pin qcom_headset_jack_pins[] = {
 	},
 };
 
-int qcom_snd_wcd_jack_setup(struct snd_soc_pcm_runtime *rtd,
-			    struct snd_soc_jack *jack, bool *jack_setup)
+static int qcom_snd_headset_jack_init(struct snd_soc_card *card,
+				      struct snd_soc_jack *jack,
+				      bool *jack_setup,
+				      struct snd_soc_jack_pin *pins,
+				      unsigned int num_pins)
 {
-	struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0);
-	struct snd_soc_dai *codec_dai = snd_soc_rtd_to_codec(rtd, 0);
-	struct snd_soc_card *card = rtd->card;
-	int rval, i;
+	int rval;
+
+	if (!pins) {
+		pins = qcom_headset_jack_pins;
+		num_pins = ARRAY_SIZE(qcom_headset_jack_pins);
+	}
 
 	if (!*jack_setup) {
 		rval = snd_soc_card_jack_new_pins(card, "Headset Jack",
-					     SND_JACK_HEADSET | SND_JACK_LINEOUT |
-					     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,
-					     jack, qcom_headset_jack_pins,
-					     ARRAY_SIZE(qcom_headset_jack_pins));
+						  SND_JACK_HEADSET | SND_JACK_LINEOUT |
+						  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,
+						  jack, pins, num_pins);
 
 		if (rval < 0) {
-			dev_err(card->dev, "Unable to add Headphone Jack\n");
+			dev_err(card->dev, "Unable to add Headset Jack\n");
 			return rval;
 		}
 
@@ -231,6 +235,48 @@ int qcom_snd_wcd_jack_setup(struct snd_soc_pcm_runtime *rtd,
 		*jack_setup = true;
 	}
 
+	return 0;
+}
+
+int qcom_snd_headset_jack_setup(struct snd_soc_pcm_runtime *rtd,
+				struct snd_soc_jack *jack,
+				bool *jack_setup,
+				struct snd_soc_jack_pin *pins,
+				unsigned int num_pins)
+{
+	struct snd_soc_dai *codec_dai = snd_soc_rtd_to_codec(rtd, 0);
+	struct snd_soc_card *card = rtd->card;
+	int rval, i;
+
+	rval = qcom_snd_headset_jack_init(card, jack, jack_setup,
+					  pins, num_pins);
+	if (rval)
+		return rval;
+
+	for_each_rtd_codec_dais(rtd, i, codec_dai) {
+		rval = snd_soc_component_set_jack(codec_dai->component, jack, NULL);
+		if (rval != 0 && rval != -ENOTSUPP) {
+			dev_warn(card->dev, "Failed to set jack: %d\n", rval);
+			return rval;
+		}
+	}
+
+	return 0;
+}
+EXPORT_SYMBOL_GPL(qcom_snd_headset_jack_setup);
+
+int qcom_snd_wcd_jack_setup(struct snd_soc_pcm_runtime *rtd,
+			    struct snd_soc_jack *jack, bool *jack_setup)
+{
+	struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0);
+	struct snd_soc_dai *codec_dai = snd_soc_rtd_to_codec(rtd, 0);
+	struct snd_soc_card *card = rtd->card;
+	int rval, i;
+
+	rval = qcom_snd_headset_jack_init(card, jack, jack_setup, NULL, 0);
+	if (rval)
+		return rval;
+
 	switch (cpu_dai->id) {
 	case TX_CODEC_DMA_TX_0:
 	case TX_CODEC_DMA_TX_1:
@@ -250,7 +296,6 @@ int qcom_snd_wcd_jack_setup(struct snd_soc_pcm_runtime *rtd,
 		break;
 	}
 
-
 	return 0;
 }
 EXPORT_SYMBOL_GPL(qcom_snd_wcd_jack_setup);
diff --git a/sound/soc/qcom/common.h b/sound/soc/qcom/common.h
index ee6662885593..6d023f76f27e 100644
--- a/sound/soc/qcom/common.h
+++ b/sound/soc/qcom/common.h
@@ -10,10 +10,14 @@
 #define LPASS_MAX_PORT			(SENARY_MI2S_TX + 1)
 
 int qcom_snd_parse_of(struct snd_soc_card *card);
+int qcom_snd_headset_jack_setup(struct snd_soc_pcm_runtime *rtd,
+				struct snd_soc_jack *jack,
+				bool *jack_setup,
+				struct snd_soc_jack_pin *pins,
+				unsigned int num_pins);
 int qcom_snd_wcd_jack_setup(struct snd_soc_pcm_runtime *rtd,
 			    struct snd_soc_jack *jack, bool *jack_setup);
 int qcom_snd_dp_jack_setup(struct snd_soc_pcm_runtime *rtd,
 			   struct snd_soc_jack *dp_jack, int id);
 
-
 #endif
diff --git a/sound/soc/qcom/sc8280xp.c b/sound/soc/qcom/sc8280xp.c
index 7925aa3f63ba..1ccd7437cc52 100644
--- a/sound/soc/qcom/sc8280xp.c
+++ b/sound/soc/qcom/sc8280xp.c
@@ -15,26 +15,127 @@
 #include "common.h"
 #include "sdw.h"
 
+struct sc8280xp_mi2s_codec_config {
+	unsigned int cpu_dai_id;
+	unsigned int dai_fmt;
+	unsigned int sysclk_rate;
+};
+
+struct sc8280xp_be_hw_params {
+	unsigned int rate;
+	snd_pcm_format_t format;
+	unsigned int channels_min;
+	unsigned int channels_max;
+};
+
+struct sc8280xp_be_hw_params_config {
+	unsigned int cpu_dai_id;
+	struct sc8280xp_be_hw_params hw_params;
+};
+
+struct sc8280xp_sndcard_data {
+	const char *driver_name;
+	struct sc8280xp_be_hw_params default_be_hw_params;
+	const struct sc8280xp_mi2s_codec_config *mi2s_codec_configs;
+	int num_mi2s_codec_configs;
+	const struct sc8280xp_be_hw_params_config *be_hw_params_configs;
+	int num_be_hw_params_configs;
+	const unsigned int *headset_jack_dais;
+	int num_headset_jack_dais;
+	struct snd_soc_jack_pin *headset_jack_pins;
+	unsigned int num_headset_jack_pins;
+};
+
 struct sc8280xp_snd_data {
 	bool stream_prepared[AFE_PORT_MAX];
 	struct snd_soc_card *card;
 	struct snd_soc_jack jack;
 	struct snd_soc_jack dp_jack[8];
+	const struct sc8280xp_sndcard_data *card_data;
 	bool jack_setup;
 };
 
+static const struct sc8280xp_mi2s_codec_config *
+sc8280xp_snd_get_mi2s_codec_config(const struct sc8280xp_sndcard_data *card_data,
+				   unsigned int cpu_dai_id)
+{
+	int i;
+
+	for (i = 0; i < card_data->num_mi2s_codec_configs; i++) {
+		if (card_data->mi2s_codec_configs[i].cpu_dai_id == cpu_dai_id)
+			return &card_data->mi2s_codec_configs[i];
+	}
+
+	return NULL;
+}
+
+static const struct sc8280xp_be_hw_params *
+sc8280xp_snd_get_be_hw_params(const struct sc8280xp_sndcard_data *card_data,
+			      unsigned int cpu_dai_id)
+{
+	int i;
+
+	for (i = 0; i < card_data->num_be_hw_params_configs; i++) {
+		if (card_data->be_hw_params_configs[i].cpu_dai_id == cpu_dai_id)
+			return &card_data->be_hw_params_configs[i].hw_params;
+	}
+
+	return NULL;
+}
+
+static bool sc8280xp_snd_is_headset_jack_dai(const struct sc8280xp_sndcard_data *card_data,
+					     unsigned int cpu_dai_id)
+{
+	int i;
+
+	for (i = 0; i < card_data->num_headset_jack_dais; i++) {
+		if (card_data->headset_jack_dais[i] == cpu_dai_id)
+			return true;
+	}
+
+	return false;
+}
+
 static int sc8280xp_snd_init(struct snd_soc_pcm_runtime *rtd)
 {
 	struct sc8280xp_snd_data *data = snd_soc_card_get_drvdata(rtd->card);
+	const struct sc8280xp_sndcard_data *card_data = data->card_data;
+	const struct sc8280xp_mi2s_codec_config *mi2s_config;
 	struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0);
+	struct snd_soc_dai *codec_dai;
 	struct snd_soc_card *card = rtd->card;
 	struct snd_soc_jack *dp_jack  = NULL;
 	int dp_pcm_id = 0;
+	int i, ret;
 
 	switch (cpu_dai->id) {
 	case PRIMARY_MI2S_RX...QUATERNARY_MI2S_TX:
 	case QUINARY_MI2S_RX...QUINARY_MI2S_TX:
 		snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_BP_FP);
+
+		mi2s_config = sc8280xp_snd_get_mi2s_codec_config(card_data,
+								 cpu_dai->id);
+		if (mi2s_config) {
+			for_each_rtd_codec_dais(rtd, i, codec_dai) {
+				if (mi2s_config->dai_fmt) {
+					ret = snd_soc_dai_set_fmt(codec_dai,
+								  mi2s_config->dai_fmt);
+					if (ret && ret != -ENOTSUPP)
+						return ret;
+				}
+
+				if (mi2s_config->sysclk_rate) {
+					ret = snd_soc_dai_set_sysclk(codec_dai, 0,
+								     mi2s_config->sysclk_rate,
+								     SND_SOC_CLOCK_IN);
+					if (ret && ret != -ENOTSUPP)
+						return dev_err_probe(card->dev, ret,
+								     "%s: failed to set sysclk for %s\n",
+								     rtd->dai_link->name,
+								     codec_dai->name);
+				}
+			}
+		}
 		break;
 	case WSA_CODEC_DMA_RX_0:
 	case WSA_CODEC_DMA_RX_1:
@@ -64,34 +165,56 @@ static int sc8280xp_snd_init(struct snd_soc_pcm_runtime *rtd)
 	if (dp_jack)
 		return qcom_snd_dp_jack_setup(rtd, dp_jack, dp_pcm_id);
 
+	if (sc8280xp_snd_is_headset_jack_dai(card_data, cpu_dai->id))
+		return qcom_snd_headset_jack_setup(rtd, &data->jack,
+						   &data->jack_setup,
+						   card_data->headset_jack_pins,
+						   card_data->num_headset_jack_pins);
+
+	if (card_data->headset_jack_dais)
+		return 0;
+
 	return qcom_snd_wcd_jack_setup(rtd, &data->jack, &data->jack_setup);
 }
 
 static int sc8280xp_be_hw_params_fixup(struct snd_soc_pcm_runtime *rtd,
-				     struct snd_pcm_hw_params *params)
+				       struct snd_pcm_hw_params *params)
 {
+	struct sc8280xp_snd_data *data = snd_soc_card_get_drvdata(rtd->card);
+	const struct sc8280xp_sndcard_data *card_data = data->card_data;
+	const struct sc8280xp_be_hw_params *be_hw_params;
 	struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0);
 	struct snd_interval *rate = hw_param_interval(params,
 					SNDRV_PCM_HW_PARAM_RATE);
 	struct snd_interval *channels = hw_param_interval(params,
 					SNDRV_PCM_HW_PARAM_CHANNELS);
 	struct snd_mask *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
+	bool use_default = false;
 
-	rate->min = rate->max = 48000;
-	snd_mask_set_format(fmt, SNDRV_PCM_FORMAT_S16_LE);
-	channels->min = 2;
-	channels->max = 2;
-	switch (cpu_dai->id) {
-	case TX_CODEC_DMA_TX_0:
-	case TX_CODEC_DMA_TX_1:
-	case TX_CODEC_DMA_TX_2:
-	case TX_CODEC_DMA_TX_3:
-		channels->min = 1;
-		break;
-	default:
-		break;
+	be_hw_params = sc8280xp_snd_get_be_hw_params(card_data, cpu_dai->id);
+	if (!be_hw_params) {
+		be_hw_params = &card_data->default_be_hw_params;
+		use_default = true;
 	}
 
+	rate->min = be_hw_params->rate;
+	rate->max = be_hw_params->rate;
+	snd_mask_set_format(fmt, be_hw_params->format);
+	channels->min = be_hw_params->channels_min;
+	channels->max = be_hw_params->channels_max;
+
+	if (use_default) {
+		switch (cpu_dai->id) {
+		case TX_CODEC_DMA_TX_0:
+		case TX_CODEC_DMA_TX_1:
+		case TX_CODEC_DMA_TX_2:
+		case TX_CODEC_DMA_TX_3:
+			channels->min = 1;
+			break;
+		default:
+			break;
+		}
+	}
 
 	return 0;
 }
@@ -146,36 +269,178 @@ static int sc8280xp_platform_probe(struct platform_device *pdev)
 	if (!card)
 		return -ENOMEM;
 	card->owner = THIS_MODULE;
+
 	/* Allocate the private data */
 	data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
 	if (!data)
 		return -ENOMEM;
+	data->card_data = of_device_get_match_data(dev);
+	if (!data->card_data)
+		return -EINVAL;
 
 	card->dev = dev;
+	card->driver_name = data->card_data->driver_name;
+
 	dev_set_drvdata(dev, card);
 	snd_soc_card_set_drvdata(card, data);
 	ret = qcom_snd_parse_of(card);
 	if (ret)
 		return ret;
 
-	card->driver_name = of_device_get_match_data(dev);
 	sc8280xp_add_be_ops(card);
 	return devm_snd_soc_register_card(dev, card);
 }
 
+#define SC8280XP_SND_DATA(_driver_name)				\
+	.driver_name = _driver_name,				\
+	.default_be_hw_params = {				\
+		.rate = 48000,					\
+		.format = SNDRV_PCM_FORMAT_S16_LE,		\
+		.channels_min = 2,				\
+		.channels_max = 2,				\
+	}
+
+static const struct sc8280xp_sndcard_data kaanapali_data = {
+	SC8280XP_SND_DATA("kaanapali"),
+};
+
+static const struct sc8280xp_sndcard_data qcm6490_data = {
+	SC8280XP_SND_DATA("qcm6490"),
+};
+
+static const struct sc8280xp_sndcard_data qcs615_data = {
+	SC8280XP_SND_DATA("qcs615"),
+};
+
+static const struct sc8280xp_sndcard_data qcs6490_data = {
+	SC8280XP_SND_DATA("qcs6490"),
+};
+
+static const struct sc8280xp_sndcard_data qcs8300_data = {
+	SC8280XP_SND_DATA("qcs8300"),
+};
+
+static const struct sc8280xp_mi2s_codec_config qcs6490_rubikpi3_mi2s_codec_configs[] = {
+	{
+		.cpu_dai_id = PRIMARY_MI2S_RX,
+		.dai_fmt = SND_SOC_DAIFMT_BC_FC |
+			   SND_SOC_DAIFMT_NB_NF |
+			   SND_SOC_DAIFMT_I2S,
+		.sysclk_rate = 19200000,
+	},
+	{
+		.cpu_dai_id = PRIMARY_MI2S_TX,
+		.dai_fmt = SND_SOC_DAIFMT_BC_FC |
+			   SND_SOC_DAIFMT_NB_NF |
+			   SND_SOC_DAIFMT_I2S,
+		.sysclk_rate = 19200000,
+	},
+};
+
+static const unsigned int qcs6490_rubikpi3_headset_jack_dais[] = {
+	PRIMARY_MI2S_RX,
+};
+
+static struct snd_soc_jack_pin qcs6490_rubikpi3_headset_jack_pins[] = {
+	{
+		.pin = "Mic Jack",
+		.mask = SND_JACK_HEADPHONE,
+	},
+	{
+		.pin = "Headphone Jack",
+		.mask = SND_JACK_HEADPHONE,
+	},
+};
+
+static const struct sc8280xp_be_hw_params_config qcs6490_rubikpi3_be_hw_params_configs[] = {
+	{
+		.cpu_dai_id = PRIMARY_MI2S_TX,
+		.hw_params = {
+			.rate = 48000,
+			.format = SNDRV_PCM_FORMAT_S16_LE,
+			.channels_min = 2,
+			.channels_max = 2,
+		},
+	},
+	{
+		.cpu_dai_id = QUATERNARY_MI2S_RX,
+		.hw_params = {
+			.rate = 48000,
+			.format = SNDRV_PCM_FORMAT_S16_LE,
+			.channels_min = 2,
+			.channels_max = 2,
+		},
+	},
+	{
+		.cpu_dai_id = TERTIARY_MI2S_RX,
+		.hw_params = {
+			.rate = 48000,
+			.format = SNDRV_PCM_FORMAT_S32_LE,
+			.channels_min = 2,
+			.channels_max = 2,
+		},
+	},
+	{
+		.cpu_dai_id = TERTIARY_MI2S_TX,
+		.hw_params = {
+			.rate = 48000,
+			.format = SNDRV_PCM_FORMAT_S32_LE,
+			.channels_min = 1,
+			.channels_max = 2,
+		},
+	},
+};
+
+static const struct sc8280xp_sndcard_data qcs6490_rubikpi3_data = {
+	SC8280XP_SND_DATA("qcs6490"),
+	.mi2s_codec_configs = qcs6490_rubikpi3_mi2s_codec_configs,
+	.num_mi2s_codec_configs = ARRAY_SIZE(qcs6490_rubikpi3_mi2s_codec_configs),
+	.be_hw_params_configs = qcs6490_rubikpi3_be_hw_params_configs,
+	.num_be_hw_params_configs = ARRAY_SIZE(qcs6490_rubikpi3_be_hw_params_configs),
+	.headset_jack_dais = qcs6490_rubikpi3_headset_jack_dais,
+	.num_headset_jack_dais = ARRAY_SIZE(qcs6490_rubikpi3_headset_jack_dais),
+	.headset_jack_pins = qcs6490_rubikpi3_headset_jack_pins,
+	.num_headset_jack_pins = ARRAY_SIZE(qcs6490_rubikpi3_headset_jack_pins),
+};
+
+static const struct sc8280xp_sndcard_data sa8775p_data = {
+	SC8280XP_SND_DATA("sa8775p"),
+};
+
+static const struct sc8280xp_sndcard_data sc8280xp_data = {
+	SC8280XP_SND_DATA("sc8280xp"),
+};
+
+static const struct sc8280xp_sndcard_data sm8450_data = {
+	SC8280XP_SND_DATA("sm8450"),
+};
+
+static const struct sc8280xp_sndcard_data sm8550_data = {
+	SC8280XP_SND_DATA("sm8550"),
+};
+
+static const struct sc8280xp_sndcard_data sm8650_data = {
+	SC8280XP_SND_DATA("sm8650"),
+};
+
+static const struct sc8280xp_sndcard_data sm8750_data = {
+	SC8280XP_SND_DATA("sm8750"),
+};
+
 static const struct of_device_id snd_sc8280xp_dt_match[] = {
-	{.compatible = "qcom,kaanapali-sndcard", "kaanapali"},
-	{.compatible = "qcom,qcm6490-idp-sndcard", "qcm6490"},
-	{.compatible = "qcom,qcs615-sndcard", "qcs615"},
-	{.compatible = "qcom,qcs6490-rb3gen2-sndcard", "qcs6490"},
-	{.compatible = "qcom,qcs8275-sndcard", "qcs8300"},
-	{.compatible = "qcom,qcs9075-sndcard", "sa8775p"},
-	{.compatible = "qcom,qcs9100-sndcard", "sa8775p"},
-	{.compatible = "qcom,sc8280xp-sndcard", "sc8280xp"},
-	{.compatible = "qcom,sm8450-sndcard", "sm8450"},
-	{.compatible = "qcom,sm8550-sndcard", "sm8550"},
-	{.compatible = "qcom,sm8650-sndcard", "sm8650"},
-	{.compatible = "qcom,sm8750-sndcard", "sm8750"},
+	{ .compatible = "thundercomm,qcs6490-rubikpi3-sndcard", .data = &qcs6490_rubikpi3_data },
+	{ .compatible = "qcom,kaanapali-sndcard", .data = &kaanapali_data },
+	{ .compatible = "qcom,qcm6490-idp-sndcard", .data = &qcm6490_data },
+	{ .compatible = "qcom,qcs615-sndcard", .data = &qcs615_data },
+	{ .compatible = "qcom,qcs6490-rb3gen2-sndcard", .data = &qcs6490_data },
+	{ .compatible = "qcom,qcs8275-sndcard", .data = &qcs8300_data },
+	{ .compatible = "qcom,qcs9075-sndcard", .data = &sa8775p_data },
+	{ .compatible = "qcom,qcs9100-sndcard", .data = &sa8775p_data },
+	{ .compatible = "qcom,sc8280xp-sndcard", .data = &sc8280xp_data },
+	{ .compatible = "qcom,sm8450-sndcard", .data = &sm8450_data },
+	{ .compatible = "qcom,sm8550-sndcard", .data = &sm8550_data },
+	{ .compatible = "qcom,sm8650-sndcard", .data = &sm8650_data },
+	{ .compatible = "qcom,sm8750-sndcard", .data = &sm8750_data },
 	{}
 };
 

-- 
2.43.0