ASoC: audio-graph-card: merge audio-graph-scu-card

audio-graph-card and audio-graph-scu-card are very similar driver,
but the former is supporting normal sound card,
the latter is supporting DPCM sound card.

We couldn't use normal sound and DPCM sound in same sound card by
audio-graph-card.
This patch merges both sound card into it.
Now we can use both feature on same driver.

audio-grap-card is now supporting .compatible = "audio-graph-scu-card".

Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Tested-by: Tony Lindgren <tony@atomide.com>
Signed-off-by: Mark Brown <broonie@kernel.org>

2 files changed, 320 insertions, 47 deletions

diff --git a/sound/soc/generic/Kconfig b/sound/soc/generic/Kconfig
index fa5aff9c1041..5395782424b4 100644
--- a/sound/soc/generic/Kconfig
+++ b/sound/soc/generic/Kconfig
@@ -22,6 +22,7 @@ config SND_AUDIO_GRAPH_CARD
         help
           This option enables generic simple sound card support
           with OF-graph DT bindings.
+          It also support DPCM of multi CPU single Codec ststem.
 
 config SND_AUDIO_GRAPH_SCU_CARD
         tristate "ASoC Audio Graph SCU sound card support"
diff --git a/sound/soc/generic/audio-graph-card.c b/sound/soc/generic/audio-graph-card.c
index 1da9532ef897..8ec09bc711f8 100644
--- a/sound/soc/generic/audio-graph-card.c
+++ b/sound/soc/generic/audio-graph-card.c
@@ -27,6 +27,8 @@ struct graph_card_data {
                 struct asoc_simple_dai *codec_dai;
                 struct snd_soc_dai_link_component codecs; /* single codec */
                 struct snd_soc_dai_link_component platform;
+                struct asoc_simple_card_data adata;
+                struct snd_soc_codec_conf *codec_conf;
                 unsigned int mclk_fs;
         } *dai_props;
         unsigned int mclk_fs;
@@ -34,6 +36,8 @@ struct graph_card_data {
         struct asoc_simple_jack mic_jack;
         struct snd_soc_dai_link *dai_link;
         struct asoc_simple_dai *dais;
+        struct asoc_simple_card_data adata;
+        struct snd_soc_codec_conf *codec_conf;
         struct gpio_desc *pa_gpio;
 };
 
@@ -42,6 +46,8 @@ struct graph_card_data {
 #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))
 
+#define PREFIX  "audio-graph-card,"
+
 static int asoc_graph_card_outdrv_event(struct snd_soc_dapm_widget *w,
                                         struct snd_kcontrol *kcontrol,
                                         int event)
@@ -156,7 +162,140 @@ static int asoc_graph_card_dai_init(struct snd_soc_pcm_runtime *rtd)
         return 0;
 }
 
