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