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