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 {
 149         struct device_node *np = NULL;
 150         struct device_node *bitclkmaster = NULL;
 151         struct device_node *framemaster = NULL;
 152         unsigned int daifmt;
 153         char *name;
 154         char prop[128];
 155         char *prefix = "";
 156         int ret;
 157
 158         prefix = "simple-audio-card,";
 159
 160         daifmt = snd_soc_of_parse_daifmt(node, prefix,
 161                                          &bitclkmaster, &framemaster);
 162         daifmt &= ~SND_SOC_DAIFMT_MASTER_MASK;
 163
 164         snprintf(prop, sizeof(prop), "%scpu", prefix);
 165         np = of_get_child_by_name(node, prop);
 166         if (!np) {
 167                 ret = -EINVAL;
 168                 dev_err(dev, "%s: Can't find %s DT node\n", __func__, prop);
 169                 goto dai_link_of_err;
 170         }
 171
 172         ret = asoc_simple_card_sub_parse_of(np, &dai_props->cpu_dai,
 173                                             &dai_link->cpu_of_node,
 174                                             &dai_link->cpu_dai_name);
 175         if (ret < 0)
 176                 goto dai_link_of_err;
 177
 178         dai_props->cpu_dai.fmt = daifmt;
 179         switch (((np == bitclkmaster) << 4) | (np == framemaster)) {
 180         case 0x11:
 181                 dai_props->cpu_dai.fmt |= SND_SOC_DAIFMT_CBS_CFS;
 182                 break;
 183         case 0x10:
 184                 dai_props->cpu_dai.fmt |= SND_SOC_DAIFMT_CBS_CFM;
 185                 break;
 186         case 0x01:
 187                 dai_props->cpu_dai.fmt |= SND_SOC_DAIFMT_CBM_CFS;
 188                 break;
 189         default:
 190                 dai_props->cpu_dai.fmt |= SND_SOC_DAIFMT_CBM_CFM;
 191                 break;
 192         }
 193
 194         of_node_put(np);
 195         snprintf(prop, sizeof(prop), "%scodec", prefix);
 196         np = of_get_child_by_name(node, prop);
 197         if (!np) {
 198                 ret = -EINVAL;
 199                 dev_err(dev, "%s: Can't find %s DT node\n", __func__, prop);
 200                 goto dai_link_of_err;
 201         }
 202
 203         ret = asoc_simple_card_sub_parse_of(np, &dai_props->codec_dai,
 204                                             &dai_link->codec_of_node,
 205                                             &dai_link->codec_dai_name);
 206         if (ret < 0)
 207                 goto dai_link_of_err;
 208
 209         if (strlen(prefix) && !bitclkmaster && !framemaster) {
 210                 /* No dai-link level and master setting was not found from
 211                    sound node level, revert back to legacy DT parsing and
 212                    take the settings from codec node. */
 213                 dev_dbg(dev, "%s: Revert to legacy daifmt parsing\n",
 214                         __func__);
 215                 dai_props->cpu_dai.fmt = dai_props->codec_dai.fmt =
 216                         snd_soc_of_parse_daifmt(np, NULL, NULL, NULL) |
 217                         (daifmt & ~SND_SOC_DAIFMT_CLOCK_MASK);
 218         } else {
 219                 dai_props->codec_dai.fmt = daifmt;
 220                 switch (((np == bitclkmaster) << 4) | (np == framemaster)) {
 221                 case 0x11:
 222                         dai_props->codec_dai.fmt |= SND_SOC_DAIFMT_CBM_CFM;
 223                         break;
 224                 case 0x10:
 225                         dai_props->codec_dai.fmt |= SND_SOC_DAIFMT_CBM_CFS;
 226                         break;
 227                 case 0x01:
 228                         dai_props->codec_dai.fmt |= SND_SOC_DAIFMT_CBS_CFM;
 229                         break;
 230                 default:
 231                         dai_props->codec_dai.fmt |= SND_SOC_DAIFMT_CBS_CFS;
 232                         break;
 233                 }
 234         }
 235
 236         if (!dai_link->cpu_dai_name || !dai_link->codec_dai_name) {
 237                 ret = -EINVAL;
 238                 goto dai_link_of_err;
 239         }
 240
 241         /* simple-card assumes platform == cpu */
 242         dai_link->platform_of_node = dai_link->cpu_of_node;
 243
 244         /* Link name is created from CPU/CODEC dai name */
 245         name = devm_kzalloc(dev,
 246                             strlen(dai_link->cpu_dai_name)   +
 247                             strlen(dai_link->codec_dai_name) + 2,
 248                             GFP_KERNEL);
 249         sprintf(name, "%s-%s", dai_link->cpu_dai_name,
 250                                 dai_link->codec_dai_name);
 251         dai_link->name = dai_link->stream_name = name;
 252
 253         dev_dbg(dev, "\tname : %s\n", dai_link->stream_name);
 254         dev_dbg(dev, "\tcpu : %s / %04x / %d\n",
 255                 dai_link->cpu_dai_name,
 256                 dai_props->cpu_dai.fmt,
 257                 dai_props->cpu_dai.sysclk);
 258         dev_dbg(dev, "\tcodec : %s / %04x / %d\n",
 259                 dai_link->codec_dai_name,
 260                 dai_props->codec_dai.fmt,
 261                 dai_props->codec_dai.sysclk);
 262
 263 dai_link_of_err:
 264         if (np)
 265                 of_node_put(np);
 266         if (bitclkmaster)
 267                 of_node_put(bitclkmaster);
 268         if (framemaster)
 269                 of_node_put(framemaster);
 270         return ret;
 271 }
 272
 273 static int asoc_simple_card_parse_of(struct device_node *node,
 274                                      struct simple_card_data *priv,
 275                                      struct device *dev,
 276                                      int multi)
 277 {
 278         struct snd_soc_dai_link *dai_link = priv->snd_card.dai_link;
 279         struct simple_dai_props *dai_props = priv->dai_props;
 280         int ret;
 281
 282         /* parsing the card name from DT */
 283         snd_soc_of_parse_card_name(&priv->snd_card, "simple-audio-card,name");
 284
 285         /* off-codec widgets */
 286         if (of_property_read_bool(node, "simple-audio-card,widgets")) {
 287                 ret = snd_soc_of_parse_audio_simple_widgets(&priv->snd_card,
 288                                         "simple-audio-card,widgets");
 289                 if (ret)
 290                         return ret;
 291         }
 292
 293         /* DAPM routes */
 294         if (of_property_read_bool(node, "simple-audio-card,routing")) {
 295                 ret = snd_soc_of_parse_audio_routing(&priv->snd_card,
 296                                         "simple-audio-card,routing");
 297                 if (ret)
 298                         return ret;
 299         }
 300
 301         dev_dbg(dev, "New simple-card: %s\n", priv->snd_card.name ?
 302                 priv->snd_card.name : "");
 303
 304         if (multi) {
 305                 struct device_node *np = NULL;
 306                 int i;
 307                 for (i = 0; (np = of_get_next_child(node, np)); i++) {
 308                         dev_dbg(dev, "\tlink %d:\n", i);
 309                         ret = simple_card_dai_link_of(np, dev, dai_link + i,
 310                                                       dai_props + i);
 311                         if (ret < 0) {
 312                                 of_node_put(np);
 313                                 return ret;
 314                         }
 315                 }
 316         } else {
 317                 ret = simple_card_dai_link_of(node, dev, dai_link, dai_props);
 318                 if (ret < 0)
 319                         return ret;
 320         }
 321
 322         if (!priv->snd_card.name)
 323                 priv->snd_card.name = priv->snd_card.dai_link->name;
 324
 325         return 0;
 326 }
 327
 328 /* update the reference count of the devices nodes at end of probe */
 329 static int asoc_simple_card_unref(struct platform_device *pdev)
 330 {
 331         struct snd_soc_card *card = platform_get_drvdata(pdev);
 332         struct snd_soc_dai_link *dai_link;
 333         struct device_node *np;
 334         int num_links;
 335
 336         for (num_links = 0, dai_link = card->dai_link;
 337              num_links < card->num_links;
 338              num_links++, dai_link++) {
 339                 np = (struct device_node *) dai_link->cpu_of_node;
 340                 if (np)
 341                         of_node_put(np);
 342                 np = (struct device_node *) dai_link->codec_of_node;
 343                 if (np)
 344                         of_node_put(np);
 345         }
 346         return 0;
 347 }
 348
 349 static int asoc_simple_card_probe(struct platform_device *pdev)
 350 {
 351         struct simple_card_data *priv;
 352         struct snd_soc_dai_link *dai_link;
 353         struct device_node *np = pdev->dev.of_node;
 354         struct device *dev = &pdev->dev;
 355         int num_links, multi, ret;
 356
 357         /* get the number of DAI links */
 358         if (np && of_get_child_by_name(np, "simple-audio-card,dai-link")) {
 359                 num_links = of_get_child_count(np);
 360                 multi = 1;
 361         } else {
 362                 num_links = 1;
 363                 multi = 0;
 364         }
 365
 366         /* allocate the private data and the DAI link array */
 367         priv = devm_kzalloc(dev,
 368                         sizeof(*priv) + sizeof(*dai_link) * num_links,
 369                         GFP_KERNEL);
 370         if (!priv)
 371                 return -ENOMEM;
 372
 373         /*
 374          * init snd_soc_card
 375          */
 376         priv->snd_card.owner = THIS_MODULE;
 377         priv->snd_card.dev = dev;
 378         dai_link = priv->dai_link;
 379         priv->snd_card.dai_link = dai_link;
 380         priv->snd_card.num_links = num_links;
 381
 382         /* get room for the other properties */
 383         priv->dai_props = devm_kzalloc(dev,
 384                         sizeof(*priv->dai_props) * num_links,
 385                         GFP_KERNEL);
 386         if (!priv->dai_props)
 387                 return -ENOMEM;
 388
 389         if (np && of_device_is_available(np)) {
 390
 391                 ret = asoc_simple_card_parse_of(np, priv, dev, multi);
 392                 if (ret < 0) {
 393                         if (ret != -EPROBE_DEFER)
 394                                 dev_err(dev, "parse error %d\n", ret);
 395                         goto err;
 396                 }
 397
 398                 /*
 399                  * soc_bind_dai_link() will check cpu name
 400                  * after of_node matching if dai_link has cpu_dai_name.
 401                  * but, it will never match if name was created by fmt_single_name()
 402                  * remove cpu_dai_name to escape name matching.
 403                  * see
 404                  *      fmt_single_name()
 405                  *      fmt_multiple_name()
 406                  */
 407                 if (num_links == 1)
 408                         dai_link->cpu_dai_name = NULL;
 409
 410         } else {
 411                 struct asoc_simple_card_info *cinfo;
 412
 413                 cinfo = dev->platform_data;
 414                 if (!cinfo) {
 415                         dev_err(dev, "no info for asoc-simple-card\n");
 416                         return -EINVAL;
 417                 }
 418
 419                 if (!cinfo->name ||
 420                     !cinfo->codec_dai.name ||
 421                     !cinfo->codec ||
 422                     !cinfo->platform ||
 423                     !cinfo->cpu_dai.name) {
 424                         dev_err(dev, "insufficient asoc_simple_card_info settings\n");
 425                         return -EINVAL;
 426                 }
 427
 428                 priv->snd_card.name     = (cinfo->card) ? cinfo->card : cinfo->name;
 429                 dai_link->name          = cinfo->name;
 430                 dai_link->stream_name   = cinfo->name;
 431                 dai_link->platform_name = cinfo->platform;
 432                 dai_link->codec_name    = cinfo->codec;
 433                 dai_link->cpu_dai_name  = cinfo->cpu_dai.name;
 434                 dai_link->codec_dai_name = cinfo->codec_dai.name;
 435                 memcpy(&priv->dai_props->cpu_dai, &cinfo->cpu_dai,
 436                                         sizeof(priv->dai_props->cpu_dai));
 437                 memcpy(&priv->dai_props->codec_dai, &cinfo->codec_dai,
 438                                         sizeof(priv->dai_props->codec_dai));
 439
 440                 priv->dai_props->cpu_dai.fmt    |= cinfo->daifmt;
 441                 priv->dai_props->codec_dai.fmt  |= cinfo->daifmt;
 442         }
 443
 444         /*
 445          * init snd_soc_dai_link
 446          */
 447         dai_link->init = asoc_simple_card_dai_init;
 448
 449         snd_soc_card_set_drvdata(&priv->snd_card, priv);
 450
 451         ret = devm_snd_soc_register_card(&pdev->dev, &priv->snd_card);
 452
 453 err:
 454         asoc_simple_card_unref(pdev);
 455         return ret;
 456 }
 457
 458 static const struct of_device_id asoc_simple_of_match[] = {
 459         { .compatible = "simple-audio-card", },
 460         {},
 461 };
 462 MODULE_DEVICE_TABLE(of, asoc_simple_of_match);
 463
 464 static struct platform_driver asoc_simple_card = {
 465         .driver = {
 466                 .name = "asoc-simple-card",
 467                 .owner = THIS_MODULE,
 468                 .of_match_table = asoc_simple_of_match,
 469         },
 470         .probe = asoc_simple_card_probe,
 471 };
 472
 473 module_platform_driver(asoc_simple_card);
 474
 475 MODULE_ALIAS("platform:asoc-simple-card");
 476 MODULE_LICENSE("GPL");
 477 MODULE_DESCRIPTION("ASoC Simple Sound Card");
 478 MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>");