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