-static int asoc_graph_card_dai_link_of(struct device_node *cpu_port,
+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 graph_dai_props *dai_props = graph_priv_to_props(priv, rtd->num);
+
+        asoc_simple_card_convert_fixup(&dai_props->adata, params);
+
+        /* overwrite by top level adata if exist */
+        asoc_simple_card_convert_fixup(&priv->adata, params);
+
+        return 0;
+}
+
+static int asoc_graph_card_dai_link_of_dpcm(struct device_node *cpu_ep,
+                                            struct device_node *codec_ep,
+                                            struct graph_card_data *priv,
+                                            int *dai_idx, int link_idx,
+                                            int *conf_idx, int is_cpu)
+{
+        struct device *dev = graph_priv_to_dev(priv);
+        struct snd_soc_dai_link *dai_link = graph_priv_to_link(priv, link_idx);
+        struct graph_dai_props *dai_props = graph_priv_to_props(priv, link_idx);
+        struct snd_soc_card *card = graph_priv_to_card(priv);
+        struct device_node *ep = is_cpu ? cpu_ep : codec_ep;
+        struct device_node *node = of_graph_get_port_parent(ep);
+        struct asoc_simple_dai *dai;
+        int ret;
+
+        dev_dbg(dev, "link_of DPCM (for %s)\n", is_cpu ? "CPU" : "Codec");
+
+        if (is_cpu) {
+                struct snd_soc_dai_link_component *codecs;
+
+                /* BE is dummy */
+                codecs                  = dai_link->codecs;
+                codecs->of_node         = NULL;
+                codecs->dai_name        = "snd-soc-dummy-dai";
+                codecs->name            = "snd-soc-dummy";
+
+                /* FE settings */
+                dai_link->dynamic               = 1;
+                dai_link->dpcm_merged_format    = 1;
+
+                dai =
+                dai_props->cpu_dai      = &priv->dais[(*dai_idx)++];
+
+                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);
+                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,
+                        of_graph_get_endpoint_count(dai_link->cpu_of_node) == 1);
+        } else {
+                struct snd_soc_codec_conf *cconf;
+
+                /* 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;
+
+                dai =
+                dai_props->codec_dai    = &priv->dais[(*dai_idx)++];
+
+                cconf =
+                dai_props->codec_conf   = &priv->codec_conf[(*conf_idx)++];
+
+                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);
+                if (ret < 0)
+                        return ret;
+
+                ret = asoc_simple_card_set_dailink_name(dev, dai_link,
+                                                        "be.%s",
+                                                        dai_link->codecs->dai_name);
+                if (ret < 0)
+                        return ret;
+
+                /* check "prefix" from top node */
+                snd_soc_of_parse_audio_prefix(card, cconf,
+                                              dai_link->codecs->of_node,
+                                              "prefix");
+                /* check "prefix" from each node if top doesn't have */
+                if (!cconf->of_node)
+                        snd_soc_of_parse_node_prefix(node, cconf,
+                                                     dai_link->codecs->of_node,
+                                                     PREFIX "prefix");
+        }
+
+        asoc_simple_card_parse_convert(dev, node, PREFIX, &dai_props->adata);
+
+        ret = asoc_simple_card_of_parse_tdm(ep, dai);
+        if (ret)
+                return ret;
+
+        ret = asoc_simple_card_canonicalize_dailink(dai_link);
+        if (ret < 0)
+                return ret;
+
+        of_property_read_u32(ep,   "mclk-fs", &dai_props->mclk_fs);
+
+        ret = asoc_simple_card_parse_daifmt(dev, cpu_ep, codec_ep,
+                                            NULL, &dai_link->dai_fmt);
+        if (ret < 0)
+                return ret;
+
+        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;
+
+        return 0;
+}
+
+static int asoc_graph_card_dai_link_of(struct device_node *cpu_ep,
+                                        struct device_node *codec_ep,
                                         struct graph_card_data *priv,
                                         int *dai_idx, int link_idx)
 {
@@ -165,10 +304,10 @@ static int asoc_graph_card_dai_link_of(struct device_node *cpu_port,
         struct graph_dai_props *dai_props = graph_priv_to_props(priv, link_idx);
         struct asoc_simple_dai *cpu_dai;
         struct asoc_simple_dai *codec_dai;
-        struct device_node *cpu_ep    = of_get_next_child(cpu_port, NULL);
-        struct device_node *codec_ep = of_graph_get_remote_endpoint(cpu_ep);
         int ret;
 
+        dev_dbg(dev, "link_of\n");
+
         cpu_dai                 =
         dai_props->cpu_dai      = &priv->dais[(*dai_idx)++];
         codec_dai               =
@@ -177,45 +316,45 @@ static int asoc_graph_card_dai_link_of(struct device_node *cpu_port,
         ret = asoc_simple_card_parse_daifmt(dev, cpu_ep, codec_ep,
                                             NULL, &dai_link->dai_fmt);
         if (ret < 0)
-                goto dai_link_of_err;
+                return ret;
 
         of_property_read_u32(cpu_ep,   "mclk-fs", &dai_props->mclk_fs);
         of_property_read_u32(codec_ep, "mclk-fs", &dai_props->mclk_fs);
 
         ret = asoc_simple_card_parse_graph_cpu(cpu_ep, dai_link);
         if (ret < 0)
-                goto dai_link_of_err;
+                return ret;
 
         ret = asoc_simple_card_parse_graph_codec(codec_ep, dai_link);
         if (ret < 0)
-                goto dai_link_of_err;
+                return ret;
 
         ret = asoc_simple_card_of_parse_tdm(cpu_ep, cpu_dai);
         if (ret < 0)
-                goto dai_link_of_err;
+                return ret;
 
         ret = asoc_simple_card_of_parse_tdm(codec_ep, codec_dai);
         if (ret < 0)
-                goto dai_link_of_err;
+                return ret;
 
         ret = asoc_simple_card_parse_clk_cpu(dev, cpu_ep, dai_link, cpu_dai);
         if (ret < 0)
-                goto dai_link_of_err;
+                return ret;
 
         ret = asoc_simple_card_parse_clk_codec(dev, codec_ep, dai_link, codec_dai);
         if (ret < 0)
-                goto dai_link_of_err;
+                return ret;
 
         ret = asoc_simple_card_canonicalize_dailink(dai_link);
         if (ret < 0)
-                goto dai_link_of_err;
+                return ret;
 
         ret = asoc_simple_card_set_dailink_name(dev, dai_link,
                                                 "%s-%s",
                                                 dai_link->cpu_dai_name,
                                                 dai_link->codecs->dai_name);
         if (ret < 0)
-                goto dai_link_of_err;
+                return ret;
 
         dai_link->ops = &asoc_graph_card_ops;
         dai_link->init = asoc_graph_card_dai_init;
@@ -223,11 +362,7 @@ static int asoc_graph_card_dai_link_of(struct device_node *cpu_port,
         asoc_simple_card_canonicalize_cpu(dai_link,
                 of_graph_get_endpoint_count(dai_link->cpu_of_node) == 1);
 
-dai_link_of_err:
-        of_node_put(cpu_ep);
-        of_node_put(codec_ep);
-
-        return ret;
+        return 0;
 }
 
 static int asoc_graph_card_parse_of(struct graph_card_data *priv)
@@ -236,8 +371,14 @@ static int asoc_graph_card_parse_of(struct graph_card_data *priv)
         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              = NULL;
+        struct device_node *codec_ep            = NULL;
+        struct device_node *codec_port          = NULL;
+        struct device_node *codec_port_old      = NULL;
         int rc, ret;
-        int link_idx, dai_idx;
+        int link_idx, dai_idx, conf_idx;
+        int cpu;
 
         ret = asoc_simple_card_of_parse_widgets(card, NULL);
         if (ret < 0)
@@ -247,35 +388,159 @@ static int asoc_graph_card_parse_of(struct graph_card_data *priv)
         if (ret < 0)
                 return ret;
 
+        asoc_simple_card_parse_convert(dev, node, NULL, &priv->adata);
+
         /* Factor to mclk, used in hw_params() */
         of_property_read_u32(node, "mclk-fs", &priv->mclk_fs);
 
-        link_idx = 0;
-        dai_idx = 0;
-        of_for_each_phandle(&it, rc, node, "dais", NULL, 0) {
-                ret = asoc_graph_card_dai_link_of(it.node, priv,
-                                                  &dai_idx, link_idx++);
-                if (ret < 0) {
-                        of_node_put(it.node);
-
-                        return ret;
+        link_idx        = 0;
+        dai_idx         = 0;
+        conf_idx        = 0;
+        codec_port_old  = NULL;
+        for (cpu = 1; cpu >= 0; cpu--) {
+                /*
+                 * Detect all CPU first, and Detect all Codec 2nd.
+                 *
+                 * In Normal sound case, all DAIs are detected
+                 * as "CPU-Codec".
+                 *
+                 * In DPCM sound case,
+                 * all CPUs   are detected as "CPU-dummy", and
+                 * all Codecs are detected as "dummy-Codec".
+                 * To avoid random sub-device numbering,
+                 * detect "dummy-Codec" in last;
+                 */
+                of_for_each_phandle(&it, rc, node, "dais", NULL, 0) {
+                        cpu_port = it.node;
+                        cpu_ep   = NULL;
+                        while (1) {
+                                cpu_ep = of_get_next_child(cpu_port, cpu_ep);
+                                if (!cpu_ep)
+                                        break;
+
+                                codec_ep   = of_graph_get_remote_endpoint(cpu_ep);
+                                codec_port = of_get_parent(codec_ep);
+
+                                of_node_put(codec_ep);
+                                of_node_put(codec_port);
+
+                                dev_dbg(dev, "%pOFf <-> %pOFf\n", cpu_ep, codec_ep);
+
+                                if (of_get_child_count(codec_port) > 1) {
+                                        /*
+                                         * for DPCM sound
+                                         */
+                                        if (!cpu) {
+                                                if (codec_port_old == codec_port)
+                                                        continue;
+                                                codec_port_old = codec_port;
+                                        }
+                                        ret = asoc_graph_card_dai_link_of_dpcm(
+                                                cpu_ep, codec_ep, priv,
+                                                &dai_idx, link_idx++,
+                                                &conf_idx, cpu);
+                                } else if (cpu) {
+                                        /*
+                                         * for Normal sound
+                                         */
+                                        ret = asoc_graph_card_dai_link_of(
+                                                cpu_ep, codec_ep, priv,
+                                                &dai_idx, link_idx++);
+                                }
+                                if (ret < 0)
+                                        return ret;
+                        }
                 }
         }
 
         return asoc_simple_card_parse_card_name(card, NULL);
 }
 
-static int asoc_graph_get_dais_count(struct device *dev)
+static void asoc_graph_get_dais_count(struct device *dev,
+                                      int *link_num,
+                                      int *dais_num,
+                                      int *ccnf_num)
 {
         struct of_phandle_iterator it;
         struct device_node *node = dev->of_node;
-        int count = 0;
+        struct device_node *cpu_port;
+        struct device_node *cpu_ep;
+        struct device_node *codec_ep;
+        struct device_node *codec_port;
+        struct device_node *codec_port_old;
+        struct device_node *codec_port_old2;
         int rc;
 
-        of_for_each_phandle(&it, rc, node, "dais", NULL, 0)
-                count++;
-
-        return count;
+        /*
+         * link_num :   number of links.
+         *              CPU-Codec / CPU-dummy / dummy-Codec
+         * dais_num :   number of DAIs
+         * ccnf_num :   number of codec_conf
+         *              same number for "dummy-Codec"
+         *
+         * ex1)
+         * CPU0 --- Codec0      link : 5
+         * CPU1 --- Codec1      dais : 7
+         * CPU2 -/              ccnf : 1
+         * CPU3 --- Codec2
+         *
+         *      => 5 links = 2xCPU-Codec + 2xCPU-dummy + 1xdummy-Codec
+         *      => 7 DAIs  = 4xCPU + 3xCodec
+         *      => 1 ccnf  = 1xdummy-Codec
+         *
+         * ex2)
+         * CPU0 --- Codec0      link : 5
+         * CPU1 --- Codec1      dais : 6
+         * CPU2 -/              ccnf : 1
+         * CPU3 -/
+         *
+         *      => 5 links = 1xCPU-Codec + 3xCPU-dummy + 1xdummy-Codec
+         *      => 6 DAIs  = 4xCPU + 2xCodec
+         *      => 1 ccnf  = 1xdummy-Codec
+         *
+         * ex3)
+         * CPU0 --- Codec0      link : 6
+         * CPU1 -/              dais : 6
+         * CPU2 --- Codec1      ccnf : 2
+         * CPU3 -/
+         *
+         *      => 6 links = 0xCPU-Codec + 4xCPU-dummy + 2xdummy-Codec
+         *      => 6 DAIs  = 4xCPU + 2xCodec
+         *      => 2 ccnf  = 2xdummy-Codec
+         */
+        codec_port_old = NULL;
+        codec_port_old2 = NULL;
+        of_for_each_phandle(&it, rc, node, "dais", NULL, 0) {
+                cpu_port = it.node;
+                cpu_ep   = NULL;
+                while (1) {
+                        cpu_ep = of_get_next_child(cpu_port, cpu_ep);
+                        if (!cpu_ep)
+                                break;
+
+                        codec_ep = of_graph_get_remote_endpoint(cpu_ep);
+                        codec_port = of_get_parent(codec_ep);
+
+                        of_node_put(codec_ep);
+                        of_node_put(codec_port);
+
+                        (*link_num)++;
+                        (*dais_num)++;
+
+                        if (codec_port_old == codec_port) {
+                                if (codec_port_old2 != codec_port_old) {
+                                        (*link_num)++;
+                                        (*ccnf_num)++;
+                                }
+
+                                codec_port_old2 = codec_port_old;
+                                continue;
+                        }
+
+                        (*dais_num)++;
+                        codec_port_old = codec_port;
+                }
+        }
 }
 
 static int asoc_graph_soc_card_probe(struct snd_soc_card *card)
@@ -302,20 +567,23 @@ static int asoc_graph_card_probe(struct platform_device *pdev)
         struct asoc_simple_dai *dais;
         struct device *dev = &pdev->dev;
         struct snd_soc_card *card;
-        int num, ret, i;
+        struct snd_soc_codec_conf *cconf;
+        int lnum = 0, dnum = 0, cnum = 0;
+        int ret, i;
 
         /* 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)
+        asoc_graph_get_dais_count(dev, &lnum, &dnum, &cnum);
+        if (!lnum || !dnum)
                 return -EINVAL;
 
-        dai_props = devm_kcalloc(dev, num, sizeof(*dai_props), GFP_KERNEL);
-        dai_link  = devm_kcalloc(dev, num, sizeof(*dai_link), GFP_KERNEL);
-        dais      = devm_kcalloc(dev, num * 2, sizeof(*dais), GFP_KERNEL);
+        dai_props = devm_kcalloc(dev, lnum, sizeof(*dai_props), GFP_KERNEL);
+        dai_link  = devm_kcalloc(dev, lnum, sizeof(*dai_link),  GFP_KERNEL);
+        dais      = devm_kcalloc(dev, dnum, sizeof(*dais),      GFP_KERNEL);
+        cconf     = devm_kcalloc(dev, cnum, sizeof(*cconf),     GFP_KERNEL);
         if (!dai_props || !dai_link || !dais)
                 return -ENOMEM;
 
@@ -325,7 +593,7 @@ static int asoc_graph_card_probe(struct platform_device *pdev)
          * see
          *      soc-core.c :: snd_soc_init_multicodec()
          */
-        for (i = 0; i < num; i++) {
+        for (i = 0; i < lnum; i++) {
                 dai_link[i].codecs      = &dai_props[i].codecs;
                 dai_link[i].num_codecs  = 1;
                 dai_link[i].platform    = &dai_props[i].platform;
@@ -341,16 +609,19 @@ static int asoc_graph_card_probe(struct platform_device *pdev)
         priv->dai_props                 = dai_props;
         priv->dai_link                  = dai_link;
         priv->dais                      = dais;
+        priv->codec_conf                = cconf;
 
         /* Init snd_soc_card */
         card = graph_priv_to_card(priv);
-        card->owner     = THIS_MODULE;
-        card->dev       = dev;
-        card->dai_link  = dai_link;
-        card->num_links = num;
-        card->dapm_widgets = asoc_graph_card_dapm_widgets;
-        card->num_dapm_widgets = ARRAY_SIZE(asoc_graph_card_dapm_widgets);
-        card->probe     = asoc_graph_soc_card_probe;
+        card->owner             = THIS_MODULE;
+        card->dev               = dev;
+        card->dai_link          = dai_link;
+        card->num_links         = lnum;
+        card->dapm_widgets      = asoc_graph_card_dapm_widgets;
+        card->num_dapm_widgets  = ARRAY_SIZE(asoc_graph_card_dapm_widgets);
+        card->probe             = asoc_graph_soc_card_probe;
+        card->codec_conf        = cconf;
+        card->num_configs       = cnum;
 
         ret = asoc_graph_card_parse_of(priv);
         if (ret < 0) {
@@ -381,6 +652,7 @@ static int asoc_graph_card_remove(struct platform_device *pdev)
 
 static const struct of_device_id asoc_graph_of_match[] = {
         { .compatible = "audio-graph-card", },
+        { .compatible = "audio-graph-scu-card", },
         {},
 };
 MODULE_DEVICE_TABLE(of, asoc_graph_of_match);