sound/soc/mediatek/common/mtk-soundcard-driver.c - linux - Git at Google

 // SPDX-License-Identifier: GPL-2.0
 /*
  * mtk-soundcard-driver.c  --  MediaTek soundcard driver common
  *
  * Copyright (c) 2022 MediaTek Inc.
  * Author: Trevor Wu <trevor.wu@mediatek.com>
  */

 #include <linux/module.h>
 #include <linux/of.h>
 #include <sound/soc.h>

 #include "mtk-dsp-sof-common.h"
 #include "mtk-soc-card.h"
 #include "mtk-soundcard-driver.h"

 static int set_card_codec_info(struct snd_soc_card *card,
 			       struct device_node *sub_node,
 			       struct snd_soc_dai_link *dai_link)
 {
 	struct device *dev = card->dev;
 	struct device_node *codec_node;
 	int ret;

 	codec_node = of_get_child_by_name(sub_node, "codec");
 	if (!codec_node) {
 		dev_dbg(dev, "%s no specified codec: setting dummy.\n", dai_link->name);

 		dai_link->codecs = &snd_soc_dummy_dlc;
 		dai_link->num_codecs = 1;
 		dai_link->dynamic = 1;
 		return 0;
 	}

 	/* set card codec info */
 	ret = snd_soc_of_get_dai_link_codecs(dev, codec_node, dai_link);

 	of_node_put(codec_node);

 	if (ret < 0)
 		return dev_err_probe(dev, ret, "%s: codec dai not found\n",
 				     dai_link->name);

 	return 0;
 }

 static int set_dailink_daifmt(struct snd_soc_card *card,
 			      struct device_node *sub_node,
 			      struct snd_soc_dai_link *dai_link)
 {
 	unsigned int daifmt;
 	const char *str;
 	int ret;
 	struct {
 		char *name;
 		unsigned int val;
 	} of_clk_table[] = {
 		{ "cpu",	SND_SOC_DAIFMT_CBC_CFC },
 		{ "codec",	SND_SOC_DAIFMT_CBP_CFP },
 	};

 	daifmt = snd_soc_daifmt_parse_format(sub_node, NULL);
 	if (daifmt) {
 		dai_link->dai_fmt &= SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK;
 		dai_link->dai_fmt |= daifmt;
 	}

 	/*
 	 * check "mediatek,clk-provider = xxx"
 	 * SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK area
 	 */
 	ret = of_property_read_string(sub_node, "mediatek,clk-provider", &str);
 	if (ret == 0) {
 		int i;

 		for (i = 0; i < ARRAY_SIZE(of_clk_table); i++) {
 			if (strcmp(str, of_clk_table[i].name) == 0) {
 				dai_link->dai_fmt &= ~SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK;
 				dai_link->dai_fmt |= of_clk_table[i].val;
 				break;
 			}
 		}
 	}

 	return 0;
 }

 int parse_dai_link_info(struct snd_soc_card *card)
 {
 	struct device *dev = card->dev;
 	struct device_node *sub_node;
 	struct snd_soc_dai_link *dai_link;
 	const char *dai_link_name;
 	int ret, i;

 	/* Loop over all the dai link sub nodes */
 	for_each_available_child_of_node(dev->of_node, sub_node) {
 		if (of_property_read_string(sub_node, "link-name",
 					    &dai_link_name)) {
 			of_node_put(sub_node);
 			return -EINVAL;
 		}

 		for_each_card_prelinks(card, i, dai_link) {
 			if (!strcmp(dai_link_name, dai_link->name))
 				break;
 		}

 		if (i >= card->num_links) {
 			of_node_put(sub_node);
 			return -EINVAL;
 		}

 		ret = set_card_codec_info(card, sub_node, dai_link);
 		if (ret < 0) {
 			of_node_put(sub_node);
 			return ret;
 		}

 		ret = set_dailink_daifmt(card, sub_node, dai_link);
 		if (ret < 0) {
 			of_node_put(sub_node);
 			return ret;
 		}
 	}

 	return 0;
 }
 EXPORT_SYMBOL_GPL(parse_dai_link_info);

 void clean_card_reference(struct snd_soc_card *card)
 {
 	struct snd_soc_dai_link *dai_link;
 	int i;

 	/* release codec reference gotten by set_card_codec_info */
 	for_each_card_prelinks(card, i, dai_link)
 		snd_soc_of_put_dai_link_codecs(dai_link);
 }
 EXPORT_SYMBOL_GPL(clean_card_reference);

 int mtk_soundcard_startup(struct snd_pcm_substream *substream,
 			  enum mtk_pcm_constraint_type ctype)
 {
 	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
 	struct mtk_soc_card_data *soc_card = snd_soc_card_get_drvdata(rtd->card);
 	const struct mtk_pcm_constraints_data *mpc = &soc_card->card_data->pcm_constraints[ctype];
 	int ret;

 	if (unlikely(!mpc))
 		return -EINVAL;

 	ret = snd_pcm_hw_constraint_list(substream->runtime, 0,
 					 SNDRV_PCM_HW_PARAM_RATE,
 					 mpc->rates);
 	if (ret < 0) {
 		dev_err(rtd->dev, "hw_constraint_list rate failed\n");
 		return ret;
 	}

 	ret = snd_pcm_hw_constraint_list(substream->runtime, 0,
 					 SNDRV_PCM_HW_PARAM_CHANNELS,
 					 mpc->channels);
 	if (ret < 0) {
 		dev_err(rtd->dev, "hw_constraint_list channel failed\n");
 		return ret;
 	}

 	return 0;
 }
 EXPORT_SYMBOL_GPL(mtk_soundcard_startup);

 static int mtk_soundcard_playback_startup(struct snd_pcm_substream *substream)
 {
 	return mtk_soundcard_startup(substream, MTK_CONSTRAINT_PLAYBACK);
 }

 const struct snd_soc_ops mtk_soundcard_common_playback_ops = {
 	.startup = mtk_soundcard_playback_startup,
 };
 EXPORT_SYMBOL_GPL(mtk_soundcard_common_playback_ops);

 static int mtk_soundcard_capture_startup(struct snd_pcm_substream *substream)
 {
 	return mtk_soundcard_startup(substream, MTK_CONSTRAINT_CAPTURE);
 }

 const struct snd_soc_ops mtk_soundcard_common_capture_ops = {
 	.startup = mtk_soundcard_capture_startup,
 };
 EXPORT_SYMBOL_GPL(mtk_soundcard_common_capture_ops);

 int mtk_soundcard_common_probe(struct platform_device *pdev)
 {
 	struct device_node *platform_node, *adsp_node;
 	const struct mtk_soundcard_pdata *pdata;
 	struct mtk_soc_card_data *soc_card_data;
 	struct snd_soc_dai_link *orig_dai_link, *dai_link;
 	struct snd_soc_jack *jacks;
 	struct snd_soc_card *card;
 	int i, orig_num_links, ret;
 	bool needs_legacy_probe;

 	pdata = device_get_match_data(&pdev->dev);
 	if (!pdata)
 		return -EINVAL;

 	card = pdata->card_data->card;
 	card->dev = &pdev->dev;
 	orig_dai_link = card->dai_link;
 	orig_num_links = card->num_links;

 	ret = snd_soc_of_parse_card_name(card, "model");
 	if (ret)
 		return ret;

 	if (!card->name) {
 		if (!pdata->card_name)
 			return -EINVAL;

 		card->name = pdata->card_name;
 	}

 	needs_legacy_probe = !of_property_read_bool(pdev->dev.of_node, "audio-routing");
 	if (needs_legacy_probe) {
 		/*
 		 * If we have no .soc_probe() callback there's no way of using
 		 * any legacy probe mechanism, as that cannot not be generic.
 		 */
 		if (!pdata->soc_probe)
 			return -EINVAL;

 		dev_info_once(&pdev->dev, "audio-routing not found: using legacy probe\n");
 	} else {
 		ret = snd_soc_of_parse_audio_routing(card, "audio-routing");
 		if (ret)
 			return ret;
 	}

 	soc_card_data = devm_kzalloc(&pdev->dev, sizeof(*soc_card_data), GFP_KERNEL);
 	if (!soc_card_data)
 		return -ENOMEM;

 	soc_card_data->card_data = pdata->card_data;

 	jacks = devm_kcalloc(card->dev, soc_card_data->card_data->num_jacks,
 			     sizeof(*jacks), GFP_KERNEL);
 	if (!jacks)
 		return -ENOMEM;

 	soc_card_data->card_data->jacks = jacks;

 	platform_node = of_parse_phandle(pdev->dev.of_node, "mediatek,platform", 0);
 	if (!platform_node)
 		return dev_err_probe(&pdev->dev, -EINVAL,
 				     "Property mediatek,platform missing or invalid\n");

 	/* Check if this SoC has an Audio DSP */
 	if (pdata->sof_priv)
 		adsp_node = of_parse_phandle(pdev->dev.of_node, "mediatek,adsp", 0);
 	else
 		adsp_node = NULL;

 	if (adsp_node) {
 		if (of_property_read_bool(pdev->dev.of_node, "mediatek,dai-link")) {
 			ret = mtk_sof_dailink_parse_of(card, pdev->dev.of_node,
 						       "mediatek,dai-link",
 						       card->dai_link, card->num_links);
 			if (ret) {
 				of_node_put(adsp_node);
 				of_node_put(platform_node);
 				return dev_err_probe(&pdev->dev, ret,
 						     "Cannot parse mediatek,dai-link\n");
 			}
 		}

 		soc_card_data->sof_priv = pdata->sof_priv;
 		card->probe = mtk_sof_card_probe;
 		card->late_probe = mtk_sof_card_late_probe;
 		if (!card->topology_shortname_created) {
 			snprintf(card->topology_shortname, 32, "sof-%s", card->name);
 			card->topology_shortname_created = true;
 		}
 		card->name = card->topology_shortname;
 	}

 	/*
 	 * Regardless of whether the ADSP is wanted and/or present in a machine
 	 * specific device tree or not and regardless of whether any AFE_SOF
 	 * link is present, we have to make sure that the platforms->of_node
 	 * is not NULL, and set to either ADSP (adsp_node) or AFE (platform_node).
 	 */
 	for_each_card_prelinks(card, i, dai_link) {
 		if (adsp_node && !strncmp(dai_link->name, "AFE_SOF", strlen("AFE_SOF")))
 			dai_link->platforms->of_node = adsp_node;
 		else if (!dai_link->platforms->name && !dai_link->platforms->of_node)
 			dai_link->platforms->of_node = platform_node;
 	}

 	if (!needs_legacy_probe) {
 		ret = parse_dai_link_info(card);
 		if (ret)
 			goto err_restore_dais;
 	} else {
 		if (adsp_node)
 			of_node_put(adsp_node);
 		of_node_put(platform_node);
 	}

 	if (pdata->soc_probe) {
 		ret = pdata->soc_probe(soc_card_data, needs_legacy_probe);
 		if (ret) {
 			if (!needs_legacy_probe)
 				clean_card_reference(card);
 			goto err_restore_dais;
 		}
 	}
 	snd_soc_card_set_drvdata(card, soc_card_data);

 	ret = devm_snd_soc_register_card(&pdev->dev, card);

 	if (!needs_legacy_probe)
 		clean_card_reference(card);

 	if (ret) {
 		dev_err_probe(&pdev->dev, ret, "Cannot register card\n");
 		goto err_restore_dais;
 	}

 	return 0;

 err_restore_dais:
 	card->dai_link = orig_dai_link;
 	card->num_links = orig_num_links;
 	return ret;
 }
 EXPORT_SYMBOL_GPL(mtk_soundcard_common_probe);
	// SPDX-License-Identifier: GPL-2.0
	/*
	* mtk-soundcard-driver.c -- MediaTek soundcard driver common
	*
	* Copyright (c) 2022 MediaTek Inc.
	* Author: Trevor Wu <trevor.wu@mediatek.com>
	*/

	#include <linux/module.h>
	#include <linux/of.h>
	#include <sound/soc.h>

	#include "mtk-dsp-sof-common.h"
	#include "mtk-soc-card.h"
	#include "mtk-soundcard-driver.h"

	static int set_card_codec_info(struct snd_soc_card *card,
	struct device_node *sub_node,
	struct snd_soc_dai_link *dai_link)
	{
	struct device *dev = card->dev;
	struct device_node *codec_node;
	int ret;

	codec_node = of_get_child_by_name(sub_node, "codec");
	if (!codec_node) {
	dev_dbg(dev, "%s no specified codec: setting dummy.\n", dai_link->name);

	dai_link->codecs = &snd_soc_dummy_dlc;
	dai_link->num_codecs = 1;
	dai_link->dynamic = 1;
	return 0;
	}

	/* set card codec info */
	ret = snd_soc_of_get_dai_link_codecs(dev, codec_node, dai_link);

	of_node_put(codec_node);

	if (ret < 0)
	return dev_err_probe(dev, ret, "%s: codec dai not found\n",
	dai_link->name);

	return 0;
	}

	static int set_dailink_daifmt(struct snd_soc_card *card,
	struct device_node *sub_node,
	struct snd_soc_dai_link *dai_link)
	{
	unsigned int daifmt;
	const char *str;
	int ret;
	struct {
	char *name;
	unsigned int val;
	} of_clk_table[] = {
	{ "cpu", SND_SOC_DAIFMT_CBC_CFC },
	{ "codec", SND_SOC_DAIFMT_CBP_CFP },
	};

	daifmt = snd_soc_daifmt_parse_format(sub_node, NULL);
	if (daifmt) {
	dai_link->dai_fmt &= SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK;
	dai_link->dai_fmt \|= daifmt;
	}

	/*
	* check "mediatek,clk-provider = xxx"
	* SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK area
	*/
	ret = of_property_read_string(sub_node, "mediatek,clk-provider", &str);
	if (ret == 0) {
	int i;

	for (i = 0; i < ARRAY_SIZE(of_clk_table); i++) {
	if (strcmp(str, of_clk_table[i].name) == 0) {
	dai_link->dai_fmt &= ~SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK;
	dai_link->dai_fmt \|= of_clk_table[i].val;
	break;
	}
	}
	}

	return 0;
	}

	int parse_dai_link_info(struct snd_soc_card *card)
	{
	struct device *dev = card->dev;
	struct device_node *sub_node;
	struct snd_soc_dai_link *dai_link;
	const char *dai_link_name;
	int ret, i;

	/* Loop over all the dai link sub nodes */
	for_each_available_child_of_node(dev->of_node, sub_node) {
	if (of_property_read_string(sub_node, "link-name",
	&dai_link_name)) {
	of_node_put(sub_node);
	return -EINVAL;
	}

	for_each_card_prelinks(card, i, dai_link) {
	if (!strcmp(dai_link_name, dai_link->name))
	break;
	}

	if (i >= card->num_links) {
	of_node_put(sub_node);
	return -EINVAL;
	}

	ret = set_card_codec_info(card, sub_node, dai_link);
	if (ret < 0) {
	of_node_put(sub_node);
	return ret;
	}

	ret = set_dailink_daifmt(card, sub_node, dai_link);
	if (ret < 0) {
	of_node_put(sub_node);
	return ret;
	}
	}

	return 0;
	}
	EXPORT_SYMBOL_GPL(parse_dai_link_info);

	void clean_card_reference(struct snd_soc_card *card)
	{
	struct snd_soc_dai_link *dai_link;
	int i;

	/* release codec reference gotten by set_card_codec_info */
	for_each_card_prelinks(card, i, dai_link)
	snd_soc_of_put_dai_link_codecs(dai_link);
	}
	EXPORT_SYMBOL_GPL(clean_card_reference);

	int mtk_soundcard_startup(struct snd_pcm_substream *substream,
	enum mtk_pcm_constraint_type ctype)
	{
	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
	struct mtk_soc_card_data *soc_card = snd_soc_card_get_drvdata(rtd->card);
	const struct mtk_pcm_constraints_data *mpc = &soc_card->card_data->pcm_constraints[ctype];
	int ret;

	if (unlikely(!mpc))
	return -EINVAL;

	ret = snd_pcm_hw_constraint_list(substream->runtime, 0,
	SNDRV_PCM_HW_PARAM_RATE,
	mpc->rates);
	if (ret < 0) {
	dev_err(rtd->dev, "hw_constraint_list rate failed\n");
	return ret;
	}

	ret = snd_pcm_hw_constraint_list(substream->runtime, 0,
	SNDRV_PCM_HW_PARAM_CHANNELS,
	mpc->channels);
	if (ret < 0) {
	dev_err(rtd->dev, "hw_constraint_list channel failed\n");
	return ret;
	}

	return 0;
	}
	EXPORT_SYMBOL_GPL(mtk_soundcard_startup);

	static int mtk_soundcard_playback_startup(struct snd_pcm_substream *substream)
	{
	return mtk_soundcard_startup(substream, MTK_CONSTRAINT_PLAYBACK);
	}

	const struct snd_soc_ops mtk_soundcard_common_playback_ops = {
	.startup = mtk_soundcard_playback_startup,
	};
	EXPORT_SYMBOL_GPL(mtk_soundcard_common_playback_ops);

	static int mtk_soundcard_capture_startup(struct snd_pcm_substream *substream)
	{
	return mtk_soundcard_startup(substream, MTK_CONSTRAINT_CAPTURE);
	}

	const struct snd_soc_ops mtk_soundcard_common_capture_ops = {
	.startup = mtk_soundcard_capture_startup,
	};
	EXPORT_SYMBOL_GPL(mtk_soundcard_common_capture_ops);

	int mtk_soundcard_common_probe(struct platform_device *pdev)
	{
	struct device_node platform_node, adsp_node;
	const struct mtk_soundcard_pdata *pdata;
	struct mtk_soc_card_data *soc_card_data;
	struct snd_soc_dai_link orig_dai_link, dai_link;
	struct snd_soc_jack *jacks;
	struct snd_soc_card *card;
	int i, orig_num_links, ret;
	bool needs_legacy_probe;

	pdata = device_get_match_data(&pdev->dev);
	if (!pdata)
	return -EINVAL;

	card = pdata->card_data->card;
	card->dev = &pdev->dev;
	orig_dai_link = card->dai_link;
	orig_num_links = card->num_links;

	ret = snd_soc_of_parse_card_name(card, "model");
	if (ret)
	return ret;

	if (!card->name) {
	if (!pdata->card_name)
	return -EINVAL;

	card->name = pdata->card_name;
	}

	needs_legacy_probe = !of_property_read_bool(pdev->dev.of_node, "audio-routing");
	if (needs_legacy_probe) {
	/*
	* If we have no .soc_probe() callback there's no way of using
	* any legacy probe mechanism, as that cannot not be generic.
	*/
	if (!pdata->soc_probe)
	return -EINVAL;

	dev_info_once(&pdev->dev, "audio-routing not found: using legacy probe\n");
	} else {
	ret = snd_soc_of_parse_audio_routing(card, "audio-routing");
	if (ret)
	return ret;
	}

	soc_card_data = devm_kzalloc(&pdev->dev, sizeof(*soc_card_data), GFP_KERNEL);
	if (!soc_card_data)
	return -ENOMEM;

	soc_card_data->card_data = pdata->card_data;

	jacks = devm_kcalloc(card->dev, soc_card_data->card_data->num_jacks,
	sizeof(*jacks), GFP_KERNEL);
	if (!jacks)
	return -ENOMEM;

	soc_card_data->card_data->jacks = jacks;

	platform_node = of_parse_phandle(pdev->dev.of_node, "mediatek,platform", 0);
	if (!platform_node)
	return dev_err_probe(&pdev->dev, -EINVAL,
	"Property mediatek,platform missing or invalid\n");

	/* Check if this SoC has an Audio DSP */
	if (pdata->sof_priv)
	adsp_node = of_parse_phandle(pdev->dev.of_node, "mediatek,adsp", 0);
	else
	adsp_node = NULL;

	if (adsp_node) {
	if (of_property_read_bool(pdev->dev.of_node, "mediatek,dai-link")) {
	ret = mtk_sof_dailink_parse_of(card, pdev->dev.of_node,
	"mediatek,dai-link",
	card->dai_link, card->num_links);
	if (ret) {
	of_node_put(adsp_node);
	of_node_put(platform_node);
	return dev_err_probe(&pdev->dev, ret,
	"Cannot parse mediatek,dai-link\n");
	}
	}

	soc_card_data->sof_priv = pdata->sof_priv;
	card->probe = mtk_sof_card_probe;
	card->late_probe = mtk_sof_card_late_probe;
	if (!card->topology_shortname_created) {
	snprintf(card->topology_shortname, 32, "sof-%s", card->name);
	card->topology_shortname_created = true;
	}
	card->name = card->topology_shortname;
	}

	/*
	* Regardless of whether the ADSP is wanted and/or present in a machine
	* specific device tree or not and regardless of whether any AFE_SOF
	* link is present, we have to make sure that the platforms->of_node
	* is not NULL, and set to either ADSP (adsp_node) or AFE (platform_node).
	*/
	for_each_card_prelinks(card, i, dai_link) {
	if (adsp_node && !strncmp(dai_link->name, "AFE_SOF", strlen("AFE_SOF")))
	dai_link->platforms->of_node = adsp_node;
	else if (!dai_link->platforms->name && !dai_link->platforms->of_node)
	dai_link->platforms->of_node = platform_node;
	}

	if (!needs_legacy_probe) {
	ret = parse_dai_link_info(card);
	if (ret)
	goto err_restore_dais;
	} else {
	if (adsp_node)
	of_node_put(adsp_node);
	of_node_put(platform_node);
	}

	if (pdata->soc_probe) {
	ret = pdata->soc_probe(soc_card_data, needs_legacy_probe);
	if (ret) {
	if (!needs_legacy_probe)
	clean_card_reference(card);
	goto err_restore_dais;
	}
	}
	snd_soc_card_set_drvdata(card, soc_card_data);

	ret = devm_snd_soc_register_card(&pdev->dev, card);

	if (!needs_legacy_probe)
	clean_card_reference(card);

	if (ret) {
	dev_err_probe(&pdev->dev, ret, "Cannot register card\n");
	goto err_restore_dais;
	}

	return 0;

	err_restore_dais:
	card->dai_link = orig_dai_link;
	card->num_links = orig_num_links;
	return ret;
	}
	EXPORT_SYMBOL_GPL(mtk_soundcard_common_probe);