sound/soc/meson/axg-card.c

   1 // SPDX-License-Identifier: (GPL-2.0 OR MIT)
   2 //
   3 // Copyright (c) 2018 BayLibre, SAS.
   4 // Author: Jerome Brunet <jbrunet@baylibre.com>
   5
   6 #include <linux/module.h>
   7 #include <linux/of_platform.h>
   8 #include <sound/soc.h>
   9 #include <sound/soc-dai.h>
  10
  11 #include "axg-tdm.h"
  12
  13 struct axg_card {
  14         struct snd_soc_card card;
  15         void **link_data;
  16 };
  17
  18 struct axg_dai_link_tdm_mask {
  19         u32 tx;
  20         u32 rx;
  21 };
  22
  23 struct axg_dai_link_tdm_data {
  24         unsigned int mclk_fs;
  25         unsigned int slots;
  26         unsigned int slot_width;
  27         u32 *tx_mask;
  28         u32 *rx_mask;
  29         struct axg_dai_link_tdm_mask *codec_masks;
  30 };
  31
  32 /*
  33  * Base params for the codec to codec links
  34  * Those will be over-written by the CPU side of the link
  35  */
  36 static const struct snd_soc_pcm_stream codec_params = {
  37         .formats = SNDRV_PCM_FMTBIT_S24_LE,
  38         .rate_min = 5525,
  39         .rate_max = 192000,
  40         .channels_min = 1,
  41         .channels_max = 8,
  42 };
  43
  44 #define PREFIX "amlogic,"
  45
  46 static int axg_card_reallocate_links(struct axg_card *priv,
  47                                      unsigned int num_links)
  48 {
  49         struct snd_soc_dai_link *links;
  50         void **ldata;
  51
  52         links = krealloc(priv->card.dai_link,
  53                          num_links * sizeof(*priv->card.dai_link),
  54                          GFP_KERNEL | __GFP_ZERO);
  55         ldata = krealloc(priv->link_data,
  56                          num_links * sizeof(*priv->link_data),
  57                          GFP_KERNEL | __GFP_ZERO);
  58
  59         if (!links || !ldata) {
  60                 dev_err(priv->card.dev, "failed to allocate links\n");
  61                 return -ENOMEM;
  62         }
  63
  64         priv->card.dai_link = links;
  65         priv->link_data = ldata;
  66         priv->card.num_links = num_links;
  67         return 0;
  68 }
  69
  70 static int axg_card_parse_dai(struct snd_soc_card *card,
  71                               struct device_node *node,
  72                               struct device_node **dai_of_node,
  73                               const char **dai_name)
  74 {
  75         struct of_phandle_args args;
  76         int ret;
  77
  78         if (!dai_name || !dai_of_node || !node)
  79                 return -EINVAL;
  80
  81         ret = of_parse_phandle_with_args(node, "sound-dai",
  82                                          "#sound-dai-cells", 0, &args);
  83         if (ret) {
  84                 if (ret != -EPROBE_DEFER)
  85                         dev_err(card->dev, "can't parse dai %d\n", ret);
  86                 return ret;
  87         }
  88         *dai_of_node = args.np;
  89
  90         return snd_soc_get_dai_name(&args, dai_name);
  91 }
  92
  93 static int axg_card_set_link_name(struct snd_soc_card *card,
  94                                   struct snd_soc_dai_link *link,
  95                                   struct device_node *node,
  96                                   const char *prefix)
  97 {
  98         char *name = devm_kasprintf(card->dev, GFP_KERNEL, "%s.%s",
  99                                     prefix, node->full_name);
 100         if (!name)
 101                 return -ENOMEM;
 102
 103         link->name = name;
 104         link->stream_name = name;
 105
 106         return 0;
 107 }
 108
 109 static void axg_card_clean_references(struct axg_card *priv)
 110 {
 111         struct snd_soc_card *card = &priv->card;
 112         struct snd_soc_dai_link *link;
 113         struct snd_soc_dai_link_component *codec;
 114         struct snd_soc_aux_dev *aux;
 115         int i, j;
 116
 117         if (card->dai_link) {
 118                 for_each_card_prelinks(card, i, link) {
 119                         if (link->cpus)
 120                                 of_node_put(link->cpus->of_node);
 121                         for_each_link_codecs(link, j, codec)
 122                                 of_node_put(codec->of_node);
 123                 }
 124         }
 125
 126         if (card->aux_dev) {
 127                 for_each_card_pre_auxs(card, i, aux)
 128                         of_node_put(aux->dlc.of_node);
 129         }
 130
 131         kfree(card->dai_link);
 132         kfree(priv->link_data);
 133 }
 134
 135 static int axg_card_add_aux_devices(struct snd_soc_card *card)
 136 {
 137         struct device_node *node = card->dev->of_node;
 138         struct snd_soc_aux_dev *aux;
 139         int num, i;
 140
 141         num = of_count_phandle_with_args(node, "audio-aux-devs", NULL);
 142         if (num == -ENOENT) {
 143                 /*
 144                  * It is ok to have no auxiliary devices but for this card it
 145                  * is a strange situtation. Let's warn the about it.
 146                  */
 147                 dev_warn(card->dev, "card has no auxiliary devices\n");
 148                 return 0;
 149         } else if (num < 0) {
 150                 dev_err(card->dev, "error getting auxiliary devices: %d\n",
 151                         num);
 152                 return num;
 153         }
 154
 155         aux = devm_kcalloc(card->dev, num, sizeof(*aux), GFP_KERNEL);
 156         if (!aux)
 157                 return -ENOMEM;
 158         card->aux_dev = aux;
 159         card->num_aux_devs = num;
 160
 161         for_each_card_pre_auxs(card, i, aux) {
 162                 aux->dlc.of_node =
 163                         of_parse_phandle(node, "audio-aux-devs", i);
 164                 if (!aux->dlc.of_node)
 165                         return -EINVAL;
 166         }
 167
 168         return 0;
 169 }
 170
 171 static int axg_card_tdm_be_hw_params(struct snd_pcm_substream *substream,
 172                                      struct snd_pcm_hw_params *params)
 173 {
 174         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 175         struct axg_card *priv = snd_soc_card_get_drvdata(rtd->card);
 176         struct axg_dai_link_tdm_data *be =
 177                 (struct axg_dai_link_tdm_data *)priv->link_data[rtd->num];
 178         struct snd_soc_dai *codec_dai;
 179         unsigned int mclk;
 180         int ret, i;
 181
 182         if (be->mclk_fs) {
 183                 mclk = params_rate(params) * be->mclk_fs;
 184
 185                 for_each_rtd_codec_dai(rtd, i, codec_dai) {
 186                         ret = snd_soc_dai_set_sysclk(codec_dai, 0, mclk,
 187                                                      SND_SOC_CLOCK_IN);
 188                         if (ret && ret != -ENOTSUPP)
 189                                 return ret;
 190                 }
 191
 192                 ret = snd_soc_dai_set_sysclk(rtd->cpu_dai, 0, mclk,
 193                                              SND_SOC_CLOCK_OUT);
 194                 if (ret && ret != -ENOTSUPP)
 195                         return ret;
 196         }
 197
 198         return 0;
 199 }
 200
 201 static const struct snd_soc_ops axg_card_tdm_be_ops = {
 202         .hw_params = axg_card_tdm_be_hw_params,
 203 };
 204
 205 static int axg_card_tdm_dai_init(struct snd_soc_pcm_runtime *rtd)
 206 {
 207         struct axg_card *priv = snd_soc_card_get_drvdata(rtd->card);
 208         struct axg_dai_link_tdm_data *be =
 209                 (struct axg_dai_link_tdm_data *)priv->link_data[rtd->num];
 210         struct snd_soc_dai *codec_dai;
 211         int ret, i;
 212
 213         for_each_rtd_codec_dai(rtd, i, codec_dai) {
 214                 ret = snd_soc_dai_set_tdm_slot(codec_dai,
 215                                                be->codec_masks[i].tx,
 216                                                be->codec_masks[i].rx,
 217                                                be->slots, be->slot_width);
 218                 if (ret && ret != -ENOTSUPP) {
 219                         dev_err(codec_dai->dev,
 220                                 "setting tdm link slots failed\n");
 221                         return ret;
 222                 }
 223         }
 224
 225         ret = axg_tdm_set_tdm_slots(rtd->cpu_dai, be->tx_mask, be->rx_mask,
 226                                     be->slots, be->slot_width);
 227         if (ret) {
 228                 dev_err(rtd->cpu_dai->dev, "setting tdm link slots failed\n");
 229                 return ret;
 230         }
 231
 232         return 0;
 233 }
 234
 235 static int axg_card_tdm_dai_lb_init(struct snd_soc_pcm_runtime *rtd)
 236 {
 237         struct axg_card *priv = snd_soc_card_get_drvdata(rtd->card);
 238         struct axg_dai_link_tdm_data *be =
 239                 (struct axg_dai_link_tdm_data *)priv->link_data[rtd->num];
 240         int ret;
 241
 242         /* The loopback rx_mask is the pad tx_mask */
 243         ret = axg_tdm_set_tdm_slots(rtd->cpu_dai, NULL, be->tx_mask,
 244                                     be->slots, be->slot_width);
 245         if (ret) {
 246                 dev_err(rtd->cpu_dai->dev, "setting tdm link slots failed\n");
 247                 return ret;
 248         }
 249
 250         return 0;
 251 }
 252
 253 static int axg_card_add_tdm_loopback(struct snd_soc_card *card,
 254                                      int *index)
 255 {
 256         struct axg_card *priv = snd_soc_card_get_drvdata(card);
 257         struct snd_soc_dai_link *pad = &card->dai_link[*index];
 258         struct snd_soc_dai_link *lb;
 259         struct snd_soc_dai_link_component *dlc;
 260         int ret;
 261
 262         /* extend links */
 263         ret = axg_card_reallocate_links(priv, card->num_links + 1);
 264         if (ret)
 265                 return ret;
 266
 267         lb = &card->dai_link[*index + 1];
 268
 269         lb->name = kasprintf(GFP_KERNEL, "%s-lb", pad->name);
 270         if (!lb->name)
 271                 return -ENOMEM;
 272
 273         dlc = devm_kzalloc(card->dev, 2 * sizeof(*dlc), GFP_KERNEL);
 274         if (!dlc)
 275                 return -ENOMEM;
 276
 277         lb->cpus = &dlc[0];
 278         lb->codecs = &dlc[1];
 279         lb->num_cpus = 1;
 280         lb->num_codecs = 1;
 281
 282         lb->stream_name = lb->name;
 283         lb->cpus->of_node = pad->cpus->of_node;
 284         lb->cpus->dai_name = "TDM Loopback";
 285         lb->codecs->name = "snd-soc-dummy";
 286         lb->codecs->dai_name = "snd-soc-dummy-dai";
 287         lb->dpcm_capture = 1;
 288         lb->no_pcm = 1;
 289         lb->ops = &axg_card_tdm_be_ops;
 290         lb->init = axg_card_tdm_dai_lb_init;
 291
 292         /* Provide the same link data to the loopback */
 293         priv->link_data[*index + 1] = priv->link_data[*index];
 294
 295         /*
 296          * axg_card_clean_references() will iterate over this link,
 297          * make sure the node count is balanced
 298          */
 299         of_node_get(lb->cpus->of_node);
 300
 301         /* Let add_links continue where it should */
 302         *index += 1;
 303
 304         return 0;
 305 }
 306
 307 static unsigned int axg_card_parse_daifmt(struct device_node *node,
 308                                           struct device_node *cpu_node)
 309 {
 310         struct device_node *bitclkmaster = NULL;
 311         struct device_node *framemaster = NULL;
 312         unsigned int daifmt;
 313
 314         daifmt = snd_soc_of_parse_daifmt(node, PREFIX,
 315                                          &bitclkmaster, &framemaster);
 316         daifmt &= ~SND_SOC_DAIFMT_MASTER_MASK;
 317
 318         /* If no master is provided, default to cpu master */
 319         if (!bitclkmaster || bitclkmaster == cpu_node) {
 320                 daifmt |= (!framemaster || framemaster == cpu_node) ?
 321                         SND_SOC_DAIFMT_CBS_CFS : SND_SOC_DAIFMT_CBS_CFM;
 322         } else {
 323                 daifmt |= (!framemaster || framemaster == cpu_node) ?
 324                         SND_SOC_DAIFMT_CBM_CFS : SND_SOC_DAIFMT_CBM_CFM;
 325         }
 326
 327         of_node_put(bitclkmaster);
 328         of_node_put(framemaster);
 329
 330         return daifmt;
 331 }
 332
 333 static int axg_card_parse_cpu_tdm_slots(struct snd_soc_card *card,
 334                                         struct snd_soc_dai_link *link,
 335                                         struct device_node *node,
 336                                         struct axg_dai_link_tdm_data *be)
 337 {
 338         char propname[32];
 339         u32 tx, rx;
 340         int i;
 341
 342         be->tx_mask = devm_kcalloc(card->dev, AXG_TDM_NUM_LANES,
 343                                    sizeof(*be->tx_mask), GFP_KERNEL);
 344         be->rx_mask = devm_kcalloc(card->dev, AXG_TDM_NUM_LANES,
 345                                    sizeof(*be->rx_mask), GFP_KERNEL);
 346         if (!be->tx_mask || !be->rx_mask)
 347                 return -ENOMEM;
 348
 349         for (i = 0, tx = 0; i < AXG_TDM_NUM_LANES; i++) {
 350                 snprintf(propname, 32, "dai-tdm-slot-tx-mask-%d", i);
 351                 snd_soc_of_get_slot_mask(node, propname, &be->tx_mask[i]);
 352                 tx = max(tx, be->tx_mask[i]);
 353         }
 354
 355         /* Disable playback is the interface has no tx slots */
 356         if (!tx)
 357                 link->dpcm_playback = 0;
 358
 359         for (i = 0, rx = 0; i < AXG_TDM_NUM_LANES; i++) {
 360                 snprintf(propname, 32, "dai-tdm-slot-rx-mask-%d", i);
 361                 snd_soc_of_get_slot_mask(node, propname, &be->rx_mask[i]);
 362                 rx = max(rx, be->rx_mask[i]);
 363         }
 364
 365         /* Disable capture is the interface has no rx slots */
 366         if (!rx)
 367                 link->dpcm_capture = 0;
 368
 369         /* ... but the interface should at least have one of them */
 370         if (!tx && !rx) {
 371                 dev_err(card->dev, "tdm link has no cpu slots\n");
 372                 return -EINVAL;
 373         }
 374
 375         of_property_read_u32(node, "dai-tdm-slot-num", &be->slots);
 376         if (!be->slots) {
 377                 /*
 378                  * If the slot number is not provided, set it such as it
 379                  * accommodates the largest mask
 380                  */
 381                 be->slots = fls(max(tx, rx));
 382         } else if (be->slots < fls(max(tx, rx)) || be->slots > 32) {
 383                 /*
 384                  * Error if the slots can't accommodate the largest mask or
 385                  * if it is just too big
 386                  */
 387                 dev_err(card->dev, "bad slot number\n");
 388                 return -EINVAL;
 389         }
 390
 391         of_property_read_u32(node, "dai-tdm-slot-width", &be->slot_width);
 392
 393         return 0;
 394 }
 395
 396 static int axg_card_parse_codecs_masks(struct snd_soc_card *card,
 397                                        struct snd_soc_dai_link *link,
 398                                        struct device_node *node,
 399                                        struct axg_dai_link_tdm_data *be)
 400 {
 401         struct axg_dai_link_tdm_mask *codec_mask;
 402         struct device_node *np;
 403
 404         codec_mask = devm_kcalloc(card->dev, link->num_codecs,
 405                                   sizeof(*codec_mask), GFP_KERNEL);
 406         if (!codec_mask)
 407                 return -ENOMEM;
 408
 409         be->codec_masks = codec_mask;
 410
 411         for_each_child_of_node(node, np) {
 412                 snd_soc_of_get_slot_mask(np, "dai-tdm-slot-rx-mask",
 413                                          &codec_mask->rx);
 414                 snd_soc_of_get_slot_mask(np, "dai-tdm-slot-tx-mask",
 415                                          &codec_mask->tx);
 416
 417                 codec_mask++;
 418         }
 419
 420         return 0;
 421 }
 422
 423 static int axg_card_parse_tdm(struct snd_soc_card *card,
 424                               struct device_node *node,
 425                               int *index)
 426 {
 427         struct axg_card *priv = snd_soc_card_get_drvdata(card);
 428         struct snd_soc_dai_link *link = &card->dai_link[*index];
 429         struct axg_dai_link_tdm_data *be;
 430         int ret;
 431
 432         /* Allocate tdm link parameters */
 433         be = devm_kzalloc(card->dev, sizeof(*be), GFP_KERNEL);
 434         if (!be)
 435                 return -ENOMEM;
 436         priv->link_data[*index] = be;
 437
 438         /* Setup tdm link */
 439         link->ops = &axg_card_tdm_be_ops;
 440         link->init = axg_card_tdm_dai_init;
 441         link->dai_fmt = axg_card_parse_daifmt(node, link->cpus->of_node);
 442
 443         of_property_read_u32(node, "mclk-fs", &be->mclk_fs);
 444
 445         ret = axg_card_parse_cpu_tdm_slots(card, link, node, be);
 446         if (ret) {
 447                 dev_err(card->dev, "error parsing tdm link slots\n");
 448                 return ret;
 449         }
 450
 451         ret = axg_card_parse_codecs_masks(card, link, node, be);
 452         if (ret)
 453                 return ret;
 454
 455         /* Add loopback if the pad dai has playback */
 456         if (link->dpcm_playback) {
 457                 ret = axg_card_add_tdm_loopback(card, index);
 458                 if (ret)
 459                         return ret;
 460         }
 461
 462         return 0;
 463 }
 464
 465 static int axg_card_set_be_link(struct snd_soc_card *card,
 466                                 struct snd_soc_dai_link *link,
 467                                 struct device_node *node)
 468 {
 469         struct snd_soc_dai_link_component *codec;
 470         struct device_node *np;
 471         int ret, num_codecs;
 472
 473         link->no_pcm = 1;
 474         link->dpcm_playback = 1;
 475         link->dpcm_capture = 1;
 476
 477         num_codecs = of_get_child_count(node);
 478         if (!num_codecs) {
 479                 dev_err(card->dev, "be link %s has no codec\n",
 480                         node->full_name);
 481                 return -EINVAL;
 482         }
 483
 484         codec = devm_kcalloc(card->dev, num_codecs, sizeof(*codec), GFP_KERNEL);
 485         if (!codec)
 486                 return -ENOMEM;
 487
 488         link->codecs = codec;
 489         link->num_codecs = num_codecs;
 490
 491         for_each_child_of_node(node, np) {
 492                 ret = axg_card_parse_dai(card, np, &codec->of_node,
 493                                          &codec->dai_name);
 494                 if (ret) {
 495                         of_node_put(np);
 496                         return ret;
 497                 }
 498
 499                 codec++;
 500         }
 501
 502         ret = axg_card_set_link_name(card, link, node, "be");
 503         if (ret)
 504                 dev_err(card->dev, "error setting %pOFn link name\n", np);
 505
 506         return ret;
 507 }
 508
 509 static int axg_card_set_fe_link(struct snd_soc_card *card,
 510                                 struct snd_soc_dai_link *link,
 511                                 struct device_node *node,
 512                                 bool is_playback)
 513 {
 514         struct snd_soc_dai_link_component *codec;
 515
 516         codec = devm_kzalloc(card->dev, sizeof(*codec), GFP_KERNEL);
 517         if (!codec)
 518                 return -ENOMEM;
 519
 520         link->codecs = codec;
 521         link->num_codecs = 1;
 522
 523         link->dynamic = 1;
 524         link->dpcm_merged_format = 1;
 525         link->dpcm_merged_chan = 1;
 526         link->dpcm_merged_rate = 1;
 527         link->codecs->dai_name = "snd-soc-dummy-dai";
 528         link->codecs->name = "snd-soc-dummy";
 529
 530         if (is_playback)
 531                 link->dpcm_playback = 1;
 532         else
 533                 link->dpcm_capture = 1;
 534
 535         return axg_card_set_link_name(card, link, node, "fe");
 536 }
 537
 538 static int axg_card_cpu_is_capture_fe(struct device_node *np)
 539 {
 540         return of_device_is_compatible(np, PREFIX "axg-toddr");
 541 }
 542
 543 static int axg_card_cpu_is_playback_fe(struct device_node *np)
 544 {
 545         return of_device_is_compatible(np, PREFIX "axg-frddr");
 546 }
 547
 548 static int axg_card_cpu_is_tdm_iface(struct device_node *np)
 549 {
 550         return of_device_is_compatible(np, PREFIX "axg-tdm-iface");
 551 }
 552
 553 static int axg_card_cpu_is_codec(struct device_node *np)
 554 {
 555         return of_device_is_compatible(np, PREFIX "g12a-tohdmitx");
 556 }
 557
 558 static int axg_card_add_link(struct snd_soc_card *card, struct device_node *np,
 559                              int *index)
 560 {
 561         struct snd_soc_dai_link *dai_link = &card->dai_link[*index];
 562         struct snd_soc_dai_link_component *cpu;
 563         int ret;
 564
 565         cpu = devm_kzalloc(card->dev, sizeof(*cpu), GFP_KERNEL);
 566         if (!cpu)
 567                 return -ENOMEM;
 568
 569         dai_link->cpus = cpu;
 570         dai_link->num_cpus = 1;
 571
 572         ret = axg_card_parse_dai(card, np, &dai_link->cpus->of_node,
 573                                  &dai_link->cpus->dai_name);
 574         if (ret)
 575                 return ret;
 576
 577         if (axg_card_cpu_is_playback_fe(dai_link->cpus->of_node))
 578                 ret = axg_card_set_fe_link(card, dai_link, np, true);
 579         else if (axg_card_cpu_is_capture_fe(dai_link->cpus->of_node))
 580                 ret = axg_card_set_fe_link(card, dai_link, np, false);
 581         else
 582                 ret = axg_card_set_be_link(card, dai_link, np);
 583
 584         if (ret)
 585                 return ret;
 586
 587         if (axg_card_cpu_is_tdm_iface(dai_link->cpus->of_node))
 588                 ret = axg_card_parse_tdm(card, np, index);
 589         else if (axg_card_cpu_is_codec(dai_link->cpus->of_node))
 590                 dai_link->params = &codec_params;
 591
 592         return ret;
 593 }
 594
 595 static int axg_card_add_links(struct snd_soc_card *card)
 596 {
 597         struct axg_card *priv = snd_soc_card_get_drvdata(card);
 598         struct device_node *node = card->dev->of_node;
 599         struct device_node *np;
 600         int num, i, ret;
 601
 602         num = of_get_child_count(node);
 603         if (!num) {
 604                 dev_err(card->dev, "card has no links\n");
 605                 return -EINVAL;
 606         }
 607
 608         ret = axg_card_reallocate_links(priv, num);
 609         if (ret)
 610                 return ret;
 611
 612         i = 0;
 613         for_each_child_of_node(node, np) {
 614                 ret = axg_card_add_link(card, np, &i);
 615                 if (ret) {
 616                         of_node_put(np);
 617                         return ret;
 618                 }
 619
 620                 i++;
 621         }
 622
 623         return 0;
 624 }
 625
 626 static int axg_card_parse_of_optional(struct snd_soc_card *card,
 627                                       const char *propname,
 628                                       int (*func)(struct snd_soc_card *c,
 629                                                   const char *p))
 630 {
 631         /* If property is not provided, don't fail ... */
 632         if (!of_property_read_bool(card->dev->of_node, propname))
 633                 return 0;
 634
 635         /* ... but do fail if it is provided and the parsing fails */
 636         return func(card, propname);
 637 }
 638
 639 static const struct of_device_id axg_card_of_match[] = {
 640         { .compatible = "amlogic,axg-sound-card", },
 641         {}
 642 };
 643 MODULE_DEVICE_TABLE(of, axg_card_of_match);
 644
 645 static int axg_card_probe(struct platform_device *pdev)
 646 {
 647         struct device *dev = &pdev->dev;
 648         struct axg_card *priv;
 649         int ret;
 650
 651         priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
 652         if (!priv)
 653                 return -ENOMEM;
 654
 655         platform_set_drvdata(pdev, priv);
 656         snd_soc_card_set_drvdata(&priv->card, priv);
 657
 658         priv->card.owner = THIS_MODULE;
 659         priv->card.dev = dev;
 660
 661         ret = snd_soc_of_parse_card_name(&priv->card, "model");
 662         if (ret < 0)
 663                 return ret;
 664
 665         ret = axg_card_parse_of_optional(&priv->card, "audio-routing",
 666                                          snd_soc_of_parse_audio_routing);
 667         if (ret) {
 668                 dev_err(dev, "error while parsing routing\n");
 669                 return ret;
 670         }
 671
 672         ret = axg_card_parse_of_optional(&priv->card, "audio-widgets",
 673                                          snd_soc_of_parse_audio_simple_widgets);
 674         if (ret) {
 675                 dev_err(dev, "error while parsing widgets\n");
 676                 return ret;
 677         }
 678
 679         ret = axg_card_add_links(&priv->card);
 680         if (ret)
 681                 goto out_err;
 682
 683         ret = axg_card_add_aux_devices(&priv->card);
 684         if (ret)
 685                 goto out_err;
 686
 687         ret = devm_snd_soc_register_card(dev, &priv->card);
 688         if (ret)
 689                 goto out_err;
 690
 691         return 0;
 692
 693 out_err:
 694         axg_card_clean_references(priv);
 695         return ret;
 696 }
 697
 698 static int axg_card_remove(struct platform_device *pdev)
 699 {
 700         struct axg_card *priv = platform_get_drvdata(pdev);
 701
 702         axg_card_clean_references(priv);
 703
 704         return 0;
 705 }
 706
 707 static struct platform_driver axg_card_pdrv = {
 708         .probe = axg_card_probe,
 709         .remove = axg_card_remove,
 710         .driver = {
 711                 .name = "axg-sound-card",
 712                 .of_match_table = axg_card_of_match,
 713         },
 714 };
 715 module_platform_driver(axg_card_pdrv);
 716
 717 MODULE_DESCRIPTION("Amlogic AXG ALSA machine driver");
 718 MODULE_AUTHOR("Jerome Brunet <jbrunet@baylibre.com>");
 719 MODULE_LICENSE("GPL v2");