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