sound/soc/soc-dai.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 //
   3 // soc-dai.c
   4 //
   5 // Copyright (C) 2019 Renesas Electronics Corp.
   6 // Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
   7 //
   8
   9 #include <sound/soc.h>
  10 #include <sound/soc-dai.h>
  11 #include <sound/soc-link.h>
  12
  13 #define soc_dai_ret(dai, ret) _soc_dai_ret(dai, __func__, ret)
  14 static inline int _soc_dai_ret(struct snd_soc_dai *dai,
  15                                const char *func, int ret)
  16 {
  17         /* Positive, Zero values are not errors */
  18         if (ret >= 0)
  19                 return ret;
  20
  21         /* Negative values might be errors */
  22         switch (ret) {
  23         case -EPROBE_DEFER:
  24         case -ENOTSUPP:
  25                 break;
  26         default:
  27                 dev_err(dai->dev,
  28                         "ASoC: error at %s on %s: %d\n",
  29                         func, dai->name, ret);
  30         }
  31
  32         return ret;
  33 }
  34
  35 /**
  36  * snd_soc_dai_set_sysclk - configure DAI system or master clock.
  37  * @dai: DAI
  38  * @clk_id: DAI specific clock ID
  39  * @freq: new clock frequency in Hz
  40  * @dir: new clock direction - input/output.
  41  *
  42  * Configures the DAI master (MCLK) or system (SYSCLK) clocking.
  43  */
  44 int snd_soc_dai_set_sysclk(struct snd_soc_dai *dai, int clk_id,
  45                            unsigned int freq, int dir)
  46 {
  47         int ret;
  48
  49         if (dai->driver->ops &&
  50             dai->driver->ops->set_sysclk)
  51                 ret = dai->driver->ops->set_sysclk(dai, clk_id, freq, dir);
  52         else
  53                 ret = snd_soc_component_set_sysclk(dai->component, clk_id, 0,
  54                                                    freq, dir);
  55
  56         return soc_dai_ret(dai, ret);
  57 }
  58 EXPORT_SYMBOL_GPL(snd_soc_dai_set_sysclk);
  59
  60 /**
  61  * snd_soc_dai_set_clkdiv - configure DAI clock dividers.
  62  * @dai: DAI
  63  * @div_id: DAI specific clock divider ID
  64  * @div: new clock divisor.
  65  *
  66  * Configures the clock dividers. This is used to derive the best DAI bit and
  67  * frame clocks from the system or master clock. It's best to set the DAI bit
  68  * and frame clocks as low as possible to save system power.
  69  */
  70 int snd_soc_dai_set_clkdiv(struct snd_soc_dai *dai,
  71                            int div_id, int div)
  72 {
  73         int ret = -EINVAL;
  74
  75         if (dai->driver->ops &&
  76             dai->driver->ops->set_clkdiv)
  77                 ret = dai->driver->ops->set_clkdiv(dai, div_id, div);
  78
  79         return soc_dai_ret(dai, ret);
  80 }
  81 EXPORT_SYMBOL_GPL(snd_soc_dai_set_clkdiv);
  82
  83 /**
  84  * snd_soc_dai_set_pll - configure DAI PLL.
  85  * @dai: DAI
  86  * @pll_id: DAI specific PLL ID
  87  * @source: DAI specific source for the PLL
  88  * @freq_in: PLL input clock frequency in Hz
  89  * @freq_out: requested PLL output clock frequency in Hz
  90  *
  91  * Configures and enables PLL to generate output clock based on input clock.
  92  */
  93 int snd_soc_dai_set_pll(struct snd_soc_dai *dai, int pll_id, int source,
  94                         unsigned int freq_in, unsigned int freq_out)
  95 {
  96         int ret;
  97
  98         if (dai->driver->ops &&
  99             dai->driver->ops->set_pll)
 100                 ret = dai->driver->ops->set_pll(dai, pll_id, source,
 101                                                 freq_in, freq_out);
 102         else
 103                 ret = snd_soc_component_set_pll(dai->component, pll_id, source,
 104                                                 freq_in, freq_out);
 105
 106         return soc_dai_ret(dai, ret);
 107 }
 108 EXPORT_SYMBOL_GPL(snd_soc_dai_set_pll);
 109
 110 /**
 111  * snd_soc_dai_set_bclk_ratio - configure BCLK to sample rate ratio.
 112  * @dai: DAI
 113  * @ratio: Ratio of BCLK to Sample rate.
 114  *
 115  * Configures the DAI for a preset BCLK to sample rate ratio.
 116  */
 117 int snd_soc_dai_set_bclk_ratio(struct snd_soc_dai *dai, unsigned int ratio)
 118 {
 119         int ret = -EINVAL;
 120
 121         if (dai->driver->ops &&
 122             dai->driver->ops->set_bclk_ratio)
 123                 ret = dai->driver->ops->set_bclk_ratio(dai, ratio);
 124
 125         return soc_dai_ret(dai, ret);
 126 }
 127 EXPORT_SYMBOL_GPL(snd_soc_dai_set_bclk_ratio);
 128
 129 /**
 130  * snd_soc_dai_set_fmt - configure DAI hardware audio format.
 131  * @dai: DAI
 132  * @fmt: SND_SOC_DAIFMT_* format value.
 133  *
 134  * Configures the DAI hardware format and clocking.
 135  */
 136 int snd_soc_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
 137 {
 138         int ret = -ENOTSUPP;
 139
 140         if (dai->driver->ops &&
 141             dai->driver->ops->set_fmt)
 142                 ret = dai->driver->ops->set_fmt(dai, fmt);
 143
 144         return soc_dai_ret(dai, ret);
 145 }
 146 EXPORT_SYMBOL_GPL(snd_soc_dai_set_fmt);
 147
 148 /**
 149  * snd_soc_xlate_tdm_slot - generate tx/rx slot mask.
 150  * @slots: Number of slots in use.
 151  * @tx_mask: bitmask representing active TX slots.
 152  * @rx_mask: bitmask representing active RX slots.
 153  *
 154  * Generates the TDM tx and rx slot default masks for DAI.
 155  */
 156 static int snd_soc_xlate_tdm_slot_mask(unsigned int slots,
 157                                        unsigned int *tx_mask,
 158                                        unsigned int *rx_mask)
 159 {
 160         if (*tx_mask || *rx_mask)
 161                 return 0;
 162
 163         if (!slots)
 164                 return -EINVAL;
 165
 166         *tx_mask = (1 << slots) - 1;
 167         *rx_mask = (1 << slots) - 1;
 168
 169         return 0;
 170 }
 171
 172 /**
 173  * snd_soc_dai_set_tdm_slot() - Configures a DAI for TDM operation
 174  * @dai: The DAI to configure
 175  * @tx_mask: bitmask representing active TX slots.
 176  * @rx_mask: bitmask representing active RX slots.
 177  * @slots: Number of slots in use.
 178  * @slot_width: Width in bits for each slot.
 179  *
 180  * This function configures the specified DAI for TDM operation. @slot contains
 181  * the total number of slots of the TDM stream and @slot_with the width of each
 182  * slot in bit clock cycles. @tx_mask and @rx_mask are bitmasks specifying the
 183  * active slots of the TDM stream for the specified DAI, i.e. which slots the
 184  * DAI should write to or read from. If a bit is set the corresponding slot is
 185  * active, if a bit is cleared the corresponding slot is inactive. Bit 0 maps to
 186  * the first slot, bit 1 to the second slot and so on. The first active slot
 187  * maps to the first channel of the DAI, the second active slot to the second
 188  * channel and so on.
 189  *
 190  * TDM mode can be disabled by passing 0 for @slots. In this case @tx_mask,
 191  * @rx_mask and @slot_width will be ignored.
 192  *
 193  * Returns 0 on success, a negative error code otherwise.
 194  */
 195 int snd_soc_dai_set_tdm_slot(struct snd_soc_dai *dai,
 196                              unsigned int tx_mask, unsigned int rx_mask,
 197                              int slots, int slot_width)
 198 {
 199         int ret = -ENOTSUPP;
 200
 201         if (dai->driver->ops &&
 202             dai->driver->ops->xlate_tdm_slot_mask)
 203                 dai->driver->ops->xlate_tdm_slot_mask(slots,
 204                                                       &tx_mask, &rx_mask);
 205         else
 206                 snd_soc_xlate_tdm_slot_mask(slots, &tx_mask, &rx_mask);
 207
 208         dai->tx_mask = tx_mask;
 209         dai->rx_mask = rx_mask;
 210
 211         if (dai->driver->ops &&
 212             dai->driver->ops->set_tdm_slot)
 213                 ret = dai->driver->ops->set_tdm_slot(dai, tx_mask, rx_mask,
 214                                                       slots, slot_width);
 215         return soc_dai_ret(dai, ret);
 216 }
 217 EXPORT_SYMBOL_GPL(snd_soc_dai_set_tdm_slot);
 218
 219 /**
 220  * snd_soc_dai_set_channel_map - configure DAI audio channel map
 221  * @dai: DAI
 222  * @tx_num: how many TX channels
 223  * @tx_slot: pointer to an array which imply the TX slot number channel
 224  *           0~num-1 uses
 225  * @rx_num: how many RX channels
 226  * @rx_slot: pointer to an array which imply the RX slot number channel
 227  *           0~num-1 uses
 228  *
 229  * configure the relationship between channel number and TDM slot number.
 230  */
 231 int snd_soc_dai_set_channel_map(struct snd_soc_dai *dai,
 232                                 unsigned int tx_num, unsigned int *tx_slot,
 233                                 unsigned int rx_num, unsigned int *rx_slot)
 234 {
 235         int ret = -ENOTSUPP;
 236
 237         if (dai->driver->ops &&
 238             dai->driver->ops->set_channel_map)
 239                 ret = dai->driver->ops->set_channel_map(dai, tx_num, tx_slot,
 240                                                         rx_num, rx_slot);
 241         return soc_dai_ret(dai, ret);
 242 }
 243 EXPORT_SYMBOL_GPL(snd_soc_dai_set_channel_map);
 244
 245 /**
 246  * snd_soc_dai_get_channel_map - Get DAI audio channel map
 247  * @dai: DAI
 248  * @tx_num: how many TX channels
 249  * @tx_slot: pointer to an array which imply the TX slot number channel
 250  *           0~num-1 uses
 251  * @rx_num: how many RX channels
 252  * @rx_slot: pointer to an array which imply the RX slot number channel
 253  *           0~num-1 uses
 254  */
 255 int snd_soc_dai_get_channel_map(struct snd_soc_dai *dai,
 256                                 unsigned int *tx_num, unsigned int *tx_slot,
 257                                 unsigned int *rx_num, unsigned int *rx_slot)
 258 {
 259         int ret = -ENOTSUPP;
 260
 261         if (dai->driver->ops &&
 262             dai->driver->ops->get_channel_map)
 263                 ret = dai->driver->ops->get_channel_map(dai, tx_num, tx_slot,
 264                                                         rx_num, rx_slot);
 265         return soc_dai_ret(dai, ret);
 266 }
 267 EXPORT_SYMBOL_GPL(snd_soc_dai_get_channel_map);
 268
 269 /**
 270  * snd_soc_dai_set_tristate - configure DAI system or master clock.
 271  * @dai: DAI
 272  * @tristate: tristate enable
 273  *
 274  * Tristates the DAI so that others can use it.
 275  */
 276 int snd_soc_dai_set_tristate(struct snd_soc_dai *dai, int tristate)
 277 {
 278         int ret = -EINVAL;
 279
 280         if (dai->driver->ops &&
 281             dai->driver->ops->set_tristate)
 282                 ret = dai->driver->ops->set_tristate(dai, tristate);
 283
 284         return soc_dai_ret(dai, ret);
 285 }
 286 EXPORT_SYMBOL_GPL(snd_soc_dai_set_tristate);
 287
 288 /**
 289  * snd_soc_dai_digital_mute - configure DAI system or master clock.
 290  * @dai: DAI
 291  * @mute: mute enable
 292  * @direction: stream to mute
 293  *
 294  * Mutes the DAI DAC.
 295  */
 296 int snd_soc_dai_digital_mute(struct snd_soc_dai *dai, int mute,
 297                              int direction)
 298 {
 299         int ret = -ENOTSUPP;
 300
 301         if (dai->driver->ops &&
 302             dai->driver->ops->mute_stream)
 303                 ret = dai->driver->ops->mute_stream(dai, mute, direction);
 304         else if (direction == SNDRV_PCM_STREAM_PLAYBACK &&
 305                  dai->driver->ops &&
 306                  dai->driver->ops->digital_mute)
 307                 ret = dai->driver->ops->digital_mute(dai, mute);
 308
 309         return soc_dai_ret(dai, ret);
 310 }
 311 EXPORT_SYMBOL_GPL(snd_soc_dai_digital_mute);
 312
 313 int snd_soc_dai_hw_params(struct snd_soc_dai *dai,
 314                           struct snd_pcm_substream *substream,
 315                           struct snd_pcm_hw_params *params)
 316 {
 317         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 318         int ret = 0;
 319
 320         /* perform any topology hw_params fixups before DAI  */
 321         ret = snd_soc_link_be_hw_params_fixup(rtd, params);
 322         if (ret < 0)
 323                 goto end;
 324
 325         if (dai->driver->ops &&
 326             dai->driver->ops->hw_params)
 327                 ret = dai->driver->ops->hw_params(substream, params, dai);
 328 end:
 329         return soc_dai_ret(dai, ret);
 330 }
 331
 332 void snd_soc_dai_hw_free(struct snd_soc_dai *dai,
 333                          struct snd_pcm_substream *substream)
 334 {
 335         if (dai->driver->ops &&
 336             dai->driver->ops->hw_free)
 337                 dai->driver->ops->hw_free(substream, dai);
 338 }
 339
 340 int snd_soc_dai_startup(struct snd_soc_dai *dai,
 341                         struct snd_pcm_substream *substream)
 342 {
 343         int ret = 0;
 344
 345         if (dai->driver->ops &&
 346             dai->driver->ops->startup)
 347                 ret = dai->driver->ops->startup(substream, dai);
 348
 349         return soc_dai_ret(dai, ret);
 350 }
 351
 352 void snd_soc_dai_shutdown(struct snd_soc_dai *dai,
 353                          struct snd_pcm_substream *substream)
 354 {
 355         if (dai->driver->ops &&
 356             dai->driver->ops->shutdown)
 357                 dai->driver->ops->shutdown(substream, dai);
 358 }
 359
 360 snd_pcm_sframes_t snd_soc_dai_delay(struct snd_soc_dai *dai,
 361                                     struct snd_pcm_substream *substream)
 362 {
 363         int delay = 0;
 364
 365         if (dai->driver->ops &&
 366             dai->driver->ops->delay)
 367                 delay = dai->driver->ops->delay(substream, dai);
 368
 369         return delay;
 370 }
 371
 372 int snd_soc_dai_compress_new(struct snd_soc_dai *dai,
 373                              struct snd_soc_pcm_runtime *rtd, int num)
 374 {
 375         int ret = -ENOTSUPP;
 376         if (dai->driver->compress_new)
 377                 ret = dai->driver->compress_new(rtd, num);
 378         return soc_dai_ret(dai, ret);
 379 }
 380
 381 /*
 382  * snd_soc_dai_stream_valid() - check if a DAI supports the given stream
 383  *
 384  * Returns true if the DAI supports the indicated stream type.
 385  */
 386 bool snd_soc_dai_stream_valid(struct snd_soc_dai *dai, int dir)
 387 {
 388         struct snd_soc_pcm_stream *stream = snd_soc_dai_get_pcm_stream(dai, dir);
 389
 390         /* If the codec specifies any channels at all, it supports the stream */
 391         return stream->channels_min;
 392 }
 393
 394 /*
 395  * snd_soc_dai_link_set_capabilities() - set dai_link properties based on its DAIs
 396  */
 397 void snd_soc_dai_link_set_capabilities(struct snd_soc_dai_link *dai_link)
 398 {
 399         struct snd_soc_dai_link_component *cpu;
 400         struct snd_soc_dai_link_component *codec;
 401         struct snd_soc_dai *dai;
 402         bool supported[SNDRV_PCM_STREAM_LAST + 1];
 403         int direction;
 404         int i;
 405
 406         for_each_pcm_streams(direction) {
 407                 supported[direction] = true;
 408
 409                 for_each_link_cpus(dai_link, i, cpu) {
 410                         dai = snd_soc_find_dai(cpu);
 411                         if (!dai || !snd_soc_dai_stream_valid(dai, direction)) {
 412                                 supported[direction] = false;
 413                                 break;
 414                         }
 415                 }
 416                 if (!supported[direction])
 417                         continue;
 418                 for_each_link_codecs(dai_link, i, codec) {
 419                         dai = snd_soc_find_dai(codec);
 420                         if (!dai || !snd_soc_dai_stream_valid(dai, direction)) {
 421                                 supported[direction] = false;
 422                                 break;
 423                         }
 424                 }
 425         }
 426
 427         dai_link->dpcm_playback = supported[SNDRV_PCM_STREAM_PLAYBACK];
 428         dai_link->dpcm_capture  = supported[SNDRV_PCM_STREAM_CAPTURE];
 429 }
 430 EXPORT_SYMBOL_GPL(snd_soc_dai_link_set_capabilities);
 431
 432 void snd_soc_dai_action(struct snd_soc_dai *dai,
 433                         int stream, int action)
 434 {
 435         /* see snd_soc_dai_stream_active() */
 436         dai->stream_active[stream]      += action;
 437
 438         /* see snd_soc_component_active() */
 439         dai->component->active          += action;
 440 }
 441 EXPORT_SYMBOL_GPL(snd_soc_dai_action);
 442
 443 int snd_soc_dai_active(struct snd_soc_dai *dai)
 444 {
 445         int stream, active;
 446
 447         active = 0;
 448         for_each_pcm_streams(stream)
 449                 active += dai->stream_active[stream];
 450
 451         return active;
 452 }
 453 EXPORT_SYMBOL_GPL(snd_soc_dai_active);
 454
 455 int snd_soc_pcm_dai_probe(struct snd_soc_pcm_runtime *rtd, int order)
 456 {
 457         struct snd_soc_dai *dai;
 458         int i;
 459
 460         for_each_rtd_dais(rtd, i, dai) {
 461                 if (dai->driver->probe_order != order)
 462                         continue;
 463
 464                 if (dai->driver->probe) {
 465                         int ret = dai->driver->probe(dai);
 466
 467                         if (ret < 0)
 468                                 return soc_dai_ret(dai, ret);
 469                 }
 470
 471                 dai->probed = 1;
 472         }
 473
 474         return 0;
 475 }
 476
 477 int snd_soc_pcm_dai_remove(struct snd_soc_pcm_runtime *rtd, int order)
 478 {
 479         struct snd_soc_dai *dai;
 480         int i, r, ret = 0;
 481
 482         for_each_rtd_dais(rtd, i, dai) {
 483                 if (dai->driver->remove_order != order)
 484                         continue;
 485
 486                 if (dai->probed &&
 487                     dai->driver->remove) {
 488                         r = dai->driver->remove(dai);
 489                         if (r < 0)
 490                                 ret = r; /* use last error */
 491                 }
 492
 493                 dai->probed = 0;
 494         }
 495
 496         return ret;
 497 }
 498
 499 int snd_soc_pcm_dai_new(struct snd_soc_pcm_runtime *rtd)
 500 {
 501         struct snd_soc_dai *dai;
 502         int i, ret = 0;
 503
 504         for_each_rtd_dais(rtd, i, dai) {
 505                 if (dai->driver->pcm_new) {
 506                         ret = dai->driver->pcm_new(rtd, dai);
 507                         if (ret < 0)
 508                                 return soc_dai_ret(dai, ret);
 509                 }
 510         }
 511
 512         return 0;
 513 }
 514
 515 int snd_soc_pcm_dai_prepare(struct snd_pcm_substream *substream)
 516 {
 517         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 518         struct snd_soc_dai *dai;
 519         int i, ret;
 520
 521         for_each_rtd_dais(rtd, i, dai) {
 522                 if (dai->driver->ops &&
 523                     dai->driver->ops->prepare) {
 524                         ret = dai->driver->ops->prepare(substream, dai);
 525                         if (ret < 0)
 526                                 return soc_dai_ret(dai, ret);
 527                 }
 528         }
 529
 530         return 0;
 531 }
 532
 533 int snd_soc_pcm_dai_trigger(struct snd_pcm_substream *substream,
 534                             int cmd)
 535 {
 536         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 537         struct snd_soc_dai *dai;
 538         int i, ret;
 539
 540         for_each_rtd_dais(rtd, i, dai) {
 541                 if (dai->driver->ops &&
 542                     dai->driver->ops->trigger) {
 543                         ret = dai->driver->ops->trigger(substream, cmd, dai);
 544                         if (ret < 0)
 545                                 return soc_dai_ret(dai, ret);
 546                 }
 547         }
 548
 549         return 0;
 550 }
 551
 552 int snd_soc_pcm_dai_bespoke_trigger(struct snd_pcm_substream *substream,
 553                                     int cmd)
 554 {
 555         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 556         struct snd_soc_dai *dai;
 557         int i, ret;
 558
 559         for_each_rtd_dais(rtd, i, dai) {
 560                 if (dai->driver->ops &&
 561                     dai->driver->ops->bespoke_trigger) {
 562                         ret = dai->driver->ops->bespoke_trigger(substream,
 563                                                                 cmd, dai);
 564                         if (ret < 0)
 565                                 return soc_dai_ret(dai, ret);
 566                 }
 567         }
 568
 569         return 0;
 570 }
 571
 572 int snd_soc_dai_compr_startup(struct snd_soc_dai *dai,
 573                               struct snd_compr_stream *cstream)
 574 {
 575         int ret = 0;
 576
 577         if (dai->driver->cops &&
 578             dai->driver->cops->startup)
 579                 ret = dai->driver->cops->startup(cstream, dai);
 580
 581         return soc_dai_ret(dai, ret);
 582 }
 583 EXPORT_SYMBOL_GPL(snd_soc_dai_compr_startup);
 584
 585 void snd_soc_dai_compr_shutdown(struct snd_soc_dai *dai,
 586                                 struct snd_compr_stream *cstream)
 587 {
 588         if (dai->driver->cops &&
 589             dai->driver->cops->shutdown)
 590                 dai->driver->cops->shutdown(cstream, dai);
 591 }
 592 EXPORT_SYMBOL_GPL(snd_soc_dai_compr_shutdown);
 593
 594 int snd_soc_dai_compr_trigger(struct snd_soc_dai *dai,
 595                               struct snd_compr_stream *cstream, int cmd)
 596 {
 597         int ret = 0;
 598
 599         if (dai->driver->cops &&
 600             dai->driver->cops->trigger)
 601                 ret = dai->driver->cops->trigger(cstream, cmd, dai);
 602
 603         return soc_dai_ret(dai, ret);
 604 }
 605 EXPORT_SYMBOL_GPL(snd_soc_dai_compr_trigger);
 606
 607 int snd_soc_dai_compr_set_params(struct snd_soc_dai *dai,
 608                                  struct snd_compr_stream *cstream,
 609                                  struct snd_compr_params *params)
 610 {
 611         int ret = 0;
 612
 613         if (dai->driver->cops &&
 614             dai->driver->cops->set_params)
 615                 ret = dai->driver->cops->set_params(cstream, params, dai);
 616
 617         return soc_dai_ret(dai, ret);
 618 }
 619 EXPORT_SYMBOL_GPL(snd_soc_dai_compr_set_params);
 620
 621 int snd_soc_dai_compr_get_params(struct snd_soc_dai *dai,
 622                                  struct snd_compr_stream *cstream,
 623                                  struct snd_codec *params)
 624 {
 625         int ret = 0;
 626
 627         if (dai->driver->cops &&
 628             dai->driver->cops->get_params)
 629                 ret = dai->driver->cops->get_params(cstream, params, dai);
 630
 631         return soc_dai_ret(dai, ret);
 632 }
 633 EXPORT_SYMBOL_GPL(snd_soc_dai_compr_get_params);
 634
 635 int snd_soc_dai_compr_ack(struct snd_soc_dai *dai,
 636                           struct snd_compr_stream *cstream,
 637                           size_t bytes)
 638 {
 639         int ret = 0;
 640
 641         if (dai->driver->cops &&
 642             dai->driver->cops->ack)
 643                 ret = dai->driver->cops->ack(cstream, bytes, dai);
 644
 645         return soc_dai_ret(dai, ret);
 646 }
 647 EXPORT_SYMBOL_GPL(snd_soc_dai_compr_ack);
 648
 649 int snd_soc_dai_compr_pointer(struct snd_soc_dai *dai,
 650                               struct snd_compr_stream *cstream,
 651                               struct snd_compr_tstamp *tstamp)
 652 {
 653         int ret = 0;
 654
 655         if (dai->driver->cops &&
 656             dai->driver->cops->pointer)
 657                 ret = dai->driver->cops->pointer(cstream, tstamp, dai);
 658
 659         return soc_dai_ret(dai, ret);
 660 }
 661 EXPORT_SYMBOL_GPL(snd_soc_dai_compr_pointer);
 662
 663 int snd_soc_dai_compr_set_metadata(struct snd_soc_dai *dai,
 664                                    struct snd_compr_stream *cstream,
 665                                    struct snd_compr_metadata *metadata)
 666 {
 667         int ret = 0;
 668
 669         if (dai->driver->cops &&
 670             dai->driver->cops->set_metadata)
 671                 ret = dai->driver->cops->set_metadata(cstream, metadata, dai);
 672
 673         return soc_dai_ret(dai, ret);
 674 }
 675 EXPORT_SYMBOL_GPL(snd_soc_dai_compr_set_metadata);
 676
 677 int snd_soc_dai_compr_get_metadata(struct snd_soc_dai *dai,
 678                                    struct snd_compr_stream *cstream,
 679                                    struct snd_compr_metadata *metadata)
 680 {
 681         int ret = 0;
 682
 683         if (dai->driver->cops &&
 684             dai->driver->cops->get_metadata)
 685                 ret = dai->driver->cops->get_metadata(cstream, metadata, dai);
 686
 687         return soc_dai_ret(dai, ret);
 688 }
 689 EXPORT_SYMBOL_GPL(snd_soc_dai_compr_get_metadata);