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