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