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