// 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);