ASoC: add audio-graph-scu-card support (87f937b4) · Commits · 戴 / test

sound/soc/generic/Kconfig

+9 −0

Original line number	Diff line number	Diff line
		@@ -22,3 +22,12 @@ config SND_AUDIO_GRAPH_CARD
		help
		This option enables generic simple simple sound card support
		with OF-graph DT bindings.

		config SND_AUDIO_GRAPH_SCU_CARD
		tristate "ASoC Audio Graph SCU sound card support"
		depends on OF
		select SND_SIMPLE_CARD_UTILS
		help
		This option enables generic simple SCU sound card support
		with OF-graph DT bindings.
		It supports DPCM of multi CPU single Codec ststem.

sound/soc/generic/Makefile

+2 −0

Original line number	Diff line number	Diff line
		@@ -2,8 +2,10 @@ snd-soc-simple-card-utils-objs := simple-card-utils.o
		snd-soc-simple-card-objs := simple-card.o
		snd-soc-simple-scu-card-objs := simple-scu-card.o
		snd-soc-audio-graph-card-objs := audio-graph-card.o
		snd-soc-audio-graph-scu-card-objs := audio-graph-scu-card.o

		obj-$(CONFIG_SND_SIMPLE_CARD_UTILS) += snd-soc-simple-card-utils.o
		obj-$(CONFIG_SND_SIMPLE_CARD) += snd-soc-simple-card.o
		obj-$(CONFIG_SND_SIMPLE_SCU_CARD) += snd-soc-simple-scu-card.o
		obj-$(CONFIG_SND_AUDIO_GRAPH_CARD) += snd-soc-audio-graph-card.o
		obj-$(CONFIG_SND_AUDIO_GRAPH_SCU_CARD) += snd-soc-audio-graph-scu-card.o

sound/soc/generic/audio-graph-scu-card.c

0 → 100644

+416 −0

