sound/soc/generic/simple-card-utils.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 //
   3 // simple-card-utils.c
   4 //
   5 // Copyright (c) 2016 Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
   6
   7 #include <linux/clk.h>
   8 #include <linux/gpio.h>
   9 #include <linux/gpio/consumer.h>
  10 #include <linux/module.h>
  11 #include <linux/of.h>
  12 #include <linux/of_gpio.h>
  13 #include <linux/of_graph.h>
  14 #include <sound/jack.h>
  15 #include <sound/simple_card_utils.h>
  16
  17 void asoc_simple_convert_fixup(struct asoc_simple_data *data,
  18                                struct snd_pcm_hw_params *params)
  19 {
  20         struct snd_interval *rate = hw_param_interval(params,
  21                                                 SNDRV_PCM_HW_PARAM_RATE);
  22         struct snd_interval *channels = hw_param_interval(params,
  23                                                 SNDRV_PCM_HW_PARAM_CHANNELS);
  24
  25         if (data->convert_rate)
  26                 rate->min =
  27                 rate->max = data->convert_rate;
  28
  29         if (data->convert_channels)
  30                 channels->min =
  31                 channels->max = data->convert_channels;
  32 }
  33 EXPORT_SYMBOL_GPL(asoc_simple_convert_fixup);
  34
  35 void asoc_simple_parse_convert(struct device *dev,
  36                                struct device_node *np,
  37                                char *prefix,
  38                                struct asoc_simple_data *data)
  39 {
  40         char prop[128];
  41
  42         if (!prefix)
  43                 prefix = "";
  44
  45         /* sampling rate convert */
  46         snprintf(prop, sizeof(prop), "%s%s", prefix, "convert-rate");
  47         of_property_read_u32(np, prop, &data->convert_rate);
  48
  49         /* channels transfer */
  50         snprintf(prop, sizeof(prop), "%s%s", prefix, "convert-channels");
  51         of_property_read_u32(np, prop, &data->convert_channels);
  52 }
  53 EXPORT_SYMBOL_GPL(asoc_simple_parse_convert);
  54
  55 int asoc_simple_parse_daifmt(struct device *dev,
  56                              struct device_node *node,
  57                              struct device_node *codec,
  58                              char *prefix,
  59                              unsigned int *retfmt)
  60 {
  61         struct device_node *bitclkmaster = NULL;
  62         struct device_node *framemaster = NULL;
  63         unsigned int daifmt;
  64
  65         daifmt = snd_soc_of_parse_daifmt(node, prefix,
  66                                          &bitclkmaster, &framemaster);
  67         daifmt &= ~SND_SOC_DAIFMT_MASTER_MASK;
  68
  69         if (!bitclkmaster && !framemaster) {
  70                 /*
  71                  * No dai-link level and master setting was not found from
  72                  * sound node level, revert back to legacy DT parsing and
  73                  * take the settings from codec node.
  74                  */
  75                 dev_dbg(dev, "Revert to legacy daifmt parsing\n");
  76
  77                 daifmt = snd_soc_of_parse_daifmt(codec, NULL, NULL, NULL) |
  78                         (daifmt & ~SND_SOC_DAIFMT_CLOCK_MASK);
  79         } else {
  80                 if (codec == bitclkmaster)
  81                         daifmt |= (codec == framemaster) ?
  82                                 SND_SOC_DAIFMT_CBM_CFM : SND_SOC_DAIFMT_CBM_CFS;
  83                 else
  84                         daifmt |= (codec == framemaster) ?
  85                                 SND_SOC_DAIFMT_CBS_CFM : SND_SOC_DAIFMT_CBS_CFS;
  86         }
  87
  88         of_node_put(bitclkmaster);
  89         of_node_put(framemaster);
  90
  91         *retfmt = daifmt;
  92
  93         return 0;
  94 }
  95 EXPORT_SYMBOL_GPL(asoc_simple_parse_daifmt);
  96
  97 int asoc_simple_set_dailink_name(struct device *dev,
  98                                  struct snd_soc_dai_link *dai_link,
  99                                  const char *fmt, ...)
 100 {
 101         va_list ap;
 102         char *name = NULL;
 103         int ret = -ENOMEM;
 104
 105         va_start(ap, fmt);
 106         name = devm_kvasprintf(dev, GFP_KERNEL, fmt, ap);
 107         va_end(ap);
 108
 109         if (name) {
 110                 ret = 0;
 111
 112                 dai_link->name          = name;
 113                 dai_link->stream_name   = name;
 114         }
 115
 116         return ret;
 117 }
 118 EXPORT_SYMBOL_GPL(asoc_simple_set_dailink_name);
 119
 120 int asoc_simple_parse_card_name(struct snd_soc_card *card,
 121                                 char *prefix)
 122 {
 123         int ret;
 124
 125         if (!prefix)
 126                 prefix = "";
 127
 128         /* Parse the card name from DT */
 129         ret = snd_soc_of_parse_card_name(card, "label");
 130         if (ret < 0 || !card->name) {
 131                 char prop[128];
 132
 133                 snprintf(prop, sizeof(prop), "%sname", prefix);
 134                 ret = snd_soc_of_parse_card_name(card, prop);
 135                 if (ret < 0)
 136                         return ret;
 137         }
 138
 139         if (!card->name && card->dai_link)
 140                 card->name = card->dai_link->name;
 141
 142         return 0;
 143 }
 144 EXPORT_SYMBOL_GPL(asoc_simple_parse_card_name);
 145
 146 static int asoc_simple_clk_enable(struct asoc_simple_dai *dai)
 147 {
 148         if (dai)
 149                 return clk_prepare_enable(dai->clk);
 150
 151         return 0;
 152 }
 153
 154 static void asoc_simple_clk_disable(struct asoc_simple_dai *dai)
 155 {
 156         if (dai)
 157                 clk_disable_unprepare(dai->clk);
 158 }
 159
 160 int asoc_simple_parse_clk(struct device *dev,
 161                           struct device_node *node,
 162                           struct asoc_simple_dai *simple_dai,
 163                           struct snd_soc_dai_link_component *dlc)
 164 {
 165         struct clk *clk;
 166         u32 val;
 167
 168         /*
 169          * Parse dai->sysclk come from "clocks = <&xxx>"
 170          * (if system has common clock)
 171          *  or "system-clock-frequency = <xxx>"
 172          *  or device's module clock.
 173          */
 174         clk = devm_get_clk_from_child(dev, node, NULL);
 175         if (!IS_ERR(clk)) {
 176                 simple_dai->sysclk = clk_get_rate(clk);
 177
 178                 simple_dai->clk = clk;
 179         } else if (!of_property_read_u32(node, "system-clock-frequency", &val)) {
 180                 simple_dai->sysclk = val;
 181         } else {
 182                 clk = devm_get_clk_from_child(dev, dlc->of_node, NULL);
 183                 if (!IS_ERR(clk))
 184                         simple_dai->sysclk = clk_get_rate(clk);
 185         }
 186
 187         if (of_property_read_bool(node, "system-clock-direction-out"))
 188                 simple_dai->clk_direction = SND_SOC_CLOCK_OUT;
 189
 190         return 0;
 191 }
 192 EXPORT_SYMBOL_GPL(asoc_simple_parse_clk);
 193
 194 int asoc_simple_startup(struct snd_pcm_substream *substream)
 195 {
 196         struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
 197         struct asoc_simple_priv *priv = snd_soc_card_get_drvdata(rtd->card);
 198         struct simple_dai_props *props = simple_priv_to_props(priv, rtd->num);
 199         struct asoc_simple_dai *dai;
 200         int i1, i2, i;
 201         int ret;
 202
 203         for_each_prop_dai_cpu(props, i1, dai) {
 204                 ret = asoc_simple_clk_enable(dai);
 205                 if (ret)
 206                         goto cpu_err;
 207         }
 208
 209         for_each_prop_dai_codec(props, i2, dai) {
 210                 ret = asoc_simple_clk_enable(dai);
 211                 if (ret)
 212                         goto codec_err;
 213         }
 214
 215         return 0;
 216
 217 codec_err:
 218         for_each_prop_dai_codec(props, i, dai) {
 219                 if (i >= i2)
 220                         break;
 221                 asoc_simple_clk_disable(dai);
 222         }
 223 cpu_err:
 224         for_each_prop_dai_cpu(props, i, dai) {
 225                 if (i >= i1)
 226                         break;
 227                 asoc_simple_clk_disable(dai);
 228         }
 229         return ret;
 230 }
 231 EXPORT_SYMBOL_GPL(asoc_simple_startup);
 232
 233 void asoc_simple_shutdown(struct snd_pcm_substream *substream)
 234 {
 235         struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
 236         struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
 237         struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0);
 238         struct asoc_simple_priv *priv = snd_soc_card_get_drvdata(rtd->card);
 239         struct simple_dai_props *props = simple_priv_to_props(priv, rtd->num);
 240         struct asoc_simple_dai *dai;
 241         int i;
 242
 243         if (props->mclk_fs) {
 244                 snd_soc_dai_set_sysclk(codec_dai, 0, 0, SND_SOC_CLOCK_IN);
 245                 snd_soc_dai_set_sysclk(cpu_dai, 0, 0, SND_SOC_CLOCK_OUT);
 246         }
 247
 248         for_each_prop_dai_cpu(props, i, dai)
 249                 asoc_simple_clk_disable(dai);
 250         for_each_prop_dai_codec(props, i, dai)
 251                 asoc_simple_clk_disable(dai);
 252 }
 253 EXPORT_SYMBOL_GPL(asoc_simple_shutdown);
 254
 255 static int asoc_simple_set_clk_rate(struct asoc_simple_dai *simple_dai,
 256                                     unsigned long rate)
 257 {
 258         if (!simple_dai)
 259                 return 0;
 260
 261         if (!simple_dai->clk)
 262                 return 0;
 263
 264         if (clk_get_rate(simple_dai->clk) == rate)
 265                 return 0;
 266
 267         return clk_set_rate(simple_dai->clk, rate);
 268 }
 269
 270 int asoc_simple_hw_params(struct snd_pcm_substream *substream,
 271                           struct snd_pcm_hw_params *params)
 272 {
 273         struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
 274         struct asoc_simple_dai *pdai;
 275         struct snd_soc_dai *sdai;
 276         struct asoc_simple_priv *priv = snd_soc_card_get_drvdata(rtd->card);
 277         struct simple_dai_props *props = simple_priv_to_props(priv, rtd->num);
 278         unsigned int mclk, mclk_fs = 0;
 279         int i, ret;
 280
 281         if (props->mclk_fs)
 282                 mclk_fs = props->mclk_fs;
 283
 284         if (mclk_fs) {
 285                 mclk = params_rate(params) * mclk_fs;
 286
 287                 for_each_prop_dai_codec(props, i, pdai) {
 288                         ret = asoc_simple_set_clk_rate(pdai, mclk);
 289                         if (ret < 0)
 290                                 return ret;
 291                 }
 292                 for_each_prop_dai_cpu(props, i, pdai) {
 293                         ret = asoc_simple_set_clk_rate(pdai, mclk);
 294                         if (ret < 0)
 295                                 return ret;
 296                 }
 297                 for_each_rtd_codec_dais(rtd, i, sdai) {
 298                         ret = snd_soc_dai_set_sysclk(sdai, 0, mclk, SND_SOC_CLOCK_IN);
 299                         if (ret && ret != -ENOTSUPP)
 300                                 return ret;
 301                 }
 302                 for_each_rtd_cpu_dais(rtd, i, sdai) {
 303                         ret = snd_soc_dai_set_sysclk(sdai, 0, mclk, SND_SOC_CLOCK_OUT);
 304                         if (ret && ret != -ENOTSUPP)
 305                                 return ret;
 306                 }
 307         }
 308         return 0;
 309 }
 310 EXPORT_SYMBOL_GPL(asoc_simple_hw_params);
 311
 312 int asoc_simple_be_hw_params_fixup(struct snd_soc_pcm_runtime *rtd,
 313                                    struct snd_pcm_hw_params *params)
 314 {
 315         struct asoc_simple_priv *priv = snd_soc_card_get_drvdata(rtd->card);
 316         struct simple_dai_props *dai_props = simple_priv_to_props(priv, rtd->num);
 317
 318         asoc_simple_convert_fixup(&dai_props->adata, params);
 319
 320         return 0;
 321 }
 322 EXPORT_SYMBOL_GPL(asoc_simple_be_hw_params_fixup);
 323
 324 static int asoc_simple_init_dai(struct snd_soc_dai *dai,
 325                                      struct asoc_simple_dai *simple_dai)
 326 {
 327         int ret;
 328
 329         if (!simple_dai)
 330                 return 0;
 331
 332         if (simple_dai->sysclk) {
 333                 ret = snd_soc_dai_set_sysclk(dai, 0, simple_dai->sysclk,
 334                                              simple_dai->clk_direction);
 335                 if (ret && ret != -ENOTSUPP) {
 336                         dev_err(dai->dev, "simple-card: set_sysclk error\n");
 337                         return ret;
 338                 }
 339         }
 340
 341         if (simple_dai->slots) {
 342                 ret = snd_soc_dai_set_tdm_slot(dai,
 343                                                simple_dai->tx_slot_mask,
 344                                                simple_dai->rx_slot_mask,
 345                                                simple_dai->slots,
 346                                                simple_dai->slot_width);
 347                 if (ret && ret != -ENOTSUPP) {
 348                         dev_err(dai->dev, "simple-card: set_tdm_slot error\n");
 349                         return ret;
 350                 }
 351         }
 352
 353         return 0;
 354 }
 355
 356 static int asoc_simple_init_dai_link_params(struct snd_soc_pcm_runtime *rtd,
 357                                             struct simple_dai_props *dai_props)
 358 {
 359         struct snd_soc_dai_link *dai_link = rtd->dai_link;
 360         struct snd_soc_component *component;
 361         struct snd_soc_pcm_stream *params;
 362         struct snd_pcm_hardware hw;
 363         int i, ret, stream;
 364
 365         /* Only codecs should have non_legacy_dai_naming set. */
 366         for_each_rtd_components(rtd, i, component) {
 367                 if (!component->driver->non_legacy_dai_naming)
 368                         return 0;
 369         }
 370
 371         /* Assumes the capabilities are the same for all supported streams */
 372         for_each_pcm_streams(stream) {
 373                 ret = snd_soc_runtime_calc_hw(rtd, &hw, stream);
 374                 if (ret == 0)
 375                         break;
 376         }
 377
 378         if (ret < 0) {
 379                 dev_err(rtd->dev, "simple-card: no valid dai_link params\n");
 380                 return ret;
 381         }
 382
 383         params = devm_kzalloc(rtd->dev, sizeof(*params), GFP_KERNEL);
 384         if (!params)
 385                 return -ENOMEM;
 386
 387         params->formats = hw.formats;
 388         params->rates = hw.rates;
 389         params->rate_min = hw.rate_min;
 390         params->rate_max = hw.rate_max;
 391         params->channels_min = hw.channels_min;
 392         params->channels_max = hw.channels_max;
 393
 394         dai_link->params = params;
 395         dai_link->num_params = 1;
 396
 397         return 0;
 398 }
 399
 400 int asoc_simple_dai_init(struct snd_soc_pcm_runtime *rtd)
 401 {
 402         struct asoc_simple_priv *priv = snd_soc_card_get_drvdata(rtd->card);
 403         struct simple_dai_props *props = simple_priv_to_props(priv, rtd->num);
 404         struct asoc_simple_dai *dai;
 405         int i, ret;
 406
 407         for_each_prop_dai_codec(props, i, dai) {
 408                 ret = asoc_simple_init_dai(asoc_rtd_to_codec(rtd, i), dai);
 409                 if (ret < 0)
 410                         return ret;
 411         }
 412         for_each_prop_dai_cpu(props, i, dai) {
 413                 ret = asoc_simple_init_dai(asoc_rtd_to_cpu(rtd, i), dai);
 414                 if (ret < 0)
 415                         return ret;
 416         }
 417
 418         ret = asoc_simple_init_dai_link_params(rtd, props);
 419         if (ret < 0)
 420                 return ret;
 421
 422         return 0;
 423 }
 424 EXPORT_SYMBOL_GPL(asoc_simple_dai_init);
 425
 426 void asoc_simple_canonicalize_platform(struct snd_soc_dai_link *dai_link)
 427 {
 428         /* Assumes platform == cpu */
 429         if (!dai_link->platforms->of_node)
 430                 dai_link->platforms->of_node = dai_link->cpus->of_node;
 431 }
 432 EXPORT_SYMBOL_GPL(asoc_simple_canonicalize_platform);
 433
 434 void asoc_simple_canonicalize_cpu(struct snd_soc_dai_link *dai_link,
 435                                   int is_single_links)
 436 {
 437         /*
 438          * In soc_bind_dai_link() will check cpu name after
 439          * of_node matching if dai_link has cpu_dai_name.
 440          * but, it will never match if name was created by
 441          * fmt_single_name() remove cpu_dai_name if cpu_args
 442          * was 0. See:
 443          *      fmt_single_name()
 444          *      fmt_multiple_name()
 445          */
 446         if (is_single_links)
 447                 dai_link->cpus->dai_name = NULL;
 448 }
 449 EXPORT_SYMBOL_GPL(asoc_simple_canonicalize_cpu);
 450
 451 int asoc_simple_clean_reference(struct snd_soc_card *card)
 452 {
 453         struct snd_soc_dai_link *dai_link;
 454         int i;
 455
 456         for_each_card_prelinks(card, i, dai_link) {
 457                 of_node_put(dai_link->cpus->of_node);
 458                 of_node_put(dai_link->codecs->of_node);
 459         }
 460         return 0;
 461 }
 462 EXPORT_SYMBOL_GPL(asoc_simple_clean_reference);
 463
 464 int asoc_simple_parse_routing(struct snd_soc_card *card,
 465                               char *prefix)
 466 {
 467         struct device_node *node = card->dev->of_node;
 468         char prop[128];
 469
 470         if (!prefix)
 471                 prefix = "";
 472
 473         snprintf(prop, sizeof(prop), "%s%s", prefix, "routing");
 474
 475         if (!of_property_read_bool(node, prop))
 476                 return 0;
 477
 478         return snd_soc_of_parse_audio_routing(card, prop);
 479 }
 480 EXPORT_SYMBOL_GPL(asoc_simple_parse_routing);
 481
 482 int asoc_simple_parse_widgets(struct snd_soc_card *card,
 483                               char *prefix)
 484 {
 485         struct device_node *node = card->dev->of_node;
 486         char prop[128];
 487
 488         if (!prefix)
 489                 prefix = "";
 490
 491         snprintf(prop, sizeof(prop), "%s%s", prefix, "widgets");
 492
 493         if (of_property_read_bool(node, prop))
 494                 return snd_soc_of_parse_audio_simple_widgets(card, prop);
 495
 496         /* no widgets is not error */
 497         return 0;
 498 }
 499 EXPORT_SYMBOL_GPL(asoc_simple_parse_widgets);
 500
 501 int asoc_simple_parse_pin_switches(struct snd_soc_card *card,
 502                                    char *prefix)
 503 {
 504         const unsigned int nb_controls_max = 16;
 505         const char **strings, *control_name;
 506         struct snd_kcontrol_new *controls;
 507         struct device *dev = card->dev;
 508         unsigned int i, nb_controls;
 509         char prop[128];
 510         int ret;
 511
 512         if (!prefix)
 513                 prefix = "";
 514
 515         snprintf(prop, sizeof(prop), "%s%s", prefix, "pin-switches");
 516
 517         if (!of_property_read_bool(dev->of_node, prop))
 518                 return 0;
 519
 520         strings = devm_kcalloc(dev, nb_controls_max,
 521                                sizeof(*strings), GFP_KERNEL);
 522         if (!strings)
 523                 return -ENOMEM;
 524
 525         ret = of_property_read_string_array(dev->of_node, prop,
 526                                             strings, nb_controls_max);
 527         if (ret < 0)
 528                 return ret;
 529
 530         nb_controls = (unsigned int)ret;
 531
 532         controls = devm_kcalloc(dev, nb_controls,
 533                                 sizeof(*controls), GFP_KERNEL);
 534         if (!controls)
 535                 return -ENOMEM;
 536
 537         for (i = 0; i < nb_controls; i++) {
 538                 control_name = devm_kasprintf(dev, GFP_KERNEL,
 539                                               "%s Switch", strings[i]);
 540                 if (!control_name)
 541                         return -ENOMEM;
 542
 543                 controls[i].iface = SNDRV_CTL_ELEM_IFACE_MIXER;
 544                 controls[i].name = control_name;
 545                 controls[i].info = snd_soc_dapm_info_pin_switch;
 546                 controls[i].get = snd_soc_dapm_get_pin_switch;
 547                 controls[i].put = snd_soc_dapm_put_pin_switch;
 548                 controls[i].private_value = (unsigned long)strings[i];
 549         }
 550
 551         card->controls = controls;
 552         card->num_controls = nb_controls;
 553
 554         return 0;
 555 }
 556 EXPORT_SYMBOL_GPL(asoc_simple_parse_pin_switches);
 557
 558 int asoc_simple_init_jack(struct snd_soc_card *card,
 559                           struct asoc_simple_jack *sjack,
 560                           int is_hp, char *prefix,
 561                           char *pin)
 562 {
 563         struct device *dev = card->dev;
 564         enum of_gpio_flags flags;
 565         char prop[128];
 566         char *pin_name;
 567         char *gpio_name;
 568         int mask;
 569         int det;
 570
 571         if (!prefix)
 572                 prefix = "";
 573
 574         sjack->gpio.gpio = -ENOENT;
 575
 576         if (is_hp) {
 577                 snprintf(prop, sizeof(prop), "%shp-det-gpio", prefix);
 578                 pin_name        = pin ? pin : "Headphones";
 579                 gpio_name       = "Headphone detection";
 580                 mask            = SND_JACK_HEADPHONE;
 581         } else {
 582                 snprintf(prop, sizeof(prop), "%smic-det-gpio", prefix);
 583                 pin_name        = pin ? pin : "Mic Jack";
 584                 gpio_name       = "Mic detection";
 585                 mask            = SND_JACK_MICROPHONE;
 586         }
 587
 588         det = of_get_named_gpio_flags(dev->of_node, prop, 0, &flags);
 589         if (det == -EPROBE_DEFER)
 590                 return -EPROBE_DEFER;
 591
 592         if (gpio_is_valid(det)) {
 593                 sjack->pin.pin          = pin_name;
 594                 sjack->pin.mask         = mask;
 595
 596                 sjack->gpio.name        = gpio_name;
 597                 sjack->gpio.report      = mask;
 598                 sjack->gpio.gpio        = det;
 599                 sjack->gpio.invert      = !!(flags & OF_GPIO_ACTIVE_LOW);
 600                 sjack->gpio.debounce_time = 150;
 601
 602                 snd_soc_card_jack_new(card, pin_name, mask,
 603                                       &sjack->jack,
 604                                       &sjack->pin, 1);
 605
 606                 snd_soc_jack_add_gpios(&sjack->jack, 1,
 607                                        &sjack->gpio);
 608         }
 609
 610         return 0;
 611 }
 612 EXPORT_SYMBOL_GPL(asoc_simple_init_jack);
 613
 614 int asoc_simple_init_priv(struct asoc_simple_priv *priv,
 615                           struct link_info *li)
 616 {
 617         struct snd_soc_card *card = simple_priv_to_card(priv);
 618         struct device *dev = simple_priv_to_dev(priv);
 619         struct snd_soc_dai_link *dai_link;
 620         struct simple_dai_props *dai_props;
 621         struct asoc_simple_dai *dais;
 622         struct snd_soc_dai_link_component *dlcs;
 623         struct snd_soc_codec_conf *cconf = NULL;
 624         int i, dai_num = 0, dlc_num = 0, cnf_num = 0;
 625
 626         dai_props = devm_kcalloc(dev, li->link, sizeof(*dai_props), GFP_KERNEL);
 627         dai_link  = devm_kcalloc(dev, li->link, sizeof(*dai_link),  GFP_KERNEL);
 628         if (!dai_props || !dai_link)
 629                 return -ENOMEM;
 630
 631         /*
 632          * dais (= CPU+Codec)
 633          * dlcs (= CPU+Codec+Platform)
 634          */
 635         for (i = 0; i < li->link; i++) {
 636                 int cc = li->num[i].cpus + li->num[i].codecs;
 637
 638                 dai_num += cc;
 639                 dlc_num += cc + li->num[i].platforms;
 640
 641                 if (!li->num[i].cpus)
 642                         cnf_num += li->num[i].codecs;
 643         }
 644
 645         dais = devm_kcalloc(dev, dai_num, sizeof(*dais),      GFP_KERNEL);
 646         dlcs = devm_kcalloc(dev, dlc_num, sizeof(*dai_props), GFP_KERNEL);
 647         if (!dais || !dlcs)
 648                 return -ENOMEM;
 649
 650         if (cnf_num) {
 651                 cconf = devm_kcalloc(dev, cnf_num, sizeof(*cconf), GFP_KERNEL);
 652                 if (!cconf)
 653                         return -ENOMEM;
 654         }
 655
 656         dev_dbg(dev, "link %d, dais %d, ccnf %d\n",
 657                 li->link, dai_num, cnf_num);
 658
 659         /* dummy CPU/Codec */
 660         priv->dummy.of_node     = NULL;
 661         priv->dummy.dai_name    = "snd-soc-dummy-dai";
 662         priv->dummy.name        = "snd-soc-dummy";
 663
 664         priv->dai_props         = dai_props;
 665         priv->dai_link          = dai_link;
 666         priv->dais              = dais;
 667         priv->dlcs              = dlcs;
 668         priv->codec_conf        = cconf;
 669
 670         card->dai_link          = priv->dai_link;
 671         card->num_links         = li->link;
 672         card->codec_conf        = cconf;
 673         card->num_configs       = cnf_num;
 674
 675         for (i = 0; i < li->link; i++) {
 676                 if (li->num[i].cpus) {
 677                         /* Normal CPU */
 678                         dai_props[i].cpus       =
 679                         dai_link[i].cpus        = dlcs;
 680                         dai_props[i].num.cpus   =
 681                         dai_link[i].num_cpus    = li->num[i].cpus;
 682                         dai_props[i].cpu_dai    = dais;
 683
 684                         dlcs += li->num[i].cpus;
 685                         dais += li->num[i].cpus;
 686                 } else {
 687                         /* DPCM Be's CPU = dummy */
 688                         dai_props[i].cpus       =
 689                         dai_link[i].cpus        = &priv->dummy;
 690                         dai_props[i].num.cpus   =
 691                         dai_link[i].num_cpus    = 1;
 692                 }
 693
 694                 if (li->num[i].codecs) {
 695                         /* Normal Codec */
 696                         dai_props[i].codecs     =
 697                         dai_link[i].codecs      = dlcs;
 698                         dai_props[i].num.codecs =
 699                         dai_link[i].num_codecs  = li->num[i].codecs;
 700                         dai_props[i].codec_dai  = dais;
 701
 702                         dlcs += li->num[i].codecs;
 703                         dais += li->num[i].codecs;
 704
 705                         if (!li->num[i].cpus) {
 706                                 /* DPCM Be's Codec */
 707                                 dai_props[i].codec_conf = cconf;
 708                                 cconf += li->num[i].codecs;
 709                         }
 710                 } else {
 711                         /* DPCM Fe's Codec = dummy */
 712                         dai_props[i].codecs     =
 713                         dai_link[i].codecs      = &priv->dummy;
 714                         dai_props[i].num.codecs =
 715                         dai_link[i].num_codecs  = 1;
 716                 }
 717
 718                 if (li->num[i].platforms) {
 719                         /* Have Platform */
 720                         dai_props[i].platforms          =
 721                         dai_link[i].platforms           = dlcs;
 722                         dai_props[i].num.platforms      =
 723                         dai_link[i].num_platforms       = li->num[i].platforms;
 724
 725                         dlcs += li->num[i].platforms;
 726                 } else {
 727                         /* Doesn't have Platform */
 728                         dai_props[i].platforms          =
 729                         dai_link[i].platforms           = NULL;
 730                         dai_props[i].num.platforms      =
 731                         dai_link[i].num_platforms       = 0;
 732                 }
 733         }
 734
 735         return 0;
 736 }
 737 EXPORT_SYMBOL_GPL(asoc_simple_init_priv);
 738
 739 /* Module information */
 740 MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>");
 741 MODULE_DESCRIPTION("ALSA SoC Simple Card Utils");
 742 MODULE_LICENSE("GPL v2");