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