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