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