Original line number	Diff line number	Diff line
		/*
		* ASoC audio graph SCU sound card support
		*
		* Copyright (C) 2017 Renesas Solutions Corp.
		* Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
		*
		* based on
		* ${LINUX}/sound/soc/generic/simple-scu-card.c
		* ${LINUX}/sound/soc/generic/audio-graph-card.c
		*
		* This program is free software; you can redistribute it and/or modify
		* it under the terms of the GNU General Public License version 2 as
		* published by the Free Software Foundation.
		*/
		#include <linux/clk.h>
		#include <linux/device.h>
		#include <linux/gpio.h>
		#include <linux/module.h>
		#include <linux/of.h>
		#include <linux/of_device.h>
		#include <linux/of_gpio.h>
		#include <linux/of_graph.h>
		#include <linux/platform_device.h>
		#include <linux/string.h>
		#include <sound/jack.h>
		#include <sound/simple_card_utils.h>

		struct graph_card_data {
		struct snd_soc_card snd_card;
		struct snd_soc_codec_conf codec_conf;
		struct asoc_simple_dai *dai_props;
		struct snd_soc_dai_link *dai_link;
		u32 convert_rate;
		u32 convert_channels;
		};

		#define graph_priv_to_card(priv) (&(priv)->snd_card)
		#define graph_priv_to_props(priv, i) ((priv)->dai_props + (i))
		#define graph_priv_to_dev(priv) (graph_priv_to_card(priv)->dev)
		#define graph_priv_to_link(priv, i) (graph_priv_to_card(priv)->dai_link + (i))

		static int asoc_graph_card_startup(struct snd_pcm_substream *substream)
		{
		struct snd_soc_pcm_runtime *rtd = substream->private_data;
		struct graph_card_data *priv = snd_soc_card_get_drvdata(rtd->card);
		struct asoc_simple_dai *dai_props = graph_priv_to_props(priv, rtd->num);

		return clk_prepare_enable(dai_props->clk);
		}

		static void asoc_graph_card_shutdown(struct snd_pcm_substream *substream)
		{
		struct snd_soc_pcm_runtime *rtd = substream->private_data;
		struct graph_card_data *priv = snd_soc_card_get_drvdata(rtd->card);
		struct asoc_simple_dai *dai_props = graph_priv_to_props(priv, rtd->num);

		clk_disable_unprepare(dai_props->clk);
		}

		static struct snd_soc_ops asoc_graph_card_ops = {
		.startup = asoc_graph_card_startup,
		.shutdown = asoc_graph_card_shutdown,
		};

		static int asoc_graph_card_dai_init(struct snd_soc_pcm_runtime *rtd)
		{
		struct graph_card_data *priv = snd_soc_card_get_drvdata(rtd->card);
		struct snd_soc_dai *dai;
		struct snd_soc_dai_link *dai_link;
		struct asoc_simple_dai *dai_props;
		int num = rtd->num;

		dai_link = graph_priv_to_link(priv, num);
		dai_props = graph_priv_to_props(priv, num);
		dai = dai_link->dynamic ?
		rtd->cpu_dai :
		rtd->codec_dai;

		return asoc_simple_card_init_dai(dai, dai_props);
		}

		static int asoc_graph_card_be_hw_params_fixup(struct snd_soc_pcm_runtime *rtd,
		struct snd_pcm_hw_params *params)
		{
		struct graph_card_data *priv = snd_soc_card_get_drvdata(rtd->card);
		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);

		if (priv->convert_rate)
		rate->min =
		rate->max = priv->convert_rate;

		if (priv->convert_channels)
		channels->min =
		channels->max = priv->convert_channels;

		return 0;
		}

		static int asoc_graph_card_dai_link_of(struct device_node *ep,
		struct graph_card_data *priv,
		unsigned int daifmt,
		int idx, int is_fe)
		{
		struct device *dev = graph_priv_to_dev(priv);
		struct snd_soc_dai_link *dai_link = graph_priv_to_link(priv, idx);
		struct asoc_simple_dai *dai_props = graph_priv_to_props(priv, idx);
		struct snd_soc_card *card = graph_priv_to_card(priv);
		int ret;

		if (is_fe) {
		/* BE is dummy */
		dai_link->codec_of_node = NULL;
		dai_link->codec_dai_name = "snd-soc-dummy-dai";
		dai_link->codec_name = "snd-soc-dummy";

		/* FE settings */
		dai_link->dynamic = 1;
		dai_link->dpcm_merged_format = 1;

		ret = asoc_simple_card_parse_graph_cpu(ep, dai_link);
		if (ret)
		return ret;

		ret = asoc_simple_card_parse_clk_cpu(dev, ep, dai_link, dai_props);
		if (ret < 0)
		return ret;

		ret = asoc_simple_card_set_dailink_name(dev, dai_link,
		"fe.%s",
		dai_link->cpu_dai_name);
		if (ret < 0)
		return ret;

		/* card->num_links includes Codec */
		asoc_simple_card_canonicalize_cpu(dai_link,
		(card->num_links - 1) == 1);
		} else {
		/* FE is dummy */
		dai_link->cpu_of_node = NULL;
		dai_link->cpu_dai_name = "snd-soc-dummy-dai";
		dai_link->cpu_name = "snd-soc-dummy";

		/* BE settings */
		dai_link->no_pcm = 1;
		dai_link->be_hw_params_fixup = asoc_graph_card_be_hw_params_fixup;

		ret = asoc_simple_card_parse_graph_codec(ep, dai_link);
		if (ret < 0)
		return ret;

		ret = asoc_simple_card_parse_clk_codec(dev, ep, dai_link, dai_props);
		if (ret < 0)
		return ret;

		ret = asoc_simple_card_set_dailink_name(dev, dai_link,
		"be.%s",
		dai_link->codec_dai_name);
		if (ret < 0)
		return ret;

		snd_soc_of_parse_audio_prefix(card,
		&priv->codec_conf,
		dai_link->codec_of_node,
		"prefix");
		}

		ret = snd_soc_of_parse_tdm_slot(ep,
		&dai_props->tx_slot_mask,
		&dai_props->rx_slot_mask,
		&dai_props->slots,
		&dai_props->slot_width);
		if (ret)
		return ret;

		ret = asoc_simple_card_canonicalize_dailink(dai_link);
		if (ret < 0)
		return ret;

		dai_link->dai_fmt = daifmt;
		dai_link->dpcm_playback = 1;
		dai_link->dpcm_capture = 1;
		dai_link->ops = &asoc_graph_card_ops;
		dai_link->init = asoc_graph_card_dai_init;

		dev_dbg(dev, "\t%s / %04x / %d\n",
		dai_link->name,
		dai_link->dai_fmt,
		dai_props->sysclk);

		return 0;
		}

		static int asoc_graph_card_parse_of(struct graph_card_data *priv)
		{
		struct of_phandle_iterator it;
		struct device *dev = graph_priv_to_dev(priv);
		struct snd_soc_card *card = graph_priv_to_card(priv);
		struct device_node *node = dev->of_node;
		struct device_node *cpu_port;
		struct device_node *cpu_ep;
		struct device_node *codec_ep;
		struct device_node *rcpu_ep;
		unsigned int daifmt = 0;
		int dai_idx, ret;
		int rc, codec;

		if (!node)
		return -EINVAL;

		/*
		* we need to consider "widgets", "mclk-fs" around here
		* see simple-card
		*/

		ret = snd_soc_of_parse_audio_routing(card, "routing");
		if (ret)
		return ret;

		/* sampling rate convert */
		of_property_read_u32(node, "convert-rate", &priv->convert_rate);

		/* channels transfer */
		of_property_read_u32(node, "convert-channels", &priv->convert_channels);

		/*
		* it supports multi CPU, single CODEC only here
		* see asoc_graph_get_dais_count
		*/

		/* find 1st codec */
		of_for_each_phandle(&it, rc, node, "dais", NULL, 0) {
		cpu_port = it.node;
		cpu_ep = of_get_next_child(cpu_port, NULL);
		codec_ep = of_graph_get_remote_endpoint(cpu_ep);
		rcpu_ep = of_graph_get_remote_endpoint(codec_ep);

		of_node_put(cpu_port);
		of_node_put(cpu_ep);
		of_node_put(codec_ep);
		of_node_put(rcpu_ep);

		if (!codec_ep)
		continue;

		if (rcpu_ep != cpu_ep) {
		dev_err(dev, "remote-endpoint missmatch (%s/%s/%s)\n",
		cpu_ep->name, codec_ep->name, rcpu_ep->name);
		ret = -EINVAL;
		goto parse_of_err;
		}

		ret = asoc_simple_card_parse_daifmt(dev, cpu_ep, codec_ep,
		NULL, &daifmt);
		if (ret < 0)
		goto parse_of_err;
		}

		dai_idx = 0;
		for (codec = 0; codec < 2; codec++) {
		/*
		* To listup valid sounds continuously,
		* detect all CPU-dummy first, and
		* detect all dummy-Codec second
		*/
		of_for_each_phandle(&it, rc, node, "dais", NULL, 0) {
		cpu_port = it.node;
		cpu_ep = of_get_next_child(cpu_port, NULL);
		codec_ep = of_graph_get_remote_endpoint(cpu_ep);

		of_node_put(cpu_port);
		of_node_put(cpu_ep);
		of_node_put(codec_ep);

		if (codec) {
		if (!codec_ep)
		continue;

		/* Back-End (= Codec) */
		ret = asoc_graph_card_dai_link_of(codec_ep, priv, daifmt, dai_idx++, 0);
		if (ret < 0)
		goto parse_of_err;
		} else {
		/* Front-End (= CPU) */
		ret = asoc_graph_card_dai_link_of(cpu_ep, priv, daifmt, dai_idx++, 1);
		if (ret < 0)
		goto parse_of_err;
		}
		}
		}

		ret = asoc_simple_card_parse_card_name(card, NULL);
		if (ret)
		goto parse_of_err;

		dev_dbg(dev, "New card: %s\n",
		card->name ? card->name : "");
		dev_dbg(dev, "convert_rate %d\n", priv->convert_rate);
		dev_dbg(dev, "convert_channels %d\n", priv->convert_channels);

		ret = 0;

		parse_of_err:
		return ret;
		}

		static int asoc_graph_get_dais_count(struct device *dev)
		{
		struct of_phandle_iterator it;
		struct device_node *node = dev->of_node;
		struct device_node *cpu_port;
		struct device_node *cpu_ep;
		struct device_node *codec_ep;
		int count = 0;
		int rc;

		of_for_each_phandle(&it, rc, node, "dais", NULL, 0) {
		cpu_port = it.node;
		cpu_ep = of_get_next_child(cpu_port, NULL);
		codec_ep = of_graph_get_remote_endpoint(cpu_ep);

		of_node_put(cpu_port);
		of_node_put(cpu_ep);
		of_node_put(codec_ep);

		if (cpu_ep)
		count++;
		if (codec_ep)
		count++;
		}

		return count;
		}

		static int asoc_graph_card_probe(struct platform_device *pdev)
		{
		struct graph_card_data *priv;
		struct snd_soc_dai_link *dai_link;
		struct asoc_simple_dai *dai_props;
		struct device *dev = &pdev->dev;
		struct snd_soc_card *card;
		int num, ret;

		/* Allocate the private data and the DAI link array */
		priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
		if (!priv)
		return -ENOMEM;

		num = asoc_graph_get_dais_count(dev);
		if (num == 0)
		return -EINVAL;

		dai_props = devm_kzalloc(dev, sizeof(dai_props) num, GFP_KERNEL);
		dai_link = devm_kzalloc(dev, sizeof(dai_link) num, GFP_KERNEL);
		if (!dai_props \|\| !dai_link)
		return -ENOMEM;

		priv->dai_props = dai_props;
		priv->dai_link = dai_link;

		/* Init snd_soc_card */
		card = graph_priv_to_card(priv);
		card->owner = THIS_MODULE;
		card->dev = dev;
		card->dai_link = priv->dai_link;
		card->num_links = num;
		card->codec_conf = &priv->codec_conf;
		card->num_configs = 1;

		ret = asoc_graph_card_parse_of(priv);
		if (ret < 0) {
		if (ret != -EPROBE_DEFER)
		dev_err(dev, "parse error %d\n", ret);
		goto err;
		}

		snd_soc_card_set_drvdata(card, priv);

		ret = devm_snd_soc_register_card(dev, card);
		if (ret >= 0)
		return ret;
		err:
		asoc_simple_card_clean_reference(card);

		return ret;
		}

		static int asoc_graph_card_remove(struct platform_device *pdev)
		{
		struct snd_soc_card *card = platform_get_drvdata(pdev);

		return asoc_simple_card_clean_reference(card);
		}

		static const struct of_device_id asoc_graph_of_match[] = {
		{ .compatible = "audio-graph-scu-card", },
		{},
		};
		MODULE_DEVICE_TABLE(of, asoc_graph_of_match);

		static struct platform_driver asoc_graph_card = {
		.driver = {
		.name = "asoc-audio-graph-scu-card",
		.of_match_table = asoc_graph_of_match,
		},
		.probe = asoc_graph_card_probe,
		.remove = asoc_graph_card_remove,
		};
		module_platform_driver(asoc_graph_card);

		MODULE_ALIAS("platform:asoc-audio-graph-scu-card");
		MODULE_LICENSE("GPL v2");
		MODULE_DESCRIPTION("ASoC Audio Graph SCU Sound Card");
		MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>");

Admin message