sound/soc/generic/simple-card.c

   1 /*
   2  * ASoC simple sound card support
   3  *
   4  * Copyright (C) 2012 Renesas Solutions Corp.
   5  * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  */
  11 #include <linux/clk.h>
  12 #include <linux/device.h>
  13 #include <linux/module.h>
  14 #include <linux/of.h>
  15 #include <linux/platform_device.h>
  16 #include <linux/string.h>
  17 #include <sound/simple_card.h>
  18 #include <sound/soc-dai.h>
  19 #include <sound/soc.h>
  20
  21 struct simple_card_data {
  22         struct snd_soc_card snd_card;
  23         struct simple_dai_props {
  24                 struct asoc_simple_dai cpu_dai;
  25                 struct asoc_simple_dai codec_dai;
  26         } *dai_props;
  27         struct snd_soc_dai_link dai_link[];     /* dynamically allocated */
  28 };
  29
  30 static int __asoc_simple_card_dai_init(struct snd_soc_dai *dai,
  31                                        struct asoc_simple_dai *set)
  32 {
  33         int ret;
  34
  35         if (set->fmt) {
  36                 ret = snd_soc_dai_set_fmt(dai, set->fmt);
  37                 if (ret && ret != -ENOTSUPP) {
  38                         dev_err(dai->dev, "simple-card: set_fmt error\n");
  39                         goto err;
  40                 }
  41         }
  42
  43         if (set->sysclk) {
  44                 ret = snd_soc_dai_set_sysclk(dai, 0, set->sysclk, 0);
  45                 if (ret && ret != -ENOTSUPP) {
  46                         dev_err(dai->dev, "simple-card: set_sysclk error\n");
  47                         goto err;
  48                 }
  49         }
  50
  51         if (set->slots) {
  52                 ret = snd_soc_dai_set_tdm_slot(dai, 0, 0,
  53                                                 set->slots,
  54                                                 set->slot_width);
  55                 if (ret && ret != -ENOTSUPP) {
  56                         dev_err(dai->dev, "simple-card: set_tdm_slot error\n");
  57                         goto err;
  58                 }
  59         }
  60
  61         ret = 0;
  62
  63 err:
  64         return ret;
  65 }
  66
  67 static 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 *codec = rtd->codec_dai;
  71         struct snd_soc_dai *cpu = rtd->cpu_dai;
  72         struct simple_dai_props *dai_props;
  73         int num, ret;
  74
  75         num = rtd - rtd->card->rtd;
  76         dai_props = &priv->dai_props[num];
  77         ret = __asoc_simple_card_dai_init(codec, &dai_props->codec_dai);
  78         if (ret < 0)
  79                 return ret;
  80
  81         ret = __asoc_simple_card_dai_init(cpu, &dai_props->cpu_dai);
  82         if (ret < 0)
  83                 return ret;
  84
  85         return 0;
  86 }
  87
  88 static int
  89 asoc_simple_card_sub_parse_of(struct device_node *np,
  90                               struct asoc_simple_dai *dai,
  91                               const struct device_node **p_node,
  92                               const char **name)
  93 {
  94         struct device_node *node;
  95         struct clk *clk;
  96         int ret;
  97
  98         /*
  99          * get node via "sound-dai = <&phandle port>"
 100          * it will be used as xxx_of_node on soc_bind_dai_link()
 101          */
 102         node = of_parse_phandle(np, "sound-dai", 0);
 103         if (!node)
 104                 return -ENODEV;
 105         *p_node = node;
 106
 107         /* get dai->name */
 108         ret = snd_soc_of_get_dai_name(np, name);
 109         if (ret < 0)
 110                 return ret;
 111
 112         /* parse TDM slot */
 113         ret = snd_soc_of_parse_tdm_slot(np, &dai->slots, &dai->slot_width);
 114         if (ret)
 115                 return ret;
 116
 117         /*
 118          * dai->sysclk come from
 119          *  "clocks = <&xxx>" (if system has common clock)
 120          *  or "system-clock-frequency = <xxx>"
 121          *  or device's module clock.
 122          */
 123         if (of_property_read_bool(np, "clocks")) {
 124                 clk = of_clk_get(np, 0);
 125                 if (IS_ERR(clk)) {
 126                         ret = PTR_ERR(clk);
 127                         return ret;
 128                 }
 129
 130                 dai->sysclk = clk_get_rate(clk);
 131         } else if (of_property_read_bool(np, "system-clock-frequency")) {
 132                 of_property_read_u32(np,
 133                                      "system-clock-frequency",
 134                                      &dai->sysclk);
 135         } else {
 136                 clk = of_clk_get(node, 0);
 137                 if (!IS_ERR(clk))
 138                         dai->sysclk = clk_get_rate(clk);
 139         }
 140
 141         return 0;
 142 }
 143
 144 static int simple_card_dai_link_of(struct device_node *node,
 145                                    struct device *dev,
 146                                    struct snd_soc_dai_link *dai_link,
 147                                    struct simple_dai_props *dai_props,
 148                                    bool is_top_level_node)
 149 {
 150         struct device_node *np = NULL;
 151         struct device_node *bitclkmaster = NULL;
 152         struct device_node *framemaster = NULL;
 153         unsigned int daifmt;
 154         char *name;
 155         char prop[128];
 156         char *prefix = "";
 157         int ret;
 158
 159         if (is_top_level_node)
 160                 prefix = "simple-audio-card,";
 161
 162         daifmt = snd_soc_of_parse_daifmt(node, prefix,
 163                                          &bitclkmaster, &framemaster);
 164         daifmt &= ~SND_SOC_DAIFMT_MASTER_MASK;
 165
 166         snprintf(prop, sizeof(prop), "%scpu", prefix);
 167         np = of_get_child_by_name(node, prop);
 168         if (!np) {
 169                 ret = -EINVAL;
 170                 dev_err(dev, "%s: Can't find %s DT node\n", __func__, prop);
 171                 goto dai_link_of_err;
 172         }
 173
 174         ret = asoc_simple_card_sub_parse_of(np, &dai_props->cpu_dai,
 175                                             &dai_link->cpu_of_node,
 176                                             &dai_link->cpu_dai_name);
 177         if (ret < 0)
 178                 goto dai_link_of_err;
 179
 180         dai_props->cpu_dai.fmt = daifmt;
 181         switch (((np == bitclkmaster) << 4) | (np == framemaster)) {
 182         case 0x11:
 183                 dai_props->cpu_dai.fmt |= SND_SOC_DAIFMT_CBS_CFS;
 184                 break;
 185         case 0x10:
 186                 dai_props->cpu_dai.fmt |= SND_SOC_DAIFMT_CBS_CFM;
 187                 break;
 188         case 0x01:
 189                 dai_props->cpu_dai.fmt |= SND_SOC_DAIFMT_CBM_CFS;
 190                 break;
 191         default:
 192                 dai_props->cpu_dai.fmt |= SND_SOC_DAIFMT_CBM_CFM;
 193                 break;
 194         }
 195
 196         of_node_put(np);
 197         snprintf(prop, sizeof(prop), "%scodec", prefix);
 198         np = of_get_child_by_name(node, prop);
 199         if (!np) {
 200                 ret = -EINVAL;
 201                 dev_err(dev, "%s: Can't find %s DT node\n", __func__, prop);
 202                 goto dai_link_of_err;
 203         }
 204
 205         ret = asoc_simple_card_sub_parse_of(np, &dai_props->codec_dai,
 206                                             &dai_link->codec_of_node,
 207                                             &dai_link->codec_dai_name);
 208         if (ret < 0)
 209                 goto dai_link_of_err;
 210
 211         if (strlen(prefix) && !bitclkmaster && !framemaster) {
 212                 /* No dai-link level and master setting was not found from
 213                    sound node level, revert back to legacy DT parsing and
 214                    take the settings from codec node. */
 215                 dev_dbg(dev, "%s: Revert to legacy daifmt parsing\n",
 216                         __func__);
 217                 dai_props->cpu_dai.fmt = dai_props->codec_dai.fmt =
 218                         snd_soc_of_parse_daifmt(np, NULL, NULL, NULL) |
 219                         (daifmt & ~SND_SOC_DAIFMT_CLOCK_MASK);
 220         } else {
 221                 dai_props->codec_dai.fmt = daifmt;
 222                 switch (((np == bitclkmaster) << 4) | (np == framemaster)) {
 223                 case 0x11:
 224                         dai_props->codec_dai.fmt |= SND_SOC_DAIFMT_CBM_CFM;
 225                         break;
 226                 case 0x10:
 227                         dai_props->codec_dai.fmt |= SND_SOC_DAIFMT_CBM_CFS;
 228                         break;
 229                 case 0x01:
 230                         dai_props->codec_dai.fmt |= SND_SOC_DAIFMT_CBS_CFM;
 231                         break;
 232                 default:
 233                         dai_props->codec_dai.fmt |= SND_SOC_DAIFMT_CBS_CFS;
 234                         break;
 235                 }
 236         }
 237
 238         if (!dai_link->cpu_dai_name || !dai_link->codec_dai_name) {
 239                 ret = -EINVAL;
 240                 goto dai_link_of_err;
 241         }
 242
 243         /* simple-card assumes platform == cpu */
 244         dai_link->platform_of_node = dai_link->cpu_of_node;
 245
 246         /* Link name is created from CPU/CODEC dai name */
 247         name = devm_kzalloc(dev,
 248                             strlen(dai_link->cpu_dai_name)   +
 249                             strlen(dai_link->codec_dai_name) + 2,
 250                             GFP_KERNEL);
 251         sprintf(name, "%s-%s", dai_link->cpu_dai_name,
 252                                 dai_link->codec_dai_name);
 253         dai_link->name = dai_link->stream_name = name;
 254
 255         dev_dbg(dev, "\tname : %s\n", dai_link->stream_name);
 256         dev_dbg(dev, "\tcpu : %s / %04x / %d\n",
 257                 dai_link->cpu_dai_name,
 258                 dai_props->cpu_dai.fmt,
 259                 dai_props->cpu_dai.sysclk);
 260         dev_dbg(dev, "\tcodec : %s / %04x / %d\n",
 261                 dai_link->codec_dai_name,
 262                 dai_props->codec_dai.fmt,
 263                 dai_props->codec_dai.sysclk);
 264
 265 dai_link_of_err:
 266         if (np)
 267                 of_node_put(np);
 268         if (bitclkmaster)
 269                 of_node_put(bitclkmaster);
 270         if (framemaster)
 271                 of_node_put(framemaster);
 272         return ret;
 273 }
 274
 275 static int asoc_simple_card_parse_of(struct device_node *node,
 276                                      struct simple_card_data *priv,
 277                                      struct device *dev,
 278                                      int multi)
 279 {
 280         struct snd_soc_dai_link *dai_link = priv->snd_card.dai_link;
 281         struct simple_dai_props *dai_props = priv->dai_props;
 282         int ret;
 283
 284         /* parsing the card name from DT */
 285         snd_soc_of_parse_card_name(&priv->snd_card, "simple-audio-card,name");
 286
 287         /* off-codec widgets */
 288         if (of_property_read_bool(node, "simple-audio-card,widgets")) {
 289                 ret = snd_soc_of_parse_audio_simple_widgets(&priv->snd_card,
 290                                         "simple-audio-card,widgets");
 291                 if (ret)
 292                         return ret;
 293         }
 294
 295         /* DAPM routes */
 296         if (of_property_read_bool(node, "simple-audio-card,routing")) {
 297                 ret = snd_soc_of_parse_audio_routing(&priv->snd_card,
 298                                         "simple-audio-card,routing");
 299                 if (ret)
 300                         return ret;
 301         }
 302
 303         dev_dbg(dev, "New simple-card: %s\n", priv->snd_card.name ?
 304                 priv->snd_card.name : "");
 305
 306         if (multi) {
 307                 struct device_node *np = NULL;
 308                 int i;
 309                 for (i = 0; (np = of_get_next_child(node, np)); i++) {
 310                         dev_dbg(dev, "\tlink %d:\n", i);
 311                         ret = simple_card_dai_link_of(np, dev, dai_link + i,
 312                                                       dai_props + i, false);
 313                         if (ret < 0) {
 314                                 of_node_put(np);
 315                                 return ret;
 316                         }
 317                 }
 318         } else {
 319                 ret = simple_card_dai_link_of(node, dev, dai_link, dai_props,
 320                                               true);
 321                 if (ret < 0)
 322                         return ret;
 323         }
 324
 325         if (!priv->snd_card.name)
 326                 priv->snd_card.name = priv->snd_card.dai_link->name;
 327
 328         return 0;
 329 }
 330
 331 /* update the reference count of the devices nodes at end of probe */
 332 static int asoc_simple_card_unref(struct platform_device *pdev)
 333 {
 334         struct snd_soc_card *card = platform_get_drvdata(pdev);
 335         struct snd_soc_dai_link *dai_link;
 336         struct device_node *np;
 337         int num_links;
 338
 339         for (num_links = 0, dai_link = card->dai_link;
 340              num_links < card->num_links;
 341              num_links++, dai_link++) {
 342                 np = (struct device_node *) dai_link->cpu_of_node;
 343                 if (np)
 344                         of_node_put(np);
 345                 np = (struct device_node *) dai_link->codec_of_node;
 346                 if (np)
 347                         of_node_put(np);
 348         }
 349         return 0;
 350 }
 351
 352 static int asoc_simple_card_probe(struct platform_device *pdev)
 353 {
 354         struct simple_card_data *priv;
 355         struct snd_soc_dai_link *dai_link;
 356         struct device_node *np = pdev->dev.of_node;
 357         struct device *dev = &pdev->dev;
 358         int num_links, multi, ret;
 359
 360         /* get the number of DAI links */
 361         if (np && of_get_child_by_name(np, "simple-audio-card,dai-link")) {
 362                 num_links = of_get_child_count(np);
 363                 multi = 1;
 364         } else {
 365                 num_links = 1;
 366                 multi = 0;
 367         }
 368
 369         /* allocate the private data and the DAI link array */
 370         priv = devm_kzalloc(dev,
 371                         sizeof(*priv) + sizeof(*dai_link) * num_links,
 372                         GFP_KERNEL);
 373         if (!priv)
 374                 return -ENOMEM;
 375
 376         /*
 377          * init snd_soc_card
 378          */
 379         priv->snd_card.owner = THIS_MODULE;
 380         priv->snd_card.dev = dev;
 381         dai_link = priv->dai_link;
 382         priv->snd_card.dai_link = dai_link;
 383         priv->snd_card.num_links = num_links;
 384
 385         /* get room for the other properties */
 386         priv->dai_props = devm_kzalloc(dev,
 387                         sizeof(*priv->dai_props) * num_links,
 388                         GFP_KERNEL);
 389         if (!priv->dai_props)
 390                 return -ENOMEM;
 391
 392         if (np && of_device_is_available(np)) {
 393
 394                 ret = asoc_simple_card_parse_of(np, priv, dev, multi);
 395                 if (ret < 0) {
 396                         if (ret != -EPROBE_DEFER)
 397                                 dev_err(dev, "parse error %d\n", ret);
 398                         goto err;
 399                 }
 400
 401                 /*
 402                  * soc_bind_dai_link() will check cpu name
 403                  * after of_node matching if dai_link has cpu_dai_name.
 404                  * but, it will never match if name was created by fmt_single_name()
 405                  * remove cpu_dai_name to escape name matching.
 406                  * see
 407                  *      fmt_single_name()
 408                  *      fmt_multiple_name()
 409                  */
 410                 if (num_links == 1)
 411                         dai_link->cpu_dai_name = NULL;
 412
 413         } else {
 414                 struct asoc_simple_card_info *cinfo;
 415
 416                 cinfo = dev->platform_data;
 417                 if (!cinfo) {
 418                         dev_err(dev, "no info for asoc-simple-card\n");
 419                         return -EINVAL;
 420                 }
 421
 422                 if (!cinfo->name ||
 423                     !cinfo->codec_dai.name ||
 424                     !cinfo->codec ||
 425                     !cinfo->platform ||
 426                     !cinfo->cpu_dai.name) {
 427                         dev_err(dev, "insufficient asoc_simple_card_info settings\n");
 428                         return -EINVAL;
 429                 }
 430
 431                 priv->snd_card.name     = (cinfo->card) ? cinfo->card : cinfo->name;
 432                 dai_link->name          = cinfo->name;
 433                 dai_link->stream_name   = cinfo->name;
 434                 dai_link->platform_name = cinfo->platform;
 435                 dai_link->codec_name    = cinfo->codec;
 436                 dai_link->cpu_dai_name  = cinfo->cpu_dai.name;
 437                 dai_link->codec_dai_name = cinfo->codec_dai.name;
 438                 memcpy(&priv->dai_props->cpu_dai, &cinfo->cpu_dai,
 439                                         sizeof(priv->dai_props->cpu_dai));
 440                 memcpy(&priv->dai_props->codec_dai, &cinfo->codec_dai,
 441                                         sizeof(priv->dai_props->codec_dai));
 442
 443                 priv->dai_props->cpu_dai.fmt    |= cinfo->daifmt;
 444                 priv->dai_props->codec_dai.fmt  |= cinfo->daifmt;
 445         }
 446
 447         /*
 448          * init snd_soc_dai_link
 449          */
 450         dai_link->init = asoc_simple_card_dai_init;
 451
 452         snd_soc_card_set_drvdata(&priv->snd_card, priv);
 453
 454         ret = devm_snd_soc_register_card(&pdev->dev, &priv->snd_card);
 455
 456 err:
 457         asoc_simple_card_unref(pdev);
 458         return ret;
 459 }
 460
 461 static const struct of_device_id asoc_simple_of_match[] = {
 462         { .compatible = "simple-audio-card", },
 463         {},
 464 };
 465 MODULE_DEVICE_TABLE(of, asoc_simple_of_match);
 466
 467 static struct platform_driver asoc_simple_card = {
 468         .driver = {
 469                 .name = "asoc-simple-card",
 470                 .owner = THIS_MODULE,
 471                 .of_match_table = asoc_simple_of_match,
 472         },
 473         .probe = asoc_simple_card_probe,
 474 };
 475
 476 module_platform_driver(asoc_simple_card);
 477
 478 MODULE_ALIAS("platform:asoc-simple-card");
 479 MODULE_LICENSE("GPL");
 480 MODULE_DESCRIPTION("ASoC Simple Sound Card");
 481 MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>");