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