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