linux/sound/soc/generic/simple-scu-card.c
<<
>>
Prefs
   1/*
   2 * ASoC simple SCU sound card support
   3 *
   4 * Copyright (C) 2015 Renesas Solutions Corp.
   5 * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
   6 *
   7 * based on ${LINUX}/sound/soc/generic/simple-card.c
   8 *
   9 * This program is free software; you can redistribute it and/or modify
  10 * it under the terms of the GNU General Public License version 2 as
  11 * published by the Free Software Foundation.
  12 */
  13#include <linux/clk.h>
  14#include <linux/device.h>
  15#include <linux/module.h>
  16#include <linux/of.h>
  17#include <linux/of_device.h>
  18#include <linux/platform_device.h>
  19#include <linux/string.h>
  20#include <sound/jack.h>
  21#include <sound/soc.h>
  22#include <sound/soc-dai.h>
  23#include <sound/simple_card_utils.h>
  24
  25struct simple_card_data {
  26        struct snd_soc_card snd_card;
  27        struct snd_soc_codec_conf codec_conf;
  28        struct asoc_simple_dai *dai_props;
  29        struct snd_soc_dai_link *dai_link;
  30        struct asoc_simple_card_data adata;
  31};
  32
  33#define simple_priv_to_card(priv) (&(priv)->snd_card)
  34#define simple_priv_to_props(priv, i) ((priv)->dai_props + (i))
  35#define simple_priv_to_dev(priv) (simple_priv_to_card(priv)->dev)
  36#define simple_priv_to_link(priv, i) (simple_priv_to_card(priv)->dai_link + (i))
  37
  38#define DAI     "sound-dai"
  39#define CELL    "#sound-dai-cells"
  40#define PREFIX  "simple-audio-card,"
  41
  42static int asoc_simple_card_startup(struct snd_pcm_substream *substream)
  43{
  44        struct snd_soc_pcm_runtime *rtd = substream->private_data;
  45        struct simple_card_data *priv = snd_soc_card_get_drvdata(rtd->card);
  46        struct asoc_simple_dai *dai_props =
  47                simple_priv_to_props(priv, rtd->num);
  48
  49        return asoc_simple_card_clk_enable(dai_props);
  50}
  51
  52static void asoc_simple_card_shutdown(struct snd_pcm_substream *substream)
  53{
  54        struct snd_soc_pcm_runtime *rtd = substream->private_data;
  55        struct simple_card_data *priv = snd_soc_card_get_drvdata(rtd->card);
  56        struct asoc_simple_dai *dai_props =
  57                simple_priv_to_props(priv, rtd->num);
  58
  59        asoc_simple_card_clk_disable(dai_props);
  60}
  61
  62static const struct snd_soc_ops asoc_simple_card_ops = {
  63        .startup = asoc_simple_card_startup,
  64        .shutdown = asoc_simple_card_shutdown,
  65};
  66
  67static int asoc_simple_card_dai_init(struct snd_soc_pcm_runtime *rtd)
  68{
  69        struct simple_card_data *priv = snd_soc_card_get_drvdata(rtd->card);
  70        struct snd_soc_dai *dai;
  71        struct snd_soc_dai_link *dai_link;
  72        struct asoc_simple_dai *dai_props;
  73        int num = rtd->num;
  74
  75        dai_link        = simple_priv_to_link(priv, num);
  76        dai_props       = simple_priv_to_props(priv, num);
  77        dai             = dai_link->dynamic ?
  78                                rtd->cpu_dai :
  79                                rtd->codec_dai;
  80
  81        return asoc_simple_card_init_dai(dai, dai_props);
  82}
  83
  84static int asoc_simple_card_be_hw_params_fixup(struct snd_soc_pcm_runtime *rtd,
  85                                        struct snd_pcm_hw_params *params)
  86{
  87        struct simple_card_data *priv = snd_soc_card_get_drvdata(rtd->card);
  88
  89        asoc_simple_card_convert_fixup(&priv->adata, params);
  90
  91        return 0;
  92}
  93
  94static int asoc_simple_card_dai_link_of(struct device_node *np,
  95                                        struct simple_card_data *priv,
  96                                        unsigned int daifmt,
  97                                        int idx, bool is_fe)
  98{
  99        struct device *dev = simple_priv_to_dev(priv);
 100        struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, idx);
 101        struct asoc_simple_dai *dai_props = simple_priv_to_props(priv, idx);
 102        struct snd_soc_card *card = simple_priv_to_card(priv);
 103        int ret;
 104
 105        if (is_fe) {
 106                int is_single_links = 0;
 107
 108                /* BE is dummy */
 109                dai_link->codec_of_node         = NULL;
 110                dai_link->codec_dai_name        = "snd-soc-dummy-dai";
 111                dai_link->codec_name            = "snd-soc-dummy";
 112
 113                /* FE settings */
 114                dai_link->dynamic               = 1;
 115                dai_link->dpcm_merged_format    = 1;
 116
 117                ret = asoc_simple_card_parse_cpu(np, dai_link, DAI, CELL,
 118                                                 &is_single_links);
 119                if (ret)
 120                        return ret;
 121
 122                ret = asoc_simple_card_parse_clk_cpu(dev, np, dai_link, dai_props);
 123                if (ret < 0)
 124                        return ret;
 125
 126                ret = asoc_simple_card_set_dailink_name(dev, dai_link,
 127                                                        "fe.%s",
 128                                                        dai_link->cpu_dai_name);
 129                if (ret < 0)
 130                        return ret;
 131
 132                asoc_simple_card_canonicalize_cpu(dai_link, is_single_links);
 133        } else {
 134                /* FE is dummy */
 135                dai_link->cpu_of_node           = NULL;
 136                dai_link->cpu_dai_name          = "snd-soc-dummy-dai";
 137                dai_link->cpu_name              = "snd-soc-dummy";
 138
 139                /* BE settings */
 140                dai_link->no_pcm                = 1;
 141                dai_link->be_hw_params_fixup    = asoc_simple_card_be_hw_params_fixup;
 142
 143                ret = asoc_simple_card_parse_codec(np, dai_link, DAI, CELL);
 144                if (ret < 0)
 145                        return ret;
 146
 147                ret = asoc_simple_card_parse_clk_codec(dev, np, dai_link, dai_props);
 148                if (ret < 0)
 149                        return ret;
 150
 151                ret = asoc_simple_card_set_dailink_name(dev, dai_link,
 152                                                        "be.%s",
 153                                                        dai_link->codec_dai_name);
 154                if (ret < 0)
 155                        return ret;
 156
 157                snd_soc_of_parse_audio_prefix(card,
 158                                              &priv->codec_conf,
 159                                              dai_link->codec_of_node,
 160                                              PREFIX "prefix");
 161        }
 162
 163        ret = asoc_simple_card_of_parse_tdm(np, dai_props);
 164        if (ret)
 165                return ret;
 166
 167        ret = asoc_simple_card_canonicalize_dailink(dai_link);
 168        if (ret < 0)
 169                return ret;
 170
 171        dai_link->dai_fmt               = daifmt;
 172        dai_link->dpcm_playback         = 1;
 173        dai_link->dpcm_capture          = 1;
 174        dai_link->ops                   = &asoc_simple_card_ops;
 175        dai_link->init                  = asoc_simple_card_dai_init;
 176
 177        return 0;
 178}
 179
 180static int asoc_simple_card_parse_of(struct simple_card_data *priv)
 181
 182{
 183        struct device *dev = simple_priv_to_dev(priv);
 184        struct device_node *np;
 185        struct snd_soc_card *card = simple_priv_to_card(priv);
 186        struct device_node *node = dev->of_node;
 187        unsigned int daifmt = 0;
 188        bool is_fe;
 189        int ret, i;
 190
 191        if (!node)
 192                return -EINVAL;
 193
 194        ret = asoc_simple_card_of_parse_routing(card, PREFIX, 0);
 195        if (ret < 0)
 196                return ret;
 197
 198        asoc_simple_card_parse_convert(dev, PREFIX, &priv->adata);
 199
 200        /* find 1st codec */
 201        np = of_get_child_by_name(node, PREFIX "codec");
 202        if (!np)
 203                return -ENODEV;
 204
 205        ret = asoc_simple_card_parse_daifmt(dev, node, np, PREFIX, &daifmt);
 206        if (ret < 0)
 207                return ret;
 208
 209        i = 0;
 210        for_each_child_of_node(node, np) {
 211                is_fe = false;
 212                if (strcmp(np->name, PREFIX "cpu") == 0)
 213                        is_fe = true;
 214
 215                ret = asoc_simple_card_dai_link_of(np, priv, daifmt, i, is_fe);
 216                if (ret < 0)
 217                        return ret;
 218                i++;
 219        }
 220
 221        ret = asoc_simple_card_parse_card_name(card, PREFIX);
 222        if (ret < 0)
 223                return ret;
 224
 225        return 0;
 226}
 227
 228static int asoc_simple_card_probe(struct platform_device *pdev)
 229{
 230        struct simple_card_data *priv;
 231        struct snd_soc_dai_link *dai_link;
 232        struct asoc_simple_dai *dai_props;
 233        struct snd_soc_card *card;
 234        struct device *dev = &pdev->dev;
 235        struct device_node *np = dev->of_node;
 236        int num, ret;
 237
 238        /* Allocate the private data */
 239        priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
 240        if (!priv)
 241                return -ENOMEM;
 242
 243        num = of_get_child_count(np);
 244
 245        dai_props = devm_kzalloc(dev, sizeof(*dai_props) * num, GFP_KERNEL);
 246        dai_link  = devm_kzalloc(dev, sizeof(*dai_link)  * num, GFP_KERNEL);
 247        if (!dai_props || !dai_link)
 248                return -ENOMEM;
 249
 250        priv->dai_props                         = dai_props;
 251        priv->dai_link                          = dai_link;
 252
 253        /* Init snd_soc_card */
 254        card = simple_priv_to_card(priv);
 255        card->owner             = THIS_MODULE;
 256        card->dev               = dev;
 257        card->dai_link          = priv->dai_link;
 258        card->num_links         = num;
 259        card->codec_conf        = &priv->codec_conf;
 260        card->num_configs       = 1;
 261
 262        ret = asoc_simple_card_parse_of(priv);
 263        if (ret < 0) {
 264                if (ret != -EPROBE_DEFER)
 265                        dev_err(dev, "parse error %d\n", ret);
 266                goto err;
 267        }
 268
 269        snd_soc_card_set_drvdata(card, priv);
 270
 271        ret = devm_snd_soc_register_card(dev, card);
 272        if (ret < 0)
 273                goto err;
 274
 275        return 0;
 276err:
 277        asoc_simple_card_clean_reference(card);
 278
 279        return ret;
 280}
 281
 282static int asoc_simple_card_remove(struct platform_device *pdev)
 283{
 284        struct snd_soc_card *card = platform_get_drvdata(pdev);
 285
 286        return asoc_simple_card_clean_reference(card);
 287}
 288
 289static const struct of_device_id asoc_simple_of_match[] = {
 290        { .compatible = "renesas,rsrc-card", },
 291        { .compatible = "simple-scu-audio-card", },
 292        {},
 293};
 294MODULE_DEVICE_TABLE(of, asoc_simple_of_match);
 295
 296static struct platform_driver asoc_simple_card = {
 297        .driver = {
 298                .name = "simple-scu-audio-card",
 299                .of_match_table = asoc_simple_of_match,
 300        },
 301        .probe = asoc_simple_card_probe,
 302        .remove = asoc_simple_card_remove,
 303};
 304
 305module_platform_driver(asoc_simple_card);
 306
 307MODULE_ALIAS("platform:asoc-simple-scu-card");
 308MODULE_LICENSE("GPL v2");
 309MODULE_DESCRIPTION("ASoC Simple SCU Sound Card");
 310MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>");
 311