1
2
3
4
5
6
7
8
9
10
11
12
13#include <linux/kernel.h>
14#include <linux/init.h>
15#include <linux/delay.h>
16#include <linux/pinctrl/consumer.h>
17#include <linux/pm_runtime.h>
18#include <linux/slab.h>
19#include <linux/workqueue.h>
20#include <linux/export.h>
21#include <linux/debugfs.h>
22#include <sound/core.h>
23#include <sound/pcm.h>
24#include <sound/pcm_params.h>
25#include <sound/soc.h>
26#include <sound/soc-dpcm.h>
27#include <sound/soc-link.h>
28#include <sound/initval.h>
29
30#define DPCM_MAX_BE_USERS 8
31
32static inline const char *soc_cpu_dai_name(struct snd_soc_pcm_runtime *rtd)
33{
34 return (rtd)->num_cpus == 1 ? asoc_rtd_to_cpu(rtd, 0)->name : "multicpu";
35}
36static inline const char *soc_codec_dai_name(struct snd_soc_pcm_runtime *rtd)
37{
38 return (rtd)->num_codecs == 1 ? asoc_rtd_to_codec(rtd, 0)->name : "multicodec";
39}
40
41#ifdef CONFIG_DEBUG_FS
42static const char *dpcm_state_string(enum snd_soc_dpcm_state state)
43{
44 switch (state) {
45 case SND_SOC_DPCM_STATE_NEW:
46 return "new";
47 case SND_SOC_DPCM_STATE_OPEN:
48 return "open";
49 case SND_SOC_DPCM_STATE_HW_PARAMS:
50 return "hw_params";
51 case SND_SOC_DPCM_STATE_PREPARE:
52 return "prepare";
53 case SND_SOC_DPCM_STATE_START:
54 return "start";
55 case SND_SOC_DPCM_STATE_STOP:
56 return "stop";
57 case SND_SOC_DPCM_STATE_SUSPEND:
58 return "suspend";
59 case SND_SOC_DPCM_STATE_PAUSED:
60 return "paused";
61 case SND_SOC_DPCM_STATE_HW_FREE:
62 return "hw_free";
63 case SND_SOC_DPCM_STATE_CLOSE:
64 return "close";
65 }
66
67 return "unknown";
68}
69
70static ssize_t dpcm_show_state(struct snd_soc_pcm_runtime *fe,
71 int stream, char *buf, size_t size)
72{
73 struct snd_pcm_hw_params *params = &fe->dpcm[stream].hw_params;
74 struct snd_soc_dpcm *dpcm;
75 ssize_t offset = 0;
76 unsigned long flags;
77
78
79 offset += scnprintf(buf + offset, size - offset,
80 "[%s - %s]\n", fe->dai_link->name,
81 stream ? "Capture" : "Playback");
82
83 offset += scnprintf(buf + offset, size - offset, "State: %s\n",
84 dpcm_state_string(fe->dpcm[stream].state));
85
86 if ((fe->dpcm[stream].state >= SND_SOC_DPCM_STATE_HW_PARAMS) &&
87 (fe->dpcm[stream].state <= SND_SOC_DPCM_STATE_STOP))
88 offset += scnprintf(buf + offset, size - offset,
89 "Hardware Params: "
90 "Format = %s, Channels = %d, Rate = %d\n",
91 snd_pcm_format_name(params_format(params)),
92 params_channels(params),
93 params_rate(params));
94
95
96 offset += scnprintf(buf + offset, size - offset, "Backends:\n");
97
98 if (list_empty(&fe->dpcm[stream].be_clients)) {
99 offset += scnprintf(buf + offset, size - offset,
100 " No active DSP links\n");
101 goto out;
102 }
103
104 spin_lock_irqsave(&fe->card->dpcm_lock, flags);
105 for_each_dpcm_be(fe, stream, dpcm) {
106 struct snd_soc_pcm_runtime *be = dpcm->be;
107 params = &dpcm->hw_params;
108
109 offset += scnprintf(buf + offset, size - offset,
110 "- %s\n", be->dai_link->name);
111
112 offset += scnprintf(buf + offset, size - offset,
113 " State: %s\n",
114 dpcm_state_string(be->dpcm[stream].state));
115
116 if ((be->dpcm[stream].state >= SND_SOC_DPCM_STATE_HW_PARAMS) &&
117 (be->dpcm[stream].state <= SND_SOC_DPCM_STATE_STOP))
118 offset += scnprintf(buf + offset, size - offset,
119 " Hardware Params: "
120 "Format = %s, Channels = %d, Rate = %d\n",
121 snd_pcm_format_name(params_format(params)),
122 params_channels(params),
123 params_rate(params));
124 }
125 spin_unlock_irqrestore(&fe->card->dpcm_lock, flags);
126out:
127 return offset;
128}
129
130static ssize_t dpcm_state_read_file(struct file *file, char __user *user_buf,
131 size_t count, loff_t *ppos)
132{
133 struct snd_soc_pcm_runtime *fe = file->private_data;
134 ssize_t out_count = PAGE_SIZE, offset = 0, ret = 0;
135 int stream;
136 char *buf;
137
138 if (fe->num_cpus > 1) {
139 dev_err(fe->dev,
140 "%s doesn't support Multi CPU yet\n", __func__);
141 return -EINVAL;
142 }
143
144 buf = kmalloc(out_count, GFP_KERNEL);
145 if (!buf)
146 return -ENOMEM;
147
148 for_each_pcm_streams(stream)
149 if (snd_soc_dai_stream_valid(asoc_rtd_to_cpu(fe, 0), stream))
150 offset += dpcm_show_state(fe, stream,
151 buf + offset,
152 out_count - offset);
153
154 ret = simple_read_from_buffer(user_buf, count, ppos, buf, offset);
155
156 kfree(buf);
157 return ret;
158}
159
160static const struct file_operations dpcm_state_fops = {
161 .open = simple_open,
162 .read = dpcm_state_read_file,
163 .llseek = default_llseek,
164};
165
166void soc_dpcm_debugfs_add(struct snd_soc_pcm_runtime *rtd)
167{
168 if (!rtd->dai_link->dynamic)
169 return;
170
171 if (!rtd->card->debugfs_card_root)
172 return;
173
174 rtd->debugfs_dpcm_root = debugfs_create_dir(rtd->dai_link->name,
175 rtd->card->debugfs_card_root);
176
177 debugfs_create_file("state", 0444, rtd->debugfs_dpcm_root,
178 rtd, &dpcm_state_fops);
179}
180
181static void dpcm_create_debugfs_state(struct snd_soc_dpcm *dpcm, int stream)
182{
183 char *name;
184
185 name = kasprintf(GFP_KERNEL, "%s:%s", dpcm->be->dai_link->name,
186 stream ? "capture" : "playback");
187 if (name) {
188 dpcm->debugfs_state = debugfs_create_dir(
189 name, dpcm->fe->debugfs_dpcm_root);
190 debugfs_create_u32("state", 0644, dpcm->debugfs_state,
191 &dpcm->state);
192 kfree(name);
193 }
194}
195
196static void dpcm_remove_debugfs_state(struct snd_soc_dpcm *dpcm)
197{
198 debugfs_remove_recursive(dpcm->debugfs_state);
199}
200
201#else
202static inline void dpcm_create_debugfs_state(struct snd_soc_dpcm *dpcm,
203 int stream)
204{
205}
206
207static inline void dpcm_remove_debugfs_state(struct snd_soc_dpcm *dpcm)
208{
209}
210#endif
211
212
213
214
215
216
217static int dpcm_fe_dai_do_trigger(struct snd_pcm_substream *substream, int cmd);
218static void dpcm_set_fe_update_state(struct snd_soc_pcm_runtime *fe,
219 int stream, enum snd_soc_dpcm_update state)
220{
221 struct snd_pcm_substream *substream =
222 snd_soc_dpcm_get_substream(fe, stream);
223
224 snd_pcm_stream_lock_irq(substream);
225 if (state == SND_SOC_DPCM_UPDATE_NO && fe->dpcm[stream].trigger_pending) {
226 dpcm_fe_dai_do_trigger(substream,
227 fe->dpcm[stream].trigger_pending - 1);
228 fe->dpcm[stream].trigger_pending = 0;
229 }
230 fe->dpcm[stream].runtime_update = state;
231 snd_pcm_stream_unlock_irq(substream);
232}
233
234static void dpcm_set_be_update_state(struct snd_soc_pcm_runtime *be,
235 int stream, enum snd_soc_dpcm_update state)
236{
237 be->dpcm[stream].runtime_update = state;
238}
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253void snd_soc_runtime_action(struct snd_soc_pcm_runtime *rtd,
254 int stream, int action)
255{
256 struct snd_soc_dai *dai;
257 int i;
258
259 lockdep_assert_held(&rtd->card->pcm_mutex);
260
261 for_each_rtd_dais(rtd, i, dai)
262 snd_soc_dai_action(dai, stream, action);
263}
264EXPORT_SYMBOL_GPL(snd_soc_runtime_action);
265
266
267
268
269
270
271
272
273
274
275bool snd_soc_runtime_ignore_pmdown_time(struct snd_soc_pcm_runtime *rtd)
276{
277 struct snd_soc_component *component;
278 bool ignore = true;
279 int i;
280
281 if (!rtd->pmdown_time || rtd->dai_link->ignore_pmdown_time)
282 return true;
283
284 for_each_rtd_components(rtd, i, component)
285 ignore &= !component->driver->use_pmdown_time;
286
287 return ignore;
288}
289
290
291
292
293
294
295
296
297int snd_soc_set_runtime_hwparams(struct snd_pcm_substream *substream,
298 const struct snd_pcm_hardware *hw)
299{
300 substream->runtime->hw = *hw;
301
302 return 0;
303}
304EXPORT_SYMBOL_GPL(snd_soc_set_runtime_hwparams);
305
306
307int dpcm_dapm_stream_event(struct snd_soc_pcm_runtime *fe, int dir,
308 int event)
309{
310 struct snd_soc_dpcm *dpcm;
311
312 for_each_dpcm_be(fe, dir, dpcm) {
313
314 struct snd_soc_pcm_runtime *be = dpcm->be;
315
316 dev_dbg(be->dev, "ASoC: BE %s event %d dir %d\n",
317 be->dai_link->name, event, dir);
318
319 if ((event == SND_SOC_DAPM_STREAM_STOP) &&
320 (be->dpcm[dir].users >= 1))
321 continue;
322
323 snd_soc_dapm_stream_event(be, dir, event);
324 }
325
326 snd_soc_dapm_stream_event(fe, dir, event);
327
328 return 0;
329}
330
331static void soc_pcm_set_dai_params(struct snd_soc_dai *dai,
332 struct snd_pcm_hw_params *params)
333{
334 if (params) {
335 dai->rate = params_rate(params);
336 dai->channels = params_channels(params);
337 dai->sample_bits = snd_pcm_format_physical_width(params_format(params));
338 } else {
339 dai->rate = 0;
340 dai->channels = 0;
341 dai->sample_bits = 0;
342 }
343}
344
345static int soc_pcm_apply_symmetry(struct snd_pcm_substream *substream,
346 struct snd_soc_dai *soc_dai)
347{
348 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
349 int ret;
350
351 if (!snd_soc_dai_active(soc_dai))
352 return 0;
353
354#define __soc_pcm_apply_symmetry(name, NAME) \
355 if (soc_dai->name && (soc_dai->driver->symmetric_##name || \
356 rtd->dai_link->symmetric_##name)) { \
357 dev_dbg(soc_dai->dev, "ASoC: Symmetry forces %s to %d\n",\
358 #name, soc_dai->name); \
359 \
360 ret = snd_pcm_hw_constraint_single(substream->runtime, \
361 SNDRV_PCM_HW_PARAM_##NAME,\
362 soc_dai->name); \
363 if (ret < 0) { \
364 dev_err(soc_dai->dev, \
365 "ASoC: Unable to apply %s constraint: %d\n",\
366 #name, ret); \
367 return ret; \
368 } \
369 }
370
371 __soc_pcm_apply_symmetry(rate, RATE);
372 __soc_pcm_apply_symmetry(channels, CHANNELS);
373 __soc_pcm_apply_symmetry(sample_bits, SAMPLE_BITS);
374
375 return 0;
376}
377
378static int soc_pcm_params_symmetry(struct snd_pcm_substream *substream,
379 struct snd_pcm_hw_params *params)
380{
381 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
382 struct snd_soc_dai d;
383 struct snd_soc_dai *dai;
384 struct snd_soc_dai *cpu_dai;
385 unsigned int symmetry, i;
386
387 d.name = __func__;
388 soc_pcm_set_dai_params(&d, params);
389
390#define __soc_pcm_params_symmetry(xxx) \
391 symmetry = rtd->dai_link->symmetric_##xxx; \
392 for_each_rtd_dais(rtd, i, dai) \
393 symmetry |= dai->driver->symmetric_##xxx; \
394 \
395 if (symmetry) \
396 for_each_rtd_cpu_dais(rtd, i, cpu_dai) \
397 if (!snd_soc_dai_is_dummy(cpu_dai) && \
398 cpu_dai->xxx && cpu_dai->xxx != d.xxx) { \
399 dev_err(rtd->dev, "ASoC: unmatched %s symmetry: %s:%d - %s:%d\n", \
400 #xxx, cpu_dai->name, cpu_dai->xxx, d.name, d.xxx); \
401 return -EINVAL; \
402 }
403
404
405 __soc_pcm_params_symmetry(rate);
406 __soc_pcm_params_symmetry(channels);
407 __soc_pcm_params_symmetry(sample_bits);
408
409 return 0;
410}
411
412static void soc_pcm_update_symmetry(struct snd_pcm_substream *substream)
413{
414 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
415 struct snd_soc_dai_link *link = rtd->dai_link;
416 struct snd_soc_dai *dai;
417 unsigned int symmetry, i;
418
419 symmetry = link->symmetric_rate ||
420 link->symmetric_channels ||
421 link->symmetric_sample_bits;
422
423 for_each_rtd_dais(rtd, i, dai)
424 symmetry = symmetry ||
425 dai->driver->symmetric_rate ||
426 dai->driver->symmetric_channels ||
427 dai->driver->symmetric_sample_bits;
428
429 if (symmetry)
430 substream->runtime->hw.info |= SNDRV_PCM_INFO_JOINT_DUPLEX;
431}
432
433static void soc_pcm_set_msb(struct snd_pcm_substream *substream, int bits)
434{
435 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
436 int ret;
437
438 if (!bits)
439 return;
440
441 ret = snd_pcm_hw_constraint_msbits(substream->runtime, 0, 0, bits);
442 if (ret != 0)
443 dev_warn(rtd->dev, "ASoC: Failed to set MSB %d: %d\n",
444 bits, ret);
445}
446
447static void soc_pcm_apply_msb(struct snd_pcm_substream *substream)
448{
449 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
450 struct snd_soc_dai *cpu_dai;
451 struct snd_soc_dai *codec_dai;
452 int stream = substream->stream;
453 int i;
454 unsigned int bits = 0, cpu_bits = 0;
455
456 for_each_rtd_codec_dais(rtd, i, codec_dai) {
457 struct snd_soc_pcm_stream *pcm_codec = snd_soc_dai_get_pcm_stream(codec_dai, stream);
458
459 if (pcm_codec->sig_bits == 0) {
460 bits = 0;
461 break;
462 }
463 bits = max(pcm_codec->sig_bits, bits);
464 }
465
466 for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
467 struct snd_soc_pcm_stream *pcm_cpu = snd_soc_dai_get_pcm_stream(cpu_dai, stream);
468
469 if (pcm_cpu->sig_bits == 0) {
470 cpu_bits = 0;
471 break;
472 }
473 cpu_bits = max(pcm_cpu->sig_bits, cpu_bits);
474 }
475
476 soc_pcm_set_msb(substream, bits);
477 soc_pcm_set_msb(substream, cpu_bits);
478}
479
480static void soc_pcm_hw_init(struct snd_pcm_hardware *hw)
481{
482 hw->rates = UINT_MAX;
483 hw->rate_min = 0;
484 hw->rate_max = UINT_MAX;
485 hw->channels_min = 0;
486 hw->channels_max = UINT_MAX;
487 hw->formats = ULLONG_MAX;
488}
489
490static void soc_pcm_hw_update_rate(struct snd_pcm_hardware *hw,
491 struct snd_soc_pcm_stream *p)
492{
493 hw->rates = snd_pcm_rate_mask_intersect(hw->rates, p->rates);
494
495
496 snd_pcm_hw_limit_rates(hw);
497
498
499 hw->rate_min = max(hw->rate_min, p->rate_min);
500 hw->rate_max = min_not_zero(hw->rate_max, p->rate_max);
501}
502
503static void soc_pcm_hw_update_chan(struct snd_pcm_hardware *hw,
504 struct snd_soc_pcm_stream *p)
505{
506 hw->channels_min = max(hw->channels_min, p->channels_min);
507 hw->channels_max = min(hw->channels_max, p->channels_max);
508}
509
510static void soc_pcm_hw_update_format(struct snd_pcm_hardware *hw,
511 struct snd_soc_pcm_stream *p)
512{
513 hw->formats &= p->formats;
514}
515
516
517
518
519
520
521
522
523
524
525int snd_soc_runtime_calc_hw(struct snd_soc_pcm_runtime *rtd,
526 struct snd_pcm_hardware *hw, int stream)
527{
528 struct snd_soc_dai *codec_dai;
529 struct snd_soc_dai *cpu_dai;
530 struct snd_soc_pcm_stream *codec_stream;
531 struct snd_soc_pcm_stream *cpu_stream;
532 unsigned int cpu_chan_min = 0, cpu_chan_max = UINT_MAX;
533 int i;
534
535 soc_pcm_hw_init(hw);
536
537
538 for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
539
540
541
542
543
544
545
546 if (!snd_soc_dai_stream_valid(cpu_dai, stream))
547 continue;
548
549 cpu_stream = snd_soc_dai_get_pcm_stream(cpu_dai, stream);
550
551 soc_pcm_hw_update_chan(hw, cpu_stream);
552 soc_pcm_hw_update_rate(hw, cpu_stream);
553 soc_pcm_hw_update_format(hw, cpu_stream);
554 }
555 cpu_chan_min = hw->channels_min;
556 cpu_chan_max = hw->channels_max;
557
558
559 for_each_rtd_codec_dais(rtd, i, codec_dai) {
560
561
562
563
564
565
566
567 if (!snd_soc_dai_stream_valid(codec_dai, stream))
568 continue;
569
570 codec_stream = snd_soc_dai_get_pcm_stream(codec_dai, stream);
571
572 soc_pcm_hw_update_chan(hw, codec_stream);
573 soc_pcm_hw_update_rate(hw, codec_stream);
574 soc_pcm_hw_update_format(hw, codec_stream);
575 }
576
577
578 if (!hw->channels_min)
579 return -EINVAL;
580
581
582
583
584
585
586 if (rtd->num_codecs > 1) {
587 hw->channels_min = cpu_chan_min;
588 hw->channels_max = cpu_chan_max;
589 }
590
591 return 0;
592}
593EXPORT_SYMBOL_GPL(snd_soc_runtime_calc_hw);
594
595static void soc_pcm_init_runtime_hw(struct snd_pcm_substream *substream)
596{
597 struct snd_pcm_hardware *hw = &substream->runtime->hw;
598 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
599 u64 formats = hw->formats;
600
601
602
603
604
605
606 snd_soc_runtime_calc_hw(rtd, hw, substream->stream);
607
608 if (formats)
609 hw->formats &= formats;
610}
611
612static int soc_pcm_components_open(struct snd_pcm_substream *substream)
613{
614 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
615 struct snd_soc_component *component;
616 int i, ret = 0;
617
618 for_each_rtd_components(rtd, i, component) {
619 ret = snd_soc_component_module_get_when_open(component, substream);
620 if (ret < 0)
621 break;
622
623 ret = snd_soc_component_open(component, substream);
624 if (ret < 0)
625 break;
626 }
627
628 return ret;
629}
630
631static int soc_pcm_components_close(struct snd_pcm_substream *substream,
632 int rollback)
633{
634 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
635 struct snd_soc_component *component;
636 int i, ret = 0;
637
638 for_each_rtd_components(rtd, i, component) {
639 int r = snd_soc_component_close(component, substream, rollback);
640 if (r < 0)
641 ret = r;
642
643 snd_soc_component_module_put_when_close(component, substream, rollback);
644 }
645
646 return ret;
647}
648
649static int soc_pcm_clean(struct snd_pcm_substream *substream, int rollback)
650{
651 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
652 struct snd_soc_component *component;
653 struct snd_soc_dai *dai;
654 int i;
655
656 mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass);
657
658 if (!rollback)
659 snd_soc_runtime_deactivate(rtd, substream->stream);
660
661 for_each_rtd_dais(rtd, i, dai)
662 snd_soc_dai_shutdown(dai, substream, rollback);
663
664 snd_soc_link_shutdown(substream, rollback);
665
666 soc_pcm_components_close(substream, rollback);
667
668
669 mutex_unlock(&rtd->card->pcm_mutex);
670
671 snd_soc_pcm_component_pm_runtime_put(rtd, substream, rollback);
672
673 for_each_rtd_components(rtd, i, component)
674 if (!snd_soc_component_active(component))
675 pinctrl_pm_select_sleep_state(component->dev);
676
677 return 0;
678}
679
680
681
682
683
684
685static int soc_pcm_close(struct snd_pcm_substream *substream)
686{
687 return soc_pcm_clean(substream, 0);
688}
689
690static int soc_hw_sanity_check(struct snd_pcm_substream *substream)
691{
692 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
693 struct snd_pcm_hardware *hw = &substream->runtime->hw;
694 const char *name_cpu = soc_cpu_dai_name(rtd);
695 const char *name_codec = soc_codec_dai_name(rtd);
696 const char *err_msg;
697 struct device *dev = rtd->dev;
698
699 err_msg = "rates";
700 if (!hw->rates)
701 goto config_err;
702
703 err_msg = "formats";
704 if (!hw->formats)
705 goto config_err;
706
707 err_msg = "channels";
708 if (!hw->channels_min || !hw->channels_max ||
709 hw->channels_min > hw->channels_max)
710 goto config_err;
711
712 dev_dbg(dev, "ASoC: %s <-> %s info:\n", name_codec,
713 name_cpu);
714 dev_dbg(dev, "ASoC: rate mask 0x%x\n", hw->rates);
715 dev_dbg(dev, "ASoC: ch min %d max %d\n", hw->channels_min,
716 hw->channels_max);
717 dev_dbg(dev, "ASoC: rate min %d max %d\n", hw->rate_min,
718 hw->rate_max);
719
720 return 0;
721
722config_err:
723 dev_err(dev, "ASoC: %s <-> %s No matching %s\n",
724 name_codec, name_cpu, err_msg);
725 return -EINVAL;
726}
727
728
729
730
731
732
733static int soc_pcm_open(struct snd_pcm_substream *substream)
734{
735 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
736 struct snd_soc_component *component;
737 struct snd_soc_dai *dai;
738 int i, ret = 0;
739
740 for_each_rtd_components(rtd, i, component)
741 pinctrl_pm_select_default_state(component->dev);
742
743 ret = snd_soc_pcm_component_pm_runtime_get(rtd, substream);
744 if (ret < 0)
745 goto pm_err;
746
747 mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass);
748
749 ret = soc_pcm_components_open(substream);
750 if (ret < 0)
751 goto err;
752
753 ret = snd_soc_link_startup(substream);
754 if (ret < 0)
755 goto err;
756
757
758 for_each_rtd_dais(rtd, i, dai) {
759 ret = snd_soc_dai_startup(dai, substream);
760 if (ret < 0)
761 goto err;
762
763 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
764 dai->tx_mask = 0;
765 else
766 dai->rx_mask = 0;
767 }
768
769
770 if (rtd->dai_link->dynamic || rtd->dai_link->no_pcm)
771 goto dynamic;
772
773
774 soc_pcm_init_runtime_hw(substream);
775
776 soc_pcm_update_symmetry(substream);
777
778 ret = soc_hw_sanity_check(substream);
779 if (ret < 0)
780 goto err;
781
782 soc_pcm_apply_msb(substream);
783
784
785 for_each_rtd_dais(rtd, i, dai) {
786 ret = soc_pcm_apply_symmetry(substream, dai);
787 if (ret != 0)
788 goto err;
789 }
790dynamic:
791 snd_soc_runtime_activate(rtd, substream->stream);
792 ret = 0;
793err:
794 mutex_unlock(&rtd->card->pcm_mutex);
795pm_err:
796 if (ret < 0) {
797 soc_pcm_clean(substream, 1);
798 dev_err(rtd->dev, "%s() failed (%d)", __func__, ret);
799 }
800
801 return ret;
802}
803
804static void codec2codec_close_delayed_work(struct snd_soc_pcm_runtime *rtd)
805{
806
807
808
809
810
811
812}
813
814
815
816
817
818
819static int soc_pcm_prepare(struct snd_pcm_substream *substream)
820{
821 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
822 struct snd_soc_dai *dai;
823 int i, ret = 0;
824
825 mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass);
826
827 ret = snd_soc_link_prepare(substream);
828 if (ret < 0)
829 goto out;
830
831 ret = snd_soc_pcm_component_prepare(substream);
832 if (ret < 0)
833 goto out;
834
835 ret = snd_soc_pcm_dai_prepare(substream);
836 if (ret < 0)
837 goto out;
838
839
840 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
841 rtd->pop_wait) {
842 rtd->pop_wait = 0;
843 cancel_delayed_work(&rtd->delayed_work);
844 }
845
846 snd_soc_dapm_stream_event(rtd, substream->stream,
847 SND_SOC_DAPM_STREAM_START);
848
849 for_each_rtd_dais(rtd, i, dai)
850 snd_soc_dai_digital_mute(dai, 0, substream->stream);
851
852out:
853 mutex_unlock(&rtd->card->pcm_mutex);
854
855 if (ret < 0)
856 dev_err(rtd->dev, "ASoC: %s() failed (%d)\n", __func__, ret);
857
858 return ret;
859}
860
861static void soc_pcm_codec_params_fixup(struct snd_pcm_hw_params *params,
862 unsigned int mask)
863{
864 struct snd_interval *interval;
865 int channels = hweight_long(mask);
866
867 interval = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
868 interval->min = channels;
869 interval->max = channels;
870}
871
872static int soc_pcm_hw_clean(struct snd_pcm_substream *substream, int rollback)
873{
874 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
875 struct snd_soc_dai *dai;
876 int i;
877
878 mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass);
879
880
881 for_each_rtd_dais(rtd, i, dai) {
882 if (snd_soc_dai_active(dai) == 1)
883 soc_pcm_set_dai_params(dai, NULL);
884
885 if (snd_soc_dai_stream_active(dai, substream->stream) == 1)
886 snd_soc_dai_digital_mute(dai, 1, substream->stream);
887 }
888
889
890 snd_soc_dapm_stream_stop(rtd, substream->stream);
891
892
893 snd_soc_link_hw_free(substream, rollback);
894
895
896 snd_soc_pcm_component_hw_free(substream, rollback);
897
898
899 for_each_rtd_dais(rtd, i, dai)
900 if (snd_soc_dai_stream_valid(dai, substream->stream))
901 snd_soc_dai_hw_free(dai, substream, rollback);
902
903 mutex_unlock(&rtd->card->pcm_mutex);
904 return 0;
905}
906
907
908
909
910static int soc_pcm_hw_free(struct snd_pcm_substream *substream)
911{
912 return soc_pcm_hw_clean(substream, 0);
913}
914
915
916
917
918
919
920static int soc_pcm_hw_params(struct snd_pcm_substream *substream,
921 struct snd_pcm_hw_params *params)
922{
923 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
924 struct snd_soc_dai *cpu_dai;
925 struct snd_soc_dai *codec_dai;
926 int i, ret = 0;
927
928 mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass);
929
930 ret = soc_pcm_params_symmetry(substream, params);
931 if (ret)
932 goto out;
933
934 ret = snd_soc_link_hw_params(substream, params);
935 if (ret < 0)
936 goto out;
937
938 for_each_rtd_codec_dais(rtd, i, codec_dai) {
939 struct snd_pcm_hw_params codec_params;
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955 if (!snd_soc_dai_stream_valid(codec_dai, substream->stream))
956 continue;
957
958
959 codec_params = *params;
960
961
962 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
963 codec_dai->tx_mask)
964 soc_pcm_codec_params_fixup(&codec_params,
965 codec_dai->tx_mask);
966
967 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE &&
968 codec_dai->rx_mask)
969 soc_pcm_codec_params_fixup(&codec_params,
970 codec_dai->rx_mask);
971
972 ret = snd_soc_dai_hw_params(codec_dai, substream,
973 &codec_params);
974 if(ret < 0)
975 goto out;
976
977 soc_pcm_set_dai_params(codec_dai, &codec_params);
978 snd_soc_dapm_update_dai(substream, &codec_params, codec_dai);
979 }
980
981 for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
982
983
984
985
986 if (!snd_soc_dai_stream_valid(cpu_dai, substream->stream))
987 continue;
988
989 ret = snd_soc_dai_hw_params(cpu_dai, substream, params);
990 if (ret < 0)
991 goto out;
992
993
994 soc_pcm_set_dai_params(cpu_dai, params);
995 snd_soc_dapm_update_dai(substream, params, cpu_dai);
996 }
997
998 ret = snd_soc_pcm_component_hw_params(substream, params);
999out:
1000 mutex_unlock(&rtd->card->pcm_mutex);
1001
1002 if (ret < 0) {
1003 soc_pcm_hw_clean(substream, 1);
1004 dev_err(rtd->dev, "ASoC: %s() failed (%d)\n", __func__, ret);
1005 }
1006
1007 return ret;
1008}
1009
1010static int soc_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
1011{
1012 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
1013 int ret = -EINVAL, _ret = 0;
1014 int rollback = 0;
1015
1016 switch (cmd) {
1017 case SNDRV_PCM_TRIGGER_START:
1018 case SNDRV_PCM_TRIGGER_RESUME:
1019 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
1020 ret = snd_soc_link_trigger(substream, cmd, 0);
1021 if (ret < 0)
1022 goto start_err;
1023
1024 ret = snd_soc_pcm_component_trigger(substream, cmd, 0);
1025 if (ret < 0)
1026 goto start_err;
1027
1028 ret = snd_soc_pcm_dai_trigger(substream, cmd, 0);
1029start_err:
1030 if (ret < 0)
1031 rollback = 1;
1032 }
1033
1034 if (rollback) {
1035 _ret = ret;
1036 switch (cmd) {
1037 case SNDRV_PCM_TRIGGER_START:
1038 cmd = SNDRV_PCM_TRIGGER_STOP;
1039 break;
1040 case SNDRV_PCM_TRIGGER_RESUME:
1041 cmd = SNDRV_PCM_TRIGGER_SUSPEND;
1042 break;
1043 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
1044 cmd = SNDRV_PCM_TRIGGER_PAUSE_PUSH;
1045 break;
1046 }
1047 }
1048
1049 switch (cmd) {
1050 case SNDRV_PCM_TRIGGER_STOP:
1051 case SNDRV_PCM_TRIGGER_SUSPEND:
1052 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
1053 if (rtd->dai_link->stop_dma_first) {
1054 ret = snd_soc_pcm_component_trigger(substream, cmd, rollback);
1055 if (ret < 0)
1056 break;
1057
1058 ret = snd_soc_pcm_dai_trigger(substream, cmd, rollback);
1059 if (ret < 0)
1060 break;
1061 } else {
1062 ret = snd_soc_pcm_dai_trigger(substream, cmd, rollback);
1063 if (ret < 0)
1064 break;
1065
1066 ret = snd_soc_pcm_component_trigger(substream, cmd, rollback);
1067 if (ret < 0)
1068 break;
1069 }
1070 ret = snd_soc_link_trigger(substream, cmd, rollback);
1071 break;
1072 }
1073
1074 if (_ret)
1075 ret = _ret;
1076
1077 return ret;
1078}
1079
1080
1081
1082
1083
1084
1085static snd_pcm_uframes_t soc_pcm_pointer(struct snd_pcm_substream *substream)
1086{
1087 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
1088 struct snd_soc_dai *cpu_dai;
1089 struct snd_soc_dai *codec_dai;
1090 struct snd_pcm_runtime *runtime = substream->runtime;
1091 snd_pcm_uframes_t offset = 0;
1092 snd_pcm_sframes_t delay = 0;
1093 snd_pcm_sframes_t codec_delay = 0;
1094 snd_pcm_sframes_t cpu_delay = 0;
1095 int i;
1096
1097
1098 runtime->delay = 0;
1099
1100 offset = snd_soc_pcm_component_pointer(substream);
1101
1102
1103 delay = runtime->delay;
1104
1105 for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
1106 cpu_delay = max(cpu_delay,
1107 snd_soc_dai_delay(cpu_dai, substream));
1108 }
1109 delay += cpu_delay;
1110
1111 for_each_rtd_codec_dais(rtd, i, codec_dai) {
1112 codec_delay = max(codec_delay,
1113 snd_soc_dai_delay(codec_dai, substream));
1114 }
1115 delay += codec_delay;
1116
1117 runtime->delay = delay;
1118
1119 return offset;
1120}
1121
1122
1123static int dpcm_be_connect(struct snd_soc_pcm_runtime *fe,
1124 struct snd_soc_pcm_runtime *be, int stream)
1125{
1126 struct snd_soc_dpcm *dpcm;
1127 unsigned long flags;
1128
1129
1130 for_each_dpcm_be(fe, stream, dpcm) {
1131 if (dpcm->be == be && dpcm->fe == fe)
1132 return 0;
1133 }
1134
1135 dpcm = kzalloc(sizeof(struct snd_soc_dpcm), GFP_KERNEL);
1136 if (!dpcm)
1137 return -ENOMEM;
1138
1139 dpcm->be = be;
1140 dpcm->fe = fe;
1141 be->dpcm[stream].runtime = fe->dpcm[stream].runtime;
1142 dpcm->state = SND_SOC_DPCM_LINK_STATE_NEW;
1143 spin_lock_irqsave(&fe->card->dpcm_lock, flags);
1144 list_add(&dpcm->list_be, &fe->dpcm[stream].be_clients);
1145 list_add(&dpcm->list_fe, &be->dpcm[stream].fe_clients);
1146 spin_unlock_irqrestore(&fe->card->dpcm_lock, flags);
1147
1148 dev_dbg(fe->dev, "connected new DPCM %s path %s %s %s\n",
1149 stream ? "capture" : "playback", fe->dai_link->name,
1150 stream ? "<-" : "->", be->dai_link->name);
1151
1152 dpcm_create_debugfs_state(dpcm, stream);
1153
1154 return 1;
1155}
1156
1157
1158static void dpcm_be_reparent(struct snd_soc_pcm_runtime *fe,
1159 struct snd_soc_pcm_runtime *be, int stream)
1160{
1161 struct snd_soc_dpcm *dpcm;
1162 struct snd_pcm_substream *fe_substream, *be_substream;
1163
1164
1165 if (!be->dpcm[stream].users)
1166 return;
1167
1168 be_substream = snd_soc_dpcm_get_substream(be, stream);
1169
1170 for_each_dpcm_fe(be, stream, dpcm) {
1171 if (dpcm->fe == fe)
1172 continue;
1173
1174 dev_dbg(fe->dev, "reparent %s path %s %s %s\n",
1175 stream ? "capture" : "playback",
1176 dpcm->fe->dai_link->name,
1177 stream ? "<-" : "->", dpcm->be->dai_link->name);
1178
1179 fe_substream = snd_soc_dpcm_get_substream(dpcm->fe, stream);
1180 be_substream->runtime = fe_substream->runtime;
1181 break;
1182 }
1183}
1184
1185
1186void dpcm_be_disconnect(struct snd_soc_pcm_runtime *fe, int stream)
1187{
1188 struct snd_soc_dpcm *dpcm, *d;
1189 unsigned long flags;
1190
1191 for_each_dpcm_be_safe(fe, stream, dpcm, d) {
1192 dev_dbg(fe->dev, "ASoC: BE %s disconnect check for %s\n",
1193 stream ? "capture" : "playback",
1194 dpcm->be->dai_link->name);
1195
1196 if (dpcm->state != SND_SOC_DPCM_LINK_STATE_FREE)
1197 continue;
1198
1199 dev_dbg(fe->dev, "freed DSP %s path %s %s %s\n",
1200 stream ? "capture" : "playback", fe->dai_link->name,
1201 stream ? "<-" : "->", dpcm->be->dai_link->name);
1202
1203
1204 dpcm_be_reparent(fe, dpcm->be, stream);
1205
1206 dpcm_remove_debugfs_state(dpcm);
1207
1208 spin_lock_irqsave(&fe->card->dpcm_lock, flags);
1209 list_del(&dpcm->list_be);
1210 list_del(&dpcm->list_fe);
1211 spin_unlock_irqrestore(&fe->card->dpcm_lock, flags);
1212 kfree(dpcm);
1213 }
1214}
1215
1216
1217static struct snd_soc_pcm_runtime *dpcm_get_be(struct snd_soc_card *card,
1218 struct snd_soc_dapm_widget *widget, int stream)
1219{
1220 struct snd_soc_pcm_runtime *be;
1221 struct snd_soc_dapm_widget *w;
1222 struct snd_soc_dai *dai;
1223 int i;
1224
1225 dev_dbg(card->dev, "ASoC: find BE for widget %s\n", widget->name);
1226
1227 for_each_card_rtds(card, be) {
1228
1229 if (!be->dai_link->no_pcm)
1230 continue;
1231
1232 for_each_rtd_dais(be, i, dai) {
1233 w = snd_soc_dai_get_widget(dai, stream);
1234
1235 dev_dbg(card->dev, "ASoC: try BE : %s\n",
1236 w ? w->name : "(not set)");
1237
1238 if (w == widget)
1239 return be;
1240 }
1241 }
1242
1243
1244 return NULL;
1245}
1246
1247static int widget_in_list(struct snd_soc_dapm_widget_list *list,
1248 struct snd_soc_dapm_widget *widget)
1249{
1250 struct snd_soc_dapm_widget *w;
1251 int i;
1252
1253 for_each_dapm_widgets(list, i, w)
1254 if (widget == w)
1255 return 1;
1256
1257 return 0;
1258}
1259
1260bool dpcm_end_walk_at_be(struct snd_soc_dapm_widget *widget, enum snd_soc_dapm_direction dir)
1261{
1262 struct snd_soc_card *card = widget->dapm->card;
1263 struct snd_soc_pcm_runtime *rtd;
1264 int stream;
1265
1266
1267 if (dir == SND_SOC_DAPM_DIR_OUT)
1268 stream = SNDRV_PCM_STREAM_PLAYBACK;
1269 else
1270 stream = SNDRV_PCM_STREAM_CAPTURE;
1271
1272 rtd = dpcm_get_be(card, widget, stream);
1273 if (rtd)
1274 return true;
1275
1276 return false;
1277}
1278EXPORT_SYMBOL_GPL(dpcm_end_walk_at_be);
1279
1280int dpcm_path_get(struct snd_soc_pcm_runtime *fe,
1281 int stream, struct snd_soc_dapm_widget_list **list)
1282{
1283 struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(fe, 0);
1284 int paths;
1285
1286 if (fe->num_cpus > 1) {
1287 dev_err(fe->dev,
1288 "%s doesn't support Multi CPU yet\n", __func__);
1289 return -EINVAL;
1290 }
1291
1292
1293 paths = snd_soc_dapm_dai_get_connected_widgets(cpu_dai, stream, list,
1294 fe->card->component_chaining ?
1295 NULL : dpcm_end_walk_at_be);
1296
1297 if (paths > 0)
1298 dev_dbg(fe->dev, "ASoC: found %d audio %s paths\n", paths,
1299 stream ? "capture" : "playback");
1300 else if (paths == 0)
1301 dev_dbg(fe->dev, "ASoC: %s no valid %s path\n", fe->dai_link->name,
1302 stream ? "capture" : "playback");
1303
1304 return paths;
1305}
1306
1307void dpcm_path_put(struct snd_soc_dapm_widget_list **list)
1308{
1309 snd_soc_dapm_dai_free_widgets(list);
1310}
1311
1312static bool dpcm_be_is_active(struct snd_soc_dpcm *dpcm, int stream,
1313 struct snd_soc_dapm_widget_list *list)
1314{
1315 struct snd_soc_dai *dai;
1316 unsigned int i;
1317
1318
1319 for_each_rtd_dais(dpcm->be, i, dai) {
1320 struct snd_soc_dapm_widget *widget = snd_soc_dai_get_widget(dai, stream);
1321
1322
1323
1324
1325
1326 if (widget && widget_in_list(list, widget))
1327 return true;
1328 }
1329
1330 return false;
1331}
1332
1333static int dpcm_prune_paths(struct snd_soc_pcm_runtime *fe, int stream,
1334 struct snd_soc_dapm_widget_list **list_)
1335{
1336 struct snd_soc_dpcm *dpcm;
1337 int prune = 0;
1338
1339
1340 for_each_dpcm_be(fe, stream, dpcm) {
1341 if (dpcm_be_is_active(dpcm, stream, *list_))
1342 continue;
1343
1344 dev_dbg(fe->dev, "ASoC: pruning %s BE %s for %s\n",
1345 stream ? "capture" : "playback",
1346 dpcm->be->dai_link->name, fe->dai_link->name);
1347 dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE;
1348 dpcm_set_be_update_state(dpcm->be, stream, SND_SOC_DPCM_UPDATE_BE);
1349 prune++;
1350 }
1351
1352 dev_dbg(fe->dev, "ASoC: found %d old BE paths for pruning\n", prune);
1353 return prune;
1354}
1355
1356static int dpcm_add_paths(struct snd_soc_pcm_runtime *fe, int stream,
1357 struct snd_soc_dapm_widget_list **list_)
1358{
1359 struct snd_soc_card *card = fe->card;
1360 struct snd_soc_dapm_widget_list *list = *list_;
1361 struct snd_soc_pcm_runtime *be;
1362 struct snd_soc_dapm_widget *widget;
1363 int i, new = 0, err;
1364
1365
1366 for_each_dapm_widgets(list, i, widget) {
1367
1368 switch (widget->id) {
1369 case snd_soc_dapm_dai_in:
1370 if (stream != SNDRV_PCM_STREAM_PLAYBACK)
1371 continue;
1372 break;
1373 case snd_soc_dapm_dai_out:
1374 if (stream != SNDRV_PCM_STREAM_CAPTURE)
1375 continue;
1376 break;
1377 default:
1378 continue;
1379 }
1380
1381
1382 be = dpcm_get_be(card, widget, stream);
1383 if (!be) {
1384 dev_dbg(fe->dev, "ASoC: no BE found for %s\n",
1385 widget->name);
1386 continue;
1387 }
1388
1389
1390 if (!fe->dpcm[stream].runtime && !fe->fe_compr)
1391 continue;
1392
1393
1394
1395
1396
1397
1398 if (fe->card->component_chaining &&
1399 (be->dpcm[stream].state != SND_SOC_DPCM_STATE_NEW) &&
1400 (be->dpcm[stream].state != SND_SOC_DPCM_STATE_CLOSE))
1401 continue;
1402
1403
1404 err = dpcm_be_connect(fe, be, stream);
1405 if (err < 0) {
1406 dev_err(fe->dev, "ASoC: can't connect %s\n",
1407 widget->name);
1408 break;
1409 } else if (err == 0)
1410 continue;
1411
1412
1413 dpcm_set_be_update_state(be, stream, SND_SOC_DPCM_UPDATE_BE);
1414 new++;
1415 }
1416
1417 dev_dbg(fe->dev, "ASoC: found %d new BE paths\n", new);
1418 return new;
1419}
1420
1421
1422
1423
1424
1425int dpcm_process_paths(struct snd_soc_pcm_runtime *fe,
1426 int stream, struct snd_soc_dapm_widget_list **list, int new)
1427{
1428 if (new)
1429 return dpcm_add_paths(fe, stream, list);
1430 else
1431 return dpcm_prune_paths(fe, stream, list);
1432}
1433
1434void dpcm_clear_pending_state(struct snd_soc_pcm_runtime *fe, int stream)
1435{
1436 struct snd_soc_dpcm *dpcm;
1437 unsigned long flags;
1438
1439 spin_lock_irqsave(&fe->card->dpcm_lock, flags);
1440 for_each_dpcm_be(fe, stream, dpcm)
1441 dpcm_set_be_update_state(dpcm->be, stream, SND_SOC_DPCM_UPDATE_NO);
1442 spin_unlock_irqrestore(&fe->card->dpcm_lock, flags);
1443}
1444
1445void dpcm_be_dai_stop(struct snd_soc_pcm_runtime *fe, int stream,
1446 int do_hw_free, struct snd_soc_dpcm *last)
1447{
1448 struct snd_soc_dpcm *dpcm;
1449
1450
1451 for_each_dpcm_be(fe, stream, dpcm) {
1452 struct snd_soc_pcm_runtime *be = dpcm->be;
1453 struct snd_pcm_substream *be_substream =
1454 snd_soc_dpcm_get_substream(be, stream);
1455
1456 if (dpcm == last)
1457 return;
1458
1459
1460 if (!snd_soc_dpcm_be_can_update(fe, be, stream))
1461 continue;
1462
1463 if (be->dpcm[stream].users == 0) {
1464 dev_err(be->dev, "ASoC: no users %s at close - state %d\n",
1465 stream ? "capture" : "playback",
1466 be->dpcm[stream].state);
1467 continue;
1468 }
1469
1470 if (--be->dpcm[stream].users != 0)
1471 continue;
1472
1473 if (be->dpcm[stream].state != SND_SOC_DPCM_STATE_OPEN) {
1474 if (!do_hw_free)
1475 continue;
1476
1477 if (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_FREE) {
1478 soc_pcm_hw_free(be_substream);
1479 be->dpcm[stream].state = SND_SOC_DPCM_STATE_HW_FREE;
1480 }
1481 }
1482
1483 soc_pcm_close(be_substream);
1484 be_substream->runtime = NULL;
1485 be->dpcm[stream].state = SND_SOC_DPCM_STATE_CLOSE;
1486 }
1487}
1488
1489int dpcm_be_dai_startup(struct snd_soc_pcm_runtime *fe, int stream)
1490{
1491 struct snd_soc_pcm_runtime *be;
1492 struct snd_soc_dpcm *dpcm;
1493 int err, count = 0;
1494
1495
1496 for_each_dpcm_be(fe, stream, dpcm) {
1497 struct snd_pcm_substream *be_substream;
1498
1499 be = dpcm->be;
1500 be_substream = snd_soc_dpcm_get_substream(be, stream);
1501
1502 if (!be_substream) {
1503 dev_err(be->dev, "ASoC: no backend %s stream\n",
1504 stream ? "capture" : "playback");
1505 continue;
1506 }
1507
1508
1509 if (!snd_soc_dpcm_be_can_update(fe, be, stream))
1510 continue;
1511
1512
1513 if (be->dpcm[stream].users == DPCM_MAX_BE_USERS) {
1514 dev_err(be->dev, "ASoC: too many users %s at open %d\n",
1515 stream ? "capture" : "playback",
1516 be->dpcm[stream].state);
1517 continue;
1518 }
1519
1520 if (be->dpcm[stream].users++ != 0)
1521 continue;
1522
1523 if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_NEW) &&
1524 (be->dpcm[stream].state != SND_SOC_DPCM_STATE_CLOSE))
1525 continue;
1526
1527 dev_dbg(be->dev, "ASoC: open %s BE %s\n",
1528 stream ? "capture" : "playback", be->dai_link->name);
1529
1530 be_substream->runtime = be->dpcm[stream].runtime;
1531 err = soc_pcm_open(be_substream);
1532 if (err < 0) {
1533 be->dpcm[stream].users--;
1534 if (be->dpcm[stream].users < 0)
1535 dev_err(be->dev, "ASoC: no users %s at unwind %d\n",
1536 stream ? "capture" : "playback",
1537 be->dpcm[stream].state);
1538
1539 be->dpcm[stream].state = SND_SOC_DPCM_STATE_CLOSE;
1540 goto unwind;
1541 }
1542
1543 be->dpcm[stream].state = SND_SOC_DPCM_STATE_OPEN;
1544 count++;
1545 }
1546
1547 return count;
1548
1549unwind:
1550 dpcm_be_dai_startup_rollback(fe, stream, dpcm);
1551
1552 dev_err(fe->dev, "ASoC: %s() failed at %s (%d)\n",
1553 __func__, be->dai_link->name, err);
1554
1555 return err;
1556}
1557
1558static void dpcm_runtime_setup_fe(struct snd_pcm_substream *substream)
1559{
1560 struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(substream);
1561 struct snd_pcm_runtime *runtime = substream->runtime;
1562 struct snd_pcm_hardware *hw = &runtime->hw;
1563 struct snd_soc_dai *dai;
1564 int stream = substream->stream;
1565 int i;
1566
1567 soc_pcm_hw_init(hw);
1568
1569 for_each_rtd_cpu_dais(fe, i, dai) {
1570 struct snd_soc_pcm_stream *cpu_stream;
1571
1572
1573
1574
1575
1576 if (!snd_soc_dai_stream_valid(dai, stream))
1577 continue;
1578
1579 cpu_stream = snd_soc_dai_get_pcm_stream(dai, stream);
1580
1581 soc_pcm_hw_update_rate(hw, cpu_stream);
1582 soc_pcm_hw_update_chan(hw, cpu_stream);
1583 soc_pcm_hw_update_format(hw, cpu_stream);
1584 }
1585
1586}
1587
1588static void dpcm_runtime_setup_be_format(struct snd_pcm_substream *substream)
1589{
1590 struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(substream);
1591 struct snd_pcm_runtime *runtime = substream->runtime;
1592 struct snd_pcm_hardware *hw = &runtime->hw;
1593 struct snd_soc_dpcm *dpcm;
1594 struct snd_soc_dai *dai;
1595 int stream = substream->stream;
1596
1597 if (!fe->dai_link->dpcm_merged_format)
1598 return;
1599
1600
1601
1602
1603
1604
1605 for_each_dpcm_be(fe, stream, dpcm) {
1606 struct snd_soc_pcm_runtime *be = dpcm->be;
1607 struct snd_soc_pcm_stream *codec_stream;
1608 int i;
1609
1610 for_each_rtd_codec_dais(be, i, dai) {
1611
1612
1613
1614
1615 if (!snd_soc_dai_stream_valid(dai, stream))
1616 continue;
1617
1618 codec_stream = snd_soc_dai_get_pcm_stream(dai, stream);
1619
1620 soc_pcm_hw_update_format(hw, codec_stream);
1621 }
1622 }
1623}
1624
1625static void dpcm_runtime_setup_be_chan(struct snd_pcm_substream *substream)
1626{
1627 struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(substream);
1628 struct snd_pcm_runtime *runtime = substream->runtime;
1629 struct snd_pcm_hardware *hw = &runtime->hw;
1630 struct snd_soc_dpcm *dpcm;
1631 int stream = substream->stream;
1632
1633 if (!fe->dai_link->dpcm_merged_chan)
1634 return;
1635
1636
1637
1638
1639
1640
1641 for_each_dpcm_be(fe, stream, dpcm) {
1642 struct snd_soc_pcm_runtime *be = dpcm->be;
1643 struct snd_soc_pcm_stream *cpu_stream;
1644 struct snd_soc_dai *dai;
1645 int i;
1646
1647 for_each_rtd_cpu_dais(be, i, dai) {
1648
1649
1650
1651
1652 if (!snd_soc_dai_stream_valid(dai, stream))
1653 continue;
1654
1655 cpu_stream = snd_soc_dai_get_pcm_stream(dai, stream);
1656
1657 soc_pcm_hw_update_chan(hw, cpu_stream);
1658 }
1659
1660
1661
1662
1663
1664 if (be->num_codecs == 1) {
1665 struct snd_soc_pcm_stream *codec_stream = snd_soc_dai_get_pcm_stream(
1666 asoc_rtd_to_codec(be, 0), stream);
1667
1668 soc_pcm_hw_update_chan(hw, codec_stream);
1669 }
1670 }
1671}
1672
1673static void dpcm_runtime_setup_be_rate(struct snd_pcm_substream *substream)
1674{
1675 struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(substream);
1676 struct snd_pcm_runtime *runtime = substream->runtime;
1677 struct snd_pcm_hardware *hw = &runtime->hw;
1678 struct snd_soc_dpcm *dpcm;
1679 int stream = substream->stream;
1680
1681 if (!fe->dai_link->dpcm_merged_rate)
1682 return;
1683
1684
1685
1686
1687
1688
1689 for_each_dpcm_be(fe, stream, dpcm) {
1690 struct snd_soc_pcm_runtime *be = dpcm->be;
1691 struct snd_soc_pcm_stream *pcm;
1692 struct snd_soc_dai *dai;
1693 int i;
1694
1695 for_each_rtd_dais(be, i, dai) {
1696
1697
1698
1699
1700 if (!snd_soc_dai_stream_valid(dai, stream))
1701 continue;
1702
1703 pcm = snd_soc_dai_get_pcm_stream(dai, stream);
1704
1705 soc_pcm_hw_update_rate(hw, pcm);
1706 }
1707 }
1708}
1709
1710static int dpcm_apply_symmetry(struct snd_pcm_substream *fe_substream,
1711 int stream)
1712{
1713 struct snd_soc_dpcm *dpcm;
1714 struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(fe_substream);
1715 struct snd_soc_dai *fe_cpu_dai;
1716 int err = 0;
1717 int i;
1718
1719
1720 soc_pcm_update_symmetry(fe_substream);
1721
1722 for_each_rtd_cpu_dais (fe, i, fe_cpu_dai) {
1723
1724 err = soc_pcm_apply_symmetry(fe_substream, fe_cpu_dai);
1725 if (err < 0)
1726 goto error;
1727 }
1728
1729
1730 for_each_dpcm_be(fe, stream, dpcm) {
1731 struct snd_soc_pcm_runtime *be = dpcm->be;
1732 struct snd_pcm_substream *be_substream =
1733 snd_soc_dpcm_get_substream(be, stream);
1734 struct snd_soc_pcm_runtime *rtd;
1735 struct snd_soc_dai *dai;
1736
1737
1738 if (!be_substream)
1739 continue;
1740
1741 rtd = asoc_substream_to_rtd(be_substream);
1742 if (rtd->dai_link->be_hw_params_fixup)
1743 continue;
1744
1745 soc_pcm_update_symmetry(be_substream);
1746
1747
1748 for_each_rtd_dais(rtd, i, dai) {
1749 err = soc_pcm_apply_symmetry(fe_substream, dai);
1750 if (err < 0)
1751 goto error;
1752 }
1753 }
1754error:
1755 if (err < 0)
1756 dev_err(fe->dev, "ASoC: %s failed (%d)\n", __func__, err);
1757
1758 return err;
1759}
1760
1761static int dpcm_fe_dai_startup(struct snd_pcm_substream *fe_substream)
1762{
1763 struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(fe_substream);
1764 int stream = fe_substream->stream, ret = 0;
1765
1766 dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_FE);
1767
1768 ret = dpcm_be_dai_startup(fe, stream);
1769 if (ret < 0)
1770 goto be_err;
1771
1772 dev_dbg(fe->dev, "ASoC: open FE %s\n", fe->dai_link->name);
1773
1774
1775 ret = soc_pcm_open(fe_substream);
1776 if (ret < 0)
1777 goto unwind;
1778
1779 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_OPEN;
1780
1781 dpcm_runtime_setup_fe(fe_substream);
1782
1783 dpcm_runtime_setup_be_format(fe_substream);
1784 dpcm_runtime_setup_be_chan(fe_substream);
1785 dpcm_runtime_setup_be_rate(fe_substream);
1786
1787 ret = dpcm_apply_symmetry(fe_substream, stream);
1788
1789unwind:
1790 if (ret < 0)
1791 dpcm_be_dai_startup_unwind(fe, stream);
1792be_err:
1793 dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_NO);
1794
1795 if (ret < 0)
1796 dev_err(fe->dev, "%s() failed (%d)\n", __func__, ret);
1797
1798 return ret;
1799}
1800
1801static int dpcm_fe_dai_shutdown(struct snd_pcm_substream *substream)
1802{
1803 struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(substream);
1804 int stream = substream->stream;
1805
1806 dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_FE);
1807
1808
1809 dpcm_be_dai_shutdown(fe, stream);
1810
1811 dev_dbg(fe->dev, "ASoC: close FE %s\n", fe->dai_link->name);
1812
1813
1814 soc_pcm_close(substream);
1815
1816
1817 dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_STOP);
1818
1819 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_CLOSE;
1820 dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_NO);
1821 return 0;
1822}
1823
1824void dpcm_be_dai_hw_free(struct snd_soc_pcm_runtime *fe, int stream)
1825{
1826 struct snd_soc_dpcm *dpcm;
1827
1828
1829
1830 for_each_dpcm_be(fe, stream, dpcm) {
1831
1832 struct snd_soc_pcm_runtime *be = dpcm->be;
1833 struct snd_pcm_substream *be_substream =
1834 snd_soc_dpcm_get_substream(be, stream);
1835
1836
1837 if (!snd_soc_dpcm_be_can_update(fe, be, stream))
1838 continue;
1839
1840
1841 if (!snd_soc_dpcm_can_be_free_stop(fe, be, stream))
1842 continue;
1843
1844
1845 if (be->dpcm[stream].users > 1)
1846 continue;
1847
1848 if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_PARAMS) &&
1849 (be->dpcm[stream].state != SND_SOC_DPCM_STATE_PREPARE) &&
1850 (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_FREE) &&
1851 (be->dpcm[stream].state != SND_SOC_DPCM_STATE_PAUSED) &&
1852 (be->dpcm[stream].state != SND_SOC_DPCM_STATE_STOP) &&
1853 (be->dpcm[stream].state != SND_SOC_DPCM_STATE_SUSPEND))
1854 continue;
1855
1856 dev_dbg(be->dev, "ASoC: hw_free BE %s\n",
1857 be->dai_link->name);
1858
1859 soc_pcm_hw_free(be_substream);
1860
1861 be->dpcm[stream].state = SND_SOC_DPCM_STATE_HW_FREE;
1862 }
1863}
1864
1865static int dpcm_fe_dai_hw_free(struct snd_pcm_substream *substream)
1866{
1867 struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(substream);
1868 int stream = substream->stream;
1869
1870 mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
1871 dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_FE);
1872
1873 dev_dbg(fe->dev, "ASoC: hw_free FE %s\n", fe->dai_link->name);
1874
1875
1876 soc_pcm_hw_free(substream);
1877
1878
1879
1880 dpcm_be_dai_hw_free(fe, stream);
1881
1882 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_HW_FREE;
1883 dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_NO);
1884
1885 mutex_unlock(&fe->card->mutex);
1886 return 0;
1887}
1888
1889int dpcm_be_dai_hw_params(struct snd_soc_pcm_runtime *fe, int stream)
1890{
1891 struct snd_soc_pcm_runtime *be;
1892 struct snd_pcm_substream *be_substream;
1893 struct snd_soc_dpcm *dpcm;
1894 int ret;
1895
1896 for_each_dpcm_be(fe, stream, dpcm) {
1897 be = dpcm->be;
1898 be_substream = snd_soc_dpcm_get_substream(be, stream);
1899
1900
1901 if (!snd_soc_dpcm_be_can_update(fe, be, stream))
1902 continue;
1903
1904
1905 memcpy(&dpcm->hw_params, &fe->dpcm[stream].hw_params,
1906 sizeof(struct snd_pcm_hw_params));
1907
1908
1909 ret = snd_soc_link_be_hw_params_fixup(be, &dpcm->hw_params);
1910 if (ret < 0)
1911 goto unwind;
1912
1913
1914 memcpy(&be->dpcm[stream].hw_params, &dpcm->hw_params,
1915 sizeof(struct snd_pcm_hw_params));
1916
1917
1918 if (!snd_soc_dpcm_can_be_params(fe, be, stream))
1919 continue;
1920
1921 if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_OPEN) &&
1922 (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_PARAMS) &&
1923 (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_FREE))
1924 continue;
1925
1926 dev_dbg(be->dev, "ASoC: hw_params BE %s\n",
1927 be->dai_link->name);
1928
1929 ret = soc_pcm_hw_params(be_substream, &dpcm->hw_params);
1930 if (ret < 0)
1931 goto unwind;
1932
1933 be->dpcm[stream].state = SND_SOC_DPCM_STATE_HW_PARAMS;
1934 }
1935 return 0;
1936
1937unwind:
1938 dev_dbg(fe->dev, "ASoC: %s() failed at %s (%d)\n",
1939 __func__, be->dai_link->name, ret);
1940
1941
1942 for_each_dpcm_be_rollback(fe, stream, dpcm) {
1943 be = dpcm->be;
1944 be_substream = snd_soc_dpcm_get_substream(be, stream);
1945
1946 if (!snd_soc_dpcm_be_can_update(fe, be, stream))
1947 continue;
1948
1949
1950 if (!snd_soc_dpcm_can_be_free_stop(fe, be, stream))
1951 continue;
1952
1953 if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_OPEN) &&
1954 (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_PARAMS) &&
1955 (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_FREE) &&
1956 (be->dpcm[stream].state != SND_SOC_DPCM_STATE_STOP))
1957 continue;
1958
1959 soc_pcm_hw_free(be_substream);
1960 }
1961
1962 return ret;
1963}
1964
1965static int dpcm_fe_dai_hw_params(struct snd_pcm_substream *substream,
1966 struct snd_pcm_hw_params *params)
1967{
1968 struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(substream);
1969 int ret, stream = substream->stream;
1970
1971 mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
1972 dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_FE);
1973
1974 memcpy(&fe->dpcm[stream].hw_params, params,
1975 sizeof(struct snd_pcm_hw_params));
1976 ret = dpcm_be_dai_hw_params(fe, stream);
1977 if (ret < 0)
1978 goto out;
1979
1980 dev_dbg(fe->dev, "ASoC: hw_params FE %s rate %d chan %x fmt %d\n",
1981 fe->dai_link->name, params_rate(params),
1982 params_channels(params), params_format(params));
1983
1984
1985 ret = soc_pcm_hw_params(substream, params);
1986 if (ret < 0)
1987 dpcm_be_dai_hw_free(fe, stream);
1988 else
1989 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_HW_PARAMS;
1990
1991out:
1992 dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_NO);
1993 mutex_unlock(&fe->card->mutex);
1994
1995 if (ret < 0)
1996 dev_err(fe->dev, "ASoC: %s failed (%d)\n", __func__, ret);
1997
1998 return ret;
1999}
2000
2001int dpcm_be_dai_trigger(struct snd_soc_pcm_runtime *fe, int stream,
2002 int cmd)
2003{
2004 struct snd_soc_pcm_runtime *be;
2005 struct snd_soc_dpcm *dpcm;
2006 int ret = 0;
2007
2008 for_each_dpcm_be(fe, stream, dpcm) {
2009 struct snd_pcm_substream *be_substream;
2010
2011 be = dpcm->be;
2012 be_substream = snd_soc_dpcm_get_substream(be, stream);
2013
2014
2015 if (!snd_soc_dpcm_be_can_update(fe, be, stream))
2016 continue;
2017
2018 dev_dbg(be->dev, "ASoC: trigger BE %s cmd %d\n",
2019 be->dai_link->name, cmd);
2020
2021 switch (cmd) {
2022 case SNDRV_PCM_TRIGGER_START:
2023 if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_PREPARE) &&
2024 (be->dpcm[stream].state != SND_SOC_DPCM_STATE_STOP) &&
2025 (be->dpcm[stream].state != SND_SOC_DPCM_STATE_PAUSED))
2026 continue;
2027
2028 ret = soc_pcm_trigger(be_substream, cmd);
2029 if (ret)
2030 goto end;
2031
2032 be->dpcm[stream].state = SND_SOC_DPCM_STATE_START;
2033 break;
2034 case SNDRV_PCM_TRIGGER_RESUME:
2035 if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_SUSPEND))
2036 continue;
2037
2038 ret = soc_pcm_trigger(be_substream, cmd);
2039 if (ret)
2040 goto end;
2041
2042 be->dpcm[stream].state = SND_SOC_DPCM_STATE_START;
2043 break;
2044 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
2045 if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_PAUSED))
2046 continue;
2047
2048 ret = soc_pcm_trigger(be_substream, cmd);
2049 if (ret)
2050 goto end;
2051
2052 be->dpcm[stream].state = SND_SOC_DPCM_STATE_START;
2053 break;
2054 case SNDRV_PCM_TRIGGER_STOP:
2055 if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_START) &&
2056 (be->dpcm[stream].state != SND_SOC_DPCM_STATE_PAUSED))
2057 continue;
2058
2059 if (!snd_soc_dpcm_can_be_free_stop(fe, be, stream))
2060 continue;
2061
2062 ret = soc_pcm_trigger(be_substream, cmd);
2063 if (ret)
2064 goto end;
2065
2066 be->dpcm[stream].state = SND_SOC_DPCM_STATE_STOP;
2067 break;
2068 case SNDRV_PCM_TRIGGER_SUSPEND:
2069 if (be->dpcm[stream].state != SND_SOC_DPCM_STATE_START)
2070 continue;
2071
2072 if (!snd_soc_dpcm_can_be_free_stop(fe, be, stream))
2073 continue;
2074
2075 ret = soc_pcm_trigger(be_substream, cmd);
2076 if (ret)
2077 goto end;
2078
2079 be->dpcm[stream].state = SND_SOC_DPCM_STATE_SUSPEND;
2080 break;
2081 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
2082 if (be->dpcm[stream].state != SND_SOC_DPCM_STATE_START)
2083 continue;
2084
2085 if (!snd_soc_dpcm_can_be_free_stop(fe, be, stream))
2086 continue;
2087
2088 ret = soc_pcm_trigger(be_substream, cmd);
2089 if (ret)
2090 goto end;
2091
2092 be->dpcm[stream].state = SND_SOC_DPCM_STATE_PAUSED;
2093 break;
2094 }
2095 }
2096end:
2097 if (ret < 0)
2098 dev_err(fe->dev, "ASoC: %s() failed at %s (%d)\n",
2099 __func__, be->dai_link->name, ret);
2100 return ret;
2101}
2102EXPORT_SYMBOL_GPL(dpcm_be_dai_trigger);
2103
2104static int dpcm_dai_trigger_fe_be(struct snd_pcm_substream *substream,
2105 int cmd, bool fe_first)
2106{
2107 struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(substream);
2108 int ret;
2109
2110
2111 if (fe_first) {
2112 dev_dbg(fe->dev, "ASoC: pre trigger FE %s cmd %d\n",
2113 fe->dai_link->name, cmd);
2114
2115 ret = soc_pcm_trigger(substream, cmd);
2116 if (ret < 0)
2117 return ret;
2118
2119 ret = dpcm_be_dai_trigger(fe, substream->stream, cmd);
2120 return ret;
2121 }
2122
2123
2124 ret = dpcm_be_dai_trigger(fe, substream->stream, cmd);
2125 if (ret < 0)
2126 return ret;
2127
2128 dev_dbg(fe->dev, "ASoC: post trigger FE %s cmd %d\n",
2129 fe->dai_link->name, cmd);
2130
2131 ret = soc_pcm_trigger(substream, cmd);
2132
2133 return ret;
2134}
2135
2136static int dpcm_fe_dai_do_trigger(struct snd_pcm_substream *substream, int cmd)
2137{
2138 struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(substream);
2139 int stream = substream->stream;
2140 int ret = 0;
2141 enum snd_soc_dpcm_trigger trigger = fe->dai_link->trigger[stream];
2142
2143 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
2144
2145 switch (trigger) {
2146 case SND_SOC_DPCM_TRIGGER_PRE:
2147 switch (cmd) {
2148 case SNDRV_PCM_TRIGGER_START:
2149 case SNDRV_PCM_TRIGGER_RESUME:
2150 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
2151 case SNDRV_PCM_TRIGGER_DRAIN:
2152 ret = dpcm_dai_trigger_fe_be(substream, cmd, true);
2153 break;
2154 case SNDRV_PCM_TRIGGER_STOP:
2155 case SNDRV_PCM_TRIGGER_SUSPEND:
2156 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
2157 ret = dpcm_dai_trigger_fe_be(substream, cmd, false);
2158 break;
2159 default:
2160 ret = -EINVAL;
2161 break;
2162 }
2163 break;
2164 case SND_SOC_DPCM_TRIGGER_POST:
2165 switch (cmd) {
2166 case SNDRV_PCM_TRIGGER_START:
2167 case SNDRV_PCM_TRIGGER_RESUME:
2168 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
2169 case SNDRV_PCM_TRIGGER_DRAIN:
2170 ret = dpcm_dai_trigger_fe_be(substream, cmd, false);
2171 break;
2172 case SNDRV_PCM_TRIGGER_STOP:
2173 case SNDRV_PCM_TRIGGER_SUSPEND:
2174 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
2175 ret = dpcm_dai_trigger_fe_be(substream, cmd, true);
2176 break;
2177 default:
2178 ret = -EINVAL;
2179 break;
2180 }
2181 break;
2182 case SND_SOC_DPCM_TRIGGER_BESPOKE:
2183
2184
2185 dev_dbg(fe->dev, "ASoC: bespoke trigger FE %s cmd %d\n",
2186 fe->dai_link->name, cmd);
2187
2188 ret = snd_soc_pcm_dai_bespoke_trigger(substream, cmd);
2189 break;
2190 default:
2191 dev_err(fe->dev, "ASoC: invalid trigger cmd %d for %s\n", cmd,
2192 fe->dai_link->name);
2193 ret = -EINVAL;
2194 goto out;
2195 }
2196
2197 if (ret < 0) {
2198 dev_err(fe->dev, "ASoC: trigger FE cmd: %d failed: %d\n",
2199 cmd, ret);
2200 goto out;
2201 }
2202
2203 switch (cmd) {
2204 case SNDRV_PCM_TRIGGER_START:
2205 case SNDRV_PCM_TRIGGER_RESUME:
2206 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
2207 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_START;
2208 break;
2209 case SNDRV_PCM_TRIGGER_STOP:
2210 case SNDRV_PCM_TRIGGER_SUSPEND:
2211 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_STOP;
2212 break;
2213 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
2214 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_PAUSED;
2215 break;
2216 }
2217
2218out:
2219 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
2220 return ret;
2221}
2222
2223static int dpcm_fe_dai_trigger(struct snd_pcm_substream *substream, int cmd)
2224{
2225 struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(substream);
2226 int stream = substream->stream;
2227
2228
2229
2230
2231 if (fe->dpcm[stream].runtime_update != SND_SOC_DPCM_UPDATE_NO) {
2232 fe->dpcm[stream].trigger_pending = cmd + 1;
2233 return 0;
2234 }
2235
2236
2237 return dpcm_fe_dai_do_trigger(substream, cmd);
2238}
2239
2240int dpcm_be_dai_prepare(struct snd_soc_pcm_runtime *fe, int stream)
2241{
2242 struct snd_soc_dpcm *dpcm;
2243 int ret = 0;
2244
2245 for_each_dpcm_be(fe, stream, dpcm) {
2246
2247 struct snd_soc_pcm_runtime *be = dpcm->be;
2248 struct snd_pcm_substream *be_substream =
2249 snd_soc_dpcm_get_substream(be, stream);
2250
2251
2252 if (!snd_soc_dpcm_be_can_update(fe, be, stream))
2253 continue;
2254
2255 if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_PARAMS) &&
2256 (be->dpcm[stream].state != SND_SOC_DPCM_STATE_STOP) &&
2257 (be->dpcm[stream].state != SND_SOC_DPCM_STATE_SUSPEND) &&
2258 (be->dpcm[stream].state != SND_SOC_DPCM_STATE_PAUSED))
2259 continue;
2260
2261 dev_dbg(be->dev, "ASoC: prepare BE %s\n",
2262 be->dai_link->name);
2263
2264 ret = soc_pcm_prepare(be_substream);
2265 if (ret < 0)
2266 break;
2267
2268 be->dpcm[stream].state = SND_SOC_DPCM_STATE_PREPARE;
2269 }
2270
2271 if (ret < 0)
2272 dev_err(fe->dev, "ASoC: %s() failed (%d)\n", __func__, ret);
2273
2274 return ret;
2275}
2276
2277static int dpcm_fe_dai_prepare(struct snd_pcm_substream *substream)
2278{
2279 struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(substream);
2280 int stream = substream->stream, ret = 0;
2281
2282 mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
2283
2284 dev_dbg(fe->dev, "ASoC: prepare FE %s\n", fe->dai_link->name);
2285
2286 dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_FE);
2287
2288
2289 if (list_empty(&fe->dpcm[stream].be_clients)) {
2290 dev_err(fe->dev, "ASoC: no backend DAIs enabled for %s\n",
2291 fe->dai_link->name);
2292 ret = -EINVAL;
2293 goto out;
2294 }
2295
2296 ret = dpcm_be_dai_prepare(fe, stream);
2297 if (ret < 0)
2298 goto out;
2299
2300
2301 ret = soc_pcm_prepare(substream);
2302 if (ret < 0)
2303 goto out;
2304
2305 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_PREPARE;
2306
2307out:
2308 dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_NO);
2309 mutex_unlock(&fe->card->mutex);
2310
2311 if (ret < 0)
2312 dev_err(fe->dev, "ASoC: %s() failed (%d)\n", __func__, ret);
2313
2314 return ret;
2315}
2316
2317static int dpcm_run_update_shutdown(struct snd_soc_pcm_runtime *fe, int stream)
2318{
2319 struct snd_pcm_substream *substream =
2320 snd_soc_dpcm_get_substream(fe, stream);
2321 enum snd_soc_dpcm_trigger trigger = fe->dai_link->trigger[stream];
2322 int err;
2323
2324 dev_dbg(fe->dev, "ASoC: runtime %s close on FE %s\n",
2325 stream ? "capture" : "playback", fe->dai_link->name);
2326
2327 if (trigger == SND_SOC_DPCM_TRIGGER_BESPOKE) {
2328
2329 dev_dbg(fe->dev, "ASoC: bespoke trigger FE %s cmd stop\n",
2330 fe->dai_link->name);
2331
2332 err = snd_soc_pcm_dai_bespoke_trigger(substream, SNDRV_PCM_TRIGGER_STOP);
2333 } else {
2334 dev_dbg(fe->dev, "ASoC: trigger FE %s cmd stop\n",
2335 fe->dai_link->name);
2336
2337 err = dpcm_be_dai_trigger(fe, stream, SNDRV_PCM_TRIGGER_STOP);
2338 }
2339
2340 dpcm_be_dai_hw_free(fe, stream);
2341
2342 dpcm_be_dai_shutdown(fe, stream);
2343
2344
2345 dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_NOP);
2346
2347 if (err < 0)
2348 dev_err(fe->dev, "ASoC: %s() failed (%d)\n", __func__, err);
2349
2350 return err;
2351}
2352
2353static int dpcm_run_update_startup(struct snd_soc_pcm_runtime *fe, int stream)
2354{
2355 struct snd_pcm_substream *substream =
2356 snd_soc_dpcm_get_substream(fe, stream);
2357 struct snd_soc_dpcm *dpcm;
2358 enum snd_soc_dpcm_trigger trigger = fe->dai_link->trigger[stream];
2359 int ret = 0;
2360 unsigned long flags;
2361
2362 dev_dbg(fe->dev, "ASoC: runtime %s open on FE %s\n",
2363 stream ? "capture" : "playback", fe->dai_link->name);
2364
2365
2366 if (fe->dpcm[stream].state == SND_SOC_DPCM_STATE_HW_FREE ||
2367 fe->dpcm[stream].state == SND_SOC_DPCM_STATE_CLOSE) {
2368 dev_err(fe->dev, "ASoC: FE %s is not ready %d\n",
2369 fe->dai_link->name, fe->dpcm[stream].state);
2370 ret = -EINVAL;
2371 goto disconnect;
2372 }
2373
2374
2375 ret = dpcm_be_dai_startup(fe, stream);
2376 if (ret < 0)
2377 goto disconnect;
2378
2379
2380 if (fe->dpcm[stream].state == SND_SOC_DPCM_STATE_OPEN)
2381 return 0;
2382
2383 ret = dpcm_be_dai_hw_params(fe, stream);
2384 if (ret < 0)
2385 goto close;
2386
2387
2388 if (fe->dpcm[stream].state == SND_SOC_DPCM_STATE_HW_PARAMS)
2389 return 0;
2390
2391 ret = dpcm_be_dai_prepare(fe, stream);
2392 if (ret < 0)
2393 goto hw_free;
2394
2395
2396 dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_NOP);
2397
2398
2399 if (fe->dpcm[stream].state == SND_SOC_DPCM_STATE_PREPARE ||
2400 fe->dpcm[stream].state == SND_SOC_DPCM_STATE_STOP)
2401 return 0;
2402
2403 if (trigger == SND_SOC_DPCM_TRIGGER_BESPOKE) {
2404
2405 dev_dbg(fe->dev, "ASoC: bespoke trigger FE %s cmd start\n",
2406 fe->dai_link->name);
2407
2408 ret = snd_soc_pcm_dai_bespoke_trigger(substream, SNDRV_PCM_TRIGGER_START);
2409 if (ret < 0)
2410 goto hw_free;
2411 } else {
2412 dev_dbg(fe->dev, "ASoC: trigger FE %s cmd start\n",
2413 fe->dai_link->name);
2414
2415 ret = dpcm_be_dai_trigger(fe, stream,
2416 SNDRV_PCM_TRIGGER_START);
2417 if (ret < 0)
2418 goto hw_free;
2419 }
2420
2421 return 0;
2422
2423hw_free:
2424 dpcm_be_dai_hw_free(fe, stream);
2425close:
2426 dpcm_be_dai_shutdown(fe, stream);
2427disconnect:
2428
2429 spin_lock_irqsave(&fe->card->dpcm_lock, flags);
2430 for_each_dpcm_be(fe, stream, dpcm) {
2431 struct snd_soc_pcm_runtime *be = dpcm->be;
2432
2433
2434 if (!snd_soc_dpcm_be_can_update(fe, be, stream))
2435 continue;
2436
2437 if (be->dpcm[stream].state == SND_SOC_DPCM_STATE_CLOSE ||
2438 be->dpcm[stream].state == SND_SOC_DPCM_STATE_NEW)
2439 dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE;
2440 }
2441 spin_unlock_irqrestore(&fe->card->dpcm_lock, flags);
2442
2443 if (ret < 0)
2444 dev_err(fe->dev, "ASoC: %s() failed (%d)\n", __func__, ret);
2445
2446 return ret;
2447}
2448
2449static int soc_dpcm_fe_runtime_update(struct snd_soc_pcm_runtime *fe, int new)
2450{
2451 struct snd_soc_dapm_widget_list *list;
2452 int stream;
2453 int count, paths;
2454
2455 if (!fe->dai_link->dynamic)
2456 return 0;
2457
2458 if (fe->num_cpus > 1) {
2459 dev_err(fe->dev,
2460 "%s doesn't support Multi CPU yet\n", __func__);
2461 return -EINVAL;
2462 }
2463
2464
2465 if (!snd_soc_dai_active(asoc_rtd_to_cpu(fe, 0)))
2466 return 0;
2467
2468
2469 dev_dbg(fe->dev, "ASoC: DPCM %s runtime update for FE %s\n",
2470 new ? "new" : "old", fe->dai_link->name);
2471
2472 for_each_pcm_streams(stream) {
2473
2474
2475 if (!snd_soc_dai_stream_valid(asoc_rtd_to_cpu(fe, 0), stream) ||
2476 !snd_soc_dai_stream_valid(asoc_rtd_to_codec(fe, 0), stream))
2477 continue;
2478
2479
2480 if (!snd_soc_dai_stream_active(asoc_rtd_to_cpu(fe, 0), stream) ||
2481 !snd_soc_dai_stream_active(asoc_rtd_to_codec(fe, 0), stream))
2482 continue;
2483
2484 paths = dpcm_path_get(fe, stream, &list);
2485 if (paths < 0)
2486 return paths;
2487
2488
2489 count = dpcm_process_paths(fe, stream, &list, new);
2490 if (count) {
2491 dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_BE);
2492 if (new)
2493 dpcm_run_update_startup(fe, stream);
2494 else
2495 dpcm_run_update_shutdown(fe, stream);
2496 dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_NO);
2497
2498 dpcm_clear_pending_state(fe, stream);
2499 dpcm_be_disconnect(fe, stream);
2500 }
2501
2502 dpcm_path_put(&list);
2503 }
2504
2505 return 0;
2506}
2507
2508
2509
2510
2511int snd_soc_dpcm_runtime_update(struct snd_soc_card *card)
2512{
2513 struct snd_soc_pcm_runtime *fe;
2514 int ret = 0;
2515
2516 mutex_lock_nested(&card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
2517
2518 for_each_card_rtds(card, fe) {
2519 ret = soc_dpcm_fe_runtime_update(fe, 0);
2520 if (ret)
2521 goto out;
2522 }
2523
2524
2525 for_each_card_rtds(card, fe) {
2526 ret = soc_dpcm_fe_runtime_update(fe, 1);
2527 if (ret)
2528 goto out;
2529 }
2530
2531out:
2532 mutex_unlock(&card->mutex);
2533 return ret;
2534}
2535EXPORT_SYMBOL_GPL(snd_soc_dpcm_runtime_update);
2536
2537static void dpcm_fe_dai_cleanup(struct snd_pcm_substream *fe_substream)
2538{
2539 struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(fe_substream);
2540 struct snd_soc_dpcm *dpcm;
2541 int stream = fe_substream->stream;
2542
2543
2544 for_each_dpcm_be(fe, stream, dpcm)
2545 dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE;
2546
2547 dpcm_be_disconnect(fe, stream);
2548
2549 fe->dpcm[stream].runtime = NULL;
2550}
2551
2552static int dpcm_fe_dai_close(struct snd_pcm_substream *fe_substream)
2553{
2554 struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(fe_substream);
2555 int ret;
2556
2557 mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
2558 ret = dpcm_fe_dai_shutdown(fe_substream);
2559
2560 dpcm_fe_dai_cleanup(fe_substream);
2561
2562 mutex_unlock(&fe->card->mutex);
2563 return ret;
2564}
2565
2566static int dpcm_fe_dai_open(struct snd_pcm_substream *fe_substream)
2567{
2568 struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(fe_substream);
2569 struct snd_soc_dapm_widget_list *list;
2570 int ret;
2571 int stream = fe_substream->stream;
2572
2573 mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);
2574 fe->dpcm[stream].runtime = fe_substream->runtime;
2575
2576 ret = dpcm_path_get(fe, stream, &list);
2577 if (ret < 0)
2578 goto open_end;
2579
2580
2581 dpcm_process_paths(fe, stream, &list, 1);
2582
2583 ret = dpcm_fe_dai_startup(fe_substream);
2584 if (ret < 0)
2585 dpcm_fe_dai_cleanup(fe_substream);
2586
2587 dpcm_clear_pending_state(fe, stream);
2588 dpcm_path_put(&list);
2589open_end:
2590 mutex_unlock(&fe->card->mutex);
2591 return ret;
2592}
2593
2594static int soc_get_playback_capture(struct snd_soc_pcm_runtime *rtd,
2595 int *playback, int *capture)
2596{
2597 struct snd_soc_dai *cpu_dai;
2598 int i;
2599
2600 if (rtd->dai_link->dynamic && rtd->num_cpus > 1) {
2601 dev_err(rtd->dev,
2602 "DPCM doesn't support Multi CPU for Front-Ends yet\n");
2603 return -EINVAL;
2604 }
2605
2606 if (rtd->dai_link->dynamic || rtd->dai_link->no_pcm) {
2607 int stream;
2608
2609 if (rtd->dai_link->dpcm_playback) {
2610 stream = SNDRV_PCM_STREAM_PLAYBACK;
2611
2612 for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
2613 if (snd_soc_dai_stream_valid(cpu_dai, stream)) {
2614 *playback = 1;
2615 break;
2616 }
2617 }
2618 if (!*playback) {
2619 dev_err(rtd->card->dev,
2620 "No CPU DAIs support playback for stream %s\n",
2621 rtd->dai_link->stream_name);
2622 return -EINVAL;
2623 }
2624 }
2625 if (rtd->dai_link->dpcm_capture) {
2626 stream = SNDRV_PCM_STREAM_CAPTURE;
2627
2628 for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
2629 if (snd_soc_dai_stream_valid(cpu_dai, stream)) {
2630 *capture = 1;
2631 break;
2632 }
2633 }
2634
2635 if (!*capture) {
2636 dev_err(rtd->card->dev,
2637 "No CPU DAIs support capture for stream %s\n",
2638 rtd->dai_link->stream_name);
2639 return -EINVAL;
2640 }
2641 }
2642 } else {
2643 struct snd_soc_dai *codec_dai;
2644
2645
2646 int cpu_capture = rtd->dai_link->params ?
2647 SNDRV_PCM_STREAM_PLAYBACK : SNDRV_PCM_STREAM_CAPTURE;
2648 int cpu_playback = rtd->dai_link->params ?
2649 SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
2650
2651 for_each_rtd_codec_dais(rtd, i, codec_dai) {
2652 if (rtd->num_cpus == 1) {
2653 cpu_dai = asoc_rtd_to_cpu(rtd, 0);
2654 } else if (rtd->num_cpus == rtd->num_codecs) {
2655 cpu_dai = asoc_rtd_to_cpu(rtd, i);
2656 } else {
2657 dev_err(rtd->card->dev,
2658 "N cpus to M codecs link is not supported yet\n");
2659 return -EINVAL;
2660 }
2661
2662 if (snd_soc_dai_stream_valid(codec_dai, SNDRV_PCM_STREAM_PLAYBACK) &&
2663 snd_soc_dai_stream_valid(cpu_dai, cpu_playback))
2664 *playback = 1;
2665 if (snd_soc_dai_stream_valid(codec_dai, SNDRV_PCM_STREAM_CAPTURE) &&
2666 snd_soc_dai_stream_valid(cpu_dai, cpu_capture))
2667 *capture = 1;
2668 }
2669 }
2670
2671 if (rtd->dai_link->playback_only) {
2672 *playback = 1;
2673 *capture = 0;
2674 }
2675
2676 if (rtd->dai_link->capture_only) {
2677 *playback = 0;
2678 *capture = 1;
2679 }
2680
2681 return 0;
2682}
2683
2684static int soc_create_pcm(struct snd_pcm **pcm,
2685 struct snd_soc_pcm_runtime *rtd,
2686 int playback, int capture, int num)
2687{
2688 char new_name[64];
2689 int ret;
2690
2691
2692 if (rtd->dai_link->params) {
2693 snprintf(new_name, sizeof(new_name), "codec2codec(%s)",
2694 rtd->dai_link->stream_name);
2695
2696 ret = snd_pcm_new_internal(rtd->card->snd_card, new_name, num,
2697 playback, capture, pcm);
2698 } else if (rtd->dai_link->no_pcm) {
2699 snprintf(new_name, sizeof(new_name), "(%s)",
2700 rtd->dai_link->stream_name);
2701
2702 ret = snd_pcm_new_internal(rtd->card->snd_card, new_name, num,
2703 playback, capture, pcm);
2704 } else {
2705 if (rtd->dai_link->dynamic)
2706 snprintf(new_name, sizeof(new_name), "%s (*)",
2707 rtd->dai_link->stream_name);
2708 else
2709 snprintf(new_name, sizeof(new_name), "%s %s-%d",
2710 rtd->dai_link->stream_name,
2711 soc_codec_dai_name(rtd), num);
2712
2713 ret = snd_pcm_new(rtd->card->snd_card, new_name, num, playback,
2714 capture, pcm);
2715 }
2716 if (ret < 0) {
2717 dev_err(rtd->card->dev, "ASoC: can't create pcm %s for dailink %s: %d\n",
2718 new_name, rtd->dai_link->name, ret);
2719 return ret;
2720 }
2721 dev_dbg(rtd->card->dev, "ASoC: registered pcm #%d %s\n",num, new_name);
2722
2723 return 0;
2724}
2725
2726
2727int soc_new_pcm(struct snd_soc_pcm_runtime *rtd, int num)
2728{
2729 struct snd_soc_component *component;
2730 struct snd_pcm *pcm;
2731 int ret = 0, playback = 0, capture = 0;
2732 int i;
2733
2734 ret = soc_get_playback_capture(rtd, &playback, &capture);
2735 if (ret < 0)
2736 return ret;
2737
2738 ret = soc_create_pcm(&pcm, rtd, playback, capture, num);
2739 if (ret < 0)
2740 return ret;
2741
2742
2743 if (rtd->dai_link->params)
2744 rtd->close_delayed_work_func = codec2codec_close_delayed_work;
2745 else
2746 rtd->close_delayed_work_func = snd_soc_close_delayed_work;
2747
2748 rtd->pcm = pcm;
2749 pcm->nonatomic = rtd->dai_link->nonatomic;
2750 pcm->private_data = rtd;
2751
2752 if (rtd->dai_link->no_pcm || rtd->dai_link->params) {
2753 if (playback)
2754 pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream->private_data = rtd;
2755 if (capture)
2756 pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream->private_data = rtd;
2757 goto out;
2758 }
2759
2760
2761 if (rtd->dai_link->dynamic) {
2762 rtd->ops.open = dpcm_fe_dai_open;
2763 rtd->ops.hw_params = dpcm_fe_dai_hw_params;
2764 rtd->ops.prepare = dpcm_fe_dai_prepare;
2765 rtd->ops.trigger = dpcm_fe_dai_trigger;
2766 rtd->ops.hw_free = dpcm_fe_dai_hw_free;
2767 rtd->ops.close = dpcm_fe_dai_close;
2768 rtd->ops.pointer = soc_pcm_pointer;
2769 } else {
2770 rtd->ops.open = soc_pcm_open;
2771 rtd->ops.hw_params = soc_pcm_hw_params;
2772 rtd->ops.prepare = soc_pcm_prepare;
2773 rtd->ops.trigger = soc_pcm_trigger;
2774 rtd->ops.hw_free = soc_pcm_hw_free;
2775 rtd->ops.close = soc_pcm_close;
2776 rtd->ops.pointer = soc_pcm_pointer;
2777 }
2778
2779 for_each_rtd_components(rtd, i, component) {
2780 const struct snd_soc_component_driver *drv = component->driver;
2781
2782 if (drv->ioctl)
2783 rtd->ops.ioctl = snd_soc_pcm_component_ioctl;
2784 if (drv->sync_stop)
2785 rtd->ops.sync_stop = snd_soc_pcm_component_sync_stop;
2786 if (drv->copy_user)
2787 rtd->ops.copy_user = snd_soc_pcm_component_copy_user;
2788 if (drv->page)
2789 rtd->ops.page = snd_soc_pcm_component_page;
2790 if (drv->mmap)
2791 rtd->ops.mmap = snd_soc_pcm_component_mmap;
2792 if (drv->ack)
2793 rtd->ops.ack = snd_soc_pcm_component_ack;
2794 }
2795
2796 if (playback)
2797 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &rtd->ops);
2798
2799 if (capture)
2800 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &rtd->ops);
2801
2802 ret = snd_soc_pcm_component_new(rtd);
2803 if (ret < 0)
2804 return ret;
2805
2806 pcm->no_device_suspend = true;
2807out:
2808 dev_dbg(rtd->card->dev, "%s <-> %s mapping ok\n",
2809 soc_codec_dai_name(rtd), soc_cpu_dai_name(rtd));
2810 return ret;
2811}
2812
2813
2814int snd_soc_dpcm_fe_can_update(struct snd_soc_pcm_runtime *fe, int stream)
2815{
2816 if (fe->dpcm[stream].runtime_update == SND_SOC_DPCM_UPDATE_FE)
2817 return 1;
2818 return 0;
2819}
2820EXPORT_SYMBOL_GPL(snd_soc_dpcm_fe_can_update);
2821
2822
2823int snd_soc_dpcm_be_can_update(struct snd_soc_pcm_runtime *fe,
2824 struct snd_soc_pcm_runtime *be, int stream)
2825{
2826 if ((fe->dpcm[stream].runtime_update == SND_SOC_DPCM_UPDATE_FE) ||
2827 ((fe->dpcm[stream].runtime_update == SND_SOC_DPCM_UPDATE_BE) &&
2828 be->dpcm[stream].runtime_update))
2829 return 1;
2830 return 0;
2831}
2832EXPORT_SYMBOL_GPL(snd_soc_dpcm_be_can_update);
2833
2834
2835struct snd_pcm_substream *
2836 snd_soc_dpcm_get_substream(struct snd_soc_pcm_runtime *be, int stream)
2837{
2838 return be->pcm->streams[stream].substream;
2839}
2840EXPORT_SYMBOL_GPL(snd_soc_dpcm_get_substream);
2841
2842static int snd_soc_dpcm_check_state(struct snd_soc_pcm_runtime *fe,
2843 struct snd_soc_pcm_runtime *be,
2844 int stream,
2845 const enum snd_soc_dpcm_state *states,
2846 int num_states)
2847{
2848 struct snd_soc_dpcm *dpcm;
2849 int state;
2850 int ret = 1;
2851 unsigned long flags;
2852 int i;
2853
2854 spin_lock_irqsave(&fe->card->dpcm_lock, flags);
2855 for_each_dpcm_fe(be, stream, dpcm) {
2856
2857 if (dpcm->fe == fe)
2858 continue;
2859
2860 state = dpcm->fe->dpcm[stream].state;
2861 for (i = 0; i < num_states; i++) {
2862 if (state == states[i]) {
2863 ret = 0;
2864 break;
2865 }
2866 }
2867 }
2868 spin_unlock_irqrestore(&fe->card->dpcm_lock, flags);
2869
2870
2871 return ret;
2872}
2873
2874
2875
2876
2877
2878int snd_soc_dpcm_can_be_free_stop(struct snd_soc_pcm_runtime *fe,
2879 struct snd_soc_pcm_runtime *be, int stream)
2880{
2881 const enum snd_soc_dpcm_state state[] = {
2882 SND_SOC_DPCM_STATE_START,
2883 SND_SOC_DPCM_STATE_PAUSED,
2884 SND_SOC_DPCM_STATE_SUSPEND,
2885 };
2886
2887 return snd_soc_dpcm_check_state(fe, be, stream, state, ARRAY_SIZE(state));
2888}
2889EXPORT_SYMBOL_GPL(snd_soc_dpcm_can_be_free_stop);
2890
2891
2892
2893
2894
2895int snd_soc_dpcm_can_be_params(struct snd_soc_pcm_runtime *fe,
2896 struct snd_soc_pcm_runtime *be, int stream)
2897{
2898 const enum snd_soc_dpcm_state state[] = {
2899 SND_SOC_DPCM_STATE_START,
2900 SND_SOC_DPCM_STATE_PAUSED,
2901 SND_SOC_DPCM_STATE_SUSPEND,
2902 SND_SOC_DPCM_STATE_PREPARE,
2903 };
2904
2905 return snd_soc_dpcm_check_state(fe, be, stream, state, ARRAY_SIZE(state));
2906}
2907EXPORT_SYMBOL_GPL(snd_soc_dpcm_can_be_params);
2908