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)
_soc_dai_ret(struct snd_soc_dai * dai,const char * func,int 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 */
snd_soc_dai_set_sysclk(struct snd_soc_dai * dai,int clk_id,unsigned int freq,int dir)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 */
snd_soc_dai_set_clkdiv(struct snd_soc_dai * dai,int div_id,int div)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 */
snd_soc_dai_set_pll(struct snd_soc_dai * dai,int pll_id,int source,unsigned int freq_in,unsigned int freq_out)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 */
snd_soc_dai_set_bclk_ratio(struct snd_soc_dai * dai,unsigned int ratio)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 */
snd_soc_dai_set_fmt(struct snd_soc_dai * dai,unsigned int fmt)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_mask - 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 */
snd_soc_xlate_tdm_slot_mask(unsigned int slots,unsigned int * tx_mask,unsigned int * rx_mask)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 */
snd_soc_dai_set_tdm_slot(struct snd_soc_dai * dai,unsigned int tx_mask,unsigned int rx_mask,int slots,int slot_width)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 */
snd_soc_dai_set_channel_map(struct snd_soc_dai * dai,unsigned int tx_num,unsigned int * tx_slot,unsigned int rx_num,unsigned int * rx_slot)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 */
snd_soc_dai_get_channel_map(struct snd_soc_dai * dai,unsigned int * tx_num,unsigned int * tx_slot,unsigned int * rx_num,unsigned int * rx_slot)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 */
snd_soc_dai_set_tristate(struct snd_soc_dai * dai,int tristate)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 */
snd_soc_dai_digital_mute(struct snd_soc_dai * dai,int mute,int direction)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
snd_soc_dai_hw_params(struct snd_soc_dai * dai,struct snd_pcm_substream * substream,struct snd_pcm_hw_params * params)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
snd_soc_dai_hw_free(struct snd_soc_dai * dai,struct snd_pcm_substream * substream,int rollback)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
snd_soc_dai_startup(struct snd_soc_dai * dai,struct snd_pcm_substream * substream)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
snd_soc_dai_shutdown(struct snd_soc_dai * dai,struct snd_pcm_substream * substream,int rollback)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
snd_soc_dai_delay(struct snd_soc_dai * dai,struct snd_pcm_substream * substream)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
snd_soc_dai_compress_new(struct snd_soc_dai * dai,struct snd_soc_pcm_runtime * rtd,int num)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 */
snd_soc_dai_stream_valid(struct snd_soc_dai * dai,int dir)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 */
snd_soc_dai_link_set_capabilities(struct snd_soc_dai_link * dai_link)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
snd_soc_dai_action(struct snd_soc_dai * dai,int stream,int action)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
snd_soc_dai_active(struct snd_soc_dai * dai)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
snd_soc_pcm_dai_probe(struct snd_soc_pcm_runtime * rtd,int order)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
snd_soc_pcm_dai_remove(struct snd_soc_pcm_runtime * rtd,int order)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
snd_soc_pcm_dai_new(struct snd_soc_pcm_runtime * rtd)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
snd_soc_pcm_dai_prepare(struct snd_pcm_substream * substream)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
soc_dai_trigger(struct snd_soc_dai * dai,struct snd_pcm_substream * substream,int cmd)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
snd_soc_pcm_dai_trigger(struct snd_pcm_substream * substream,int cmd,int rollback)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
snd_soc_pcm_dai_bespoke_trigger(struct snd_pcm_substream * substream,int cmd)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
snd_soc_dai_compr_startup(struct snd_soc_dai * dai,struct snd_compr_stream * cstream)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
snd_soc_dai_compr_shutdown(struct snd_soc_dai * dai,struct snd_compr_stream * cstream,int rollback)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
snd_soc_dai_compr_trigger(struct snd_soc_dai * dai,struct snd_compr_stream * cstream,int cmd)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
snd_soc_dai_compr_set_params(struct snd_soc_dai * dai,struct snd_compr_stream * cstream,struct snd_compr_params * params)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
snd_soc_dai_compr_get_params(struct snd_soc_dai * dai,struct snd_compr_stream * cstream,struct snd_codec * params)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
snd_soc_dai_compr_ack(struct snd_soc_dai * dai,struct snd_compr_stream * cstream,size_t bytes)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
snd_soc_dai_compr_pointer(struct snd_soc_dai * dai,struct snd_compr_stream * cstream,struct snd_compr_tstamp * tstamp)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
snd_soc_dai_compr_set_metadata(struct snd_soc_dai * dai,struct snd_compr_stream * cstream,struct snd_compr_metadata * metadata)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
snd_soc_dai_compr_get_metadata(struct snd_soc_dai * dai,struct snd_compr_stream * cstream,struct snd_compr_metadata * metadata)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);
763