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_STOP)) 1247 continue; 1248 1249 dev_dbg(be->dev, "ASoC: hw_free BE %s\n", 1250 dpcm->fe->dai_link->name); 1251 1252 soc_pcm_hw_free(be_substream); 1253 1254 be->dpcm[stream].state = SND_SOC_DPCM_STATE_HW_FREE; 1255 } 1256 1257 return 0; 1258 } 1259 1260 static int dpcm_fe_dai_hw_free(struct snd_pcm_substream *substream) 1261 { 1262 struct snd_soc_pcm_runtime *fe = substream->private_data; 1263 int err, stream = substream->stream; 1264 1265 mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME); 1266 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE; 1267 1268 dev_dbg(fe->dev, "ASoC: hw_free FE %s\n", fe->dai_link->name); 1269 1270 /* call hw_free on the frontend */ 1271 err = soc_pcm_hw_free(substream); 1272 if (err < 0) 1273 dev_err(fe->dev,"ASoC: hw_free FE %s failed\n", 1274 fe->dai_link->name); 1275 1276 /* only hw_params backends that are either sinks or sources 1277 * to this frontend DAI */ 1278 err = dpcm_be_dai_hw_free(fe, stream); 1279 1280 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_HW_FREE; 1281 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO; 1282 1283 mutex_unlock(&fe->card->mutex); 1284 return 0; 1285 } 1286 1287 static int dpcm_be_dai_hw_params(struct snd_soc_pcm_runtime *fe, int stream) 1288 { 1289 struct snd_soc_dpcm *dpcm; 1290 int ret; 1291 1292 list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be) { 1293 1294 struct snd_soc_pcm_runtime *be = dpcm->be; 1295 struct snd_pcm_substream *be_substream = 1296 snd_soc_dpcm_get_substream(be, stream); 1297 1298 /* is this op for this BE ? */ 1299 if (!snd_soc_dpcm_be_can_update(fe, be, stream)) 1300 continue; 1301 1302 /* only allow hw_params() if no connected FEs are running */ 1303 if (!snd_soc_dpcm_can_be_params(fe, be, stream)) 1304 continue; 1305 1306 if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_OPEN) && 1307 (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_PARAMS) && 1308 (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_FREE)) 1309 continue; 1310 1311 dev_dbg(be->dev, "ASoC: hw_params BE %s\n", 1312 dpcm->fe->dai_link->name); 1313 1314 /* copy params for each dpcm */ 1315 memcpy(&dpcm->hw_params, &fe->dpcm[stream].hw_params, 1316 sizeof(struct snd_pcm_hw_params)); 1317 1318 /* perform any hw_params fixups */ 1319 if (be->dai_link->be_hw_params_fixup) { 1320 ret = be->dai_link->be_hw_params_fixup(be, 1321 &dpcm->hw_params); 1322 if (ret < 0) { 1323 dev_err(be->dev, 1324 "ASoC: hw_params BE fixup failed %d\n", 1325 ret); 1326 goto unwind; 1327 } 1328 } 1329 1330 ret = soc_pcm_hw_params(be_substream, &dpcm->hw_params); 1331 if (ret < 0) { 1332 dev_err(dpcm->be->dev, 1333 "ASoC: hw_params BE failed %d\n", ret); 1334 goto unwind; 1335 } 1336 1337 be->dpcm[stream].state = SND_SOC_DPCM_STATE_HW_PARAMS; 1338 } 1339 return 0; 1340 1341 unwind: 1342 /* disable any enabled and non active backends */ 1343 list_for_each_entry_continue_reverse(dpcm, &fe->dpcm[stream].be_clients, list_be) { 1344 struct snd_soc_pcm_runtime *be = dpcm->be; 1345 struct snd_pcm_substream *be_substream = 1346 snd_soc_dpcm_get_substream(be, stream); 1347 1348 if (!snd_soc_dpcm_be_can_update(fe, be, stream)) 1349 continue; 1350 1351 /* only allow hw_free() if no connected FEs are running */ 1352 if (!snd_soc_dpcm_can_be_free_stop(fe, be, stream)) 1353 continue; 1354 1355 if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_OPEN) && 1356 (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_PARAMS) && 1357 (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_FREE) && 1358 (be->dpcm[stream].state != SND_SOC_DPCM_STATE_STOP)) 1359 continue; 1360 1361 soc_pcm_hw_free(be_substream); 1362 } 1363 1364 return ret; 1365 } 1366 1367 static int dpcm_fe_dai_hw_params(struct snd_pcm_substream *substream, 1368 struct snd_pcm_hw_params *params) 1369 { 1370 struct snd_soc_pcm_runtime *fe = substream->private_data; 1371 int ret, stream = substream->stream; 1372 1373 mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME); 1374 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE; 1375 1376 memcpy(&fe->dpcm[substream->stream].hw_params, params, 1377 sizeof(struct snd_pcm_hw_params)); 1378 ret = dpcm_be_dai_hw_params(fe, substream->stream); 1379 if (ret < 0) { 1380 dev_err(fe->dev,"ASoC: hw_params BE failed %d\n", ret); 1381 goto out; 1382 } 1383 1384 dev_dbg(fe->dev, "ASoC: hw_params FE %s rate %d chan %x fmt %d\n", 1385 fe->dai_link->name, params_rate(params), 1386 params_channels(params), params_format(params)); 1387 1388 /* call hw_params on the frontend */ 1389 ret = soc_pcm_hw_params(substream, params); 1390 if (ret < 0) { 1391 dev_err(fe->dev,"ASoC: hw_params FE failed %d\n", ret); 1392 dpcm_be_dai_hw_free(fe, stream); 1393 } else 1394 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_HW_PARAMS; 1395 1396 out: 1397 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO; 1398 mutex_unlock(&fe->card->mutex); 1399 return ret; 1400 } 1401 1402 static int dpcm_do_trigger(struct snd_soc_dpcm *dpcm, 1403 struct snd_pcm_substream *substream, int cmd) 1404 { 1405 int ret; 1406 1407 dev_dbg(dpcm->be->dev, "ASoC: trigger BE %s cmd %d\n", 1408 dpcm->fe->dai_link->name, cmd); 1409 1410 ret = soc_pcm_trigger(substream, cmd); 1411 if (ret < 0) 1412 dev_err(dpcm->be->dev,"ASoC: trigger BE failed %d\n", ret); 1413 1414 return ret; 1415 } 1416 1417 static int dpcm_be_dai_trigger(struct snd_soc_pcm_runtime *fe, int stream, 1418 int cmd) 1419 { 1420 struct snd_soc_dpcm *dpcm; 1421 int ret = 0; 1422 1423 list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be) { 1424 1425 struct snd_soc_pcm_runtime *be = dpcm->be; 1426 struct snd_pcm_substream *be_substream = 1427 snd_soc_dpcm_get_substream(be, stream); 1428 1429 /* is this op for this BE ? */ 1430 if (!snd_soc_dpcm_be_can_update(fe, be, stream)) 1431 continue; 1432 1433 switch (cmd) { 1434 case SNDRV_PCM_TRIGGER_START: 1435 if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_PREPARE) && 1436 (be->dpcm[stream].state != SND_SOC_DPCM_STATE_STOP)) 1437 continue; 1438 1439 ret = dpcm_do_trigger(dpcm, be_substream, cmd); 1440 if (ret) 1441 return ret; 1442 1443 be->dpcm[stream].state = SND_SOC_DPCM_STATE_START; 1444 break; 1445 case SNDRV_PCM_TRIGGER_RESUME: 1446 if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_SUSPEND)) 1447 continue; 1448 1449 ret = dpcm_do_trigger(dpcm, be_substream, cmd); 1450 if (ret) 1451 return ret; 1452 1453 be->dpcm[stream].state = SND_SOC_DPCM_STATE_START; 1454 break; 1455 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 1456 if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_PAUSED)) 1457 continue; 1458 1459 ret = dpcm_do_trigger(dpcm, be_substream, cmd); 1460 if (ret) 1461 return ret; 1462 1463 be->dpcm[stream].state = SND_SOC_DPCM_STATE_START; 1464 break; 1465 case SNDRV_PCM_TRIGGER_STOP: 1466 if (be->dpcm[stream].state != SND_SOC_DPCM_STATE_START) 1467 continue; 1468 1469 if (!snd_soc_dpcm_can_be_free_stop(fe, be, stream)) 1470 continue; 1471 1472 ret = dpcm_do_trigger(dpcm, be_substream, cmd); 1473 if (ret) 1474 return ret; 1475 1476 be->dpcm[stream].state = SND_SOC_DPCM_STATE_STOP; 1477 break; 1478 case SNDRV_PCM_TRIGGER_SUSPEND: 1479 if (be->dpcm[stream].state != SND_SOC_DPCM_STATE_STOP) 1480 continue; 1481 1482 if (!snd_soc_dpcm_can_be_free_stop(fe, be, stream)) 1483 continue; 1484 1485 ret = dpcm_do_trigger(dpcm, be_substream, cmd); 1486 if (ret) 1487 return ret; 1488 1489 be->dpcm[stream].state = SND_SOC_DPCM_STATE_SUSPEND; 1490 break; 1491 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 1492 if (be->dpcm[stream].state != SND_SOC_DPCM_STATE_START) 1493 continue; 1494 1495 if (!snd_soc_dpcm_can_be_free_stop(fe, be, stream)) 1496 continue; 1497 1498 ret = dpcm_do_trigger(dpcm, be_substream, cmd); 1499 if (ret) 1500 return ret; 1501 1502 be->dpcm[stream].state = SND_SOC_DPCM_STATE_PAUSED; 1503 break; 1504 } 1505 } 1506 1507 return ret; 1508 } 1509 EXPORT_SYMBOL_GPL(dpcm_be_dai_trigger); 1510 1511 static int dpcm_fe_dai_trigger(struct snd_pcm_substream *substream, int cmd) 1512 { 1513 struct snd_soc_pcm_runtime *fe = substream->private_data; 1514 int stream = substream->stream, ret; 1515 enum snd_soc_dpcm_trigger trigger = fe->dai_link->trigger[stream]; 1516 1517 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE; 1518 1519 switch (trigger) { 1520 case SND_SOC_DPCM_TRIGGER_PRE: 1521 /* call trigger on the frontend before the backend. */ 1522 1523 dev_dbg(fe->dev, "ASoC: pre trigger FE %s cmd %d\n", 1524 fe->dai_link->name, cmd); 1525 1526 ret = soc_pcm_trigger(substream, cmd); 1527 if (ret < 0) { 1528 dev_err(fe->dev,"ASoC: trigger FE failed %d\n", ret); 1529 goto out; 1530 } 1531 1532 ret = dpcm_be_dai_trigger(fe, substream->stream, cmd); 1533 break; 1534 case SND_SOC_DPCM_TRIGGER_POST: 1535 /* call trigger on the frontend after the backend. */ 1536 1537 ret = dpcm_be_dai_trigger(fe, substream->stream, cmd); 1538 if (ret < 0) { 1539 dev_err(fe->dev,"ASoC: trigger FE failed %d\n", ret); 1540 goto out; 1541 } 1542 1543 dev_dbg(fe->dev, "ASoC: post trigger FE %s cmd %d\n", 1544 fe->dai_link->name, cmd); 1545 1546 ret = soc_pcm_trigger(substream, cmd); 1547 break; 1548 case SND_SOC_DPCM_TRIGGER_BESPOKE: 1549 /* bespoke trigger() - handles both FE and BEs */ 1550 1551 dev_dbg(fe->dev, "ASoC: bespoke trigger FE %s cmd %d\n", 1552 fe->dai_link->name, cmd); 1553 1554 ret = soc_pcm_bespoke_trigger(substream, cmd); 1555 if (ret < 0) { 1556 dev_err(fe->dev,"ASoC: trigger FE failed %d\n", ret); 1557 goto out; 1558 } 1559 break; 1560 default: 1561 dev_err(fe->dev, "ASoC: invalid trigger cmd %d for %s\n", cmd, 1562 fe->dai_link->name); 1563 ret = -EINVAL; 1564 goto out; 1565 } 1566 1567 switch (cmd) { 1568 case SNDRV_PCM_TRIGGER_START: 1569 case SNDRV_PCM_TRIGGER_RESUME: 1570 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 1571 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_START; 1572 break; 1573 case SNDRV_PCM_TRIGGER_STOP: 1574 case SNDRV_PCM_TRIGGER_SUSPEND: 1575 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 1576 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_STOP; 1577 break; 1578 } 1579 1580 out: 1581 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO; 1582 return ret; 1583 } 1584 1585 static int dpcm_be_dai_prepare(struct snd_soc_pcm_runtime *fe, int stream) 1586 { 1587 struct snd_soc_dpcm *dpcm; 1588 int ret = 0; 1589 1590 list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be) { 1591 1592 struct snd_soc_pcm_runtime *be = dpcm->be; 1593 struct snd_pcm_substream *be_substream = 1594 snd_soc_dpcm_get_substream(be, stream); 1595 1596 /* is this op for this BE ? */ 1597 if (!snd_soc_dpcm_be_can_update(fe, be, stream)) 1598 continue; 1599 1600 if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_PARAMS) && 1601 (be->dpcm[stream].state != SND_SOC_DPCM_STATE_STOP)) 1602 continue; 1603 1604 dev_dbg(be->dev, "ASoC: prepare BE %s\n", 1605 dpcm->fe->dai_link->name); 1606 1607 ret = soc_pcm_prepare(be_substream); 1608 if (ret < 0) { 1609 dev_err(be->dev, "ASoC: backend prepare failed %d\n", 1610 ret); 1611 break; 1612 } 1613 1614 be->dpcm[stream].state = SND_SOC_DPCM_STATE_PREPARE; 1615 } 1616 return ret; 1617 } 1618 1619 static int dpcm_fe_dai_prepare(struct snd_pcm_substream *substream) 1620 { 1621 struct snd_soc_pcm_runtime *fe = substream->private_data; 1622 int stream = substream->stream, ret = 0; 1623 1624 mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME); 1625 1626 dev_dbg(fe->dev, "ASoC: prepare FE %s\n", fe->dai_link->name); 1627 1628 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE; 1629 1630 /* there is no point preparing this FE if there are no BEs */ 1631 if (list_empty(&fe->dpcm[stream].be_clients)) { 1632 dev_err(fe->dev, "ASoC: no backend DAIs enabled for %s\n", 1633 fe->dai_link->name); 1634 ret = -EINVAL; 1635 goto out; 1636 } 1637 1638 ret = dpcm_be_dai_prepare(fe, substream->stream); 1639 if (ret < 0) 1640 goto out; 1641 1642 /* call prepare on the frontend */ 1643 ret = soc_pcm_prepare(substream); 1644 if (ret < 0) { 1645 dev_err(fe->dev,"ASoC: prepare FE %s failed\n", 1646 fe->dai_link->name); 1647 goto out; 1648 } 1649 1650 /* run the stream event for each BE */ 1651 dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_START); 1652 fe->dpcm[stream].state = SND_SOC_DPCM_STATE_PREPARE; 1653 1654 out: 1655 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO; 1656 mutex_unlock(&fe->card->mutex); 1657 1658 return ret; 1659 } 1660 1661 static int soc_pcm_ioctl(struct snd_pcm_substream *substream, 1662 unsigned int cmd, void *arg) 1663 { 1664 struct snd_soc_pcm_runtime *rtd = substream->private_data; 1665 struct snd_soc_platform *platform = rtd->platform; 1666 1667 if (platform->driver->ops->ioctl) 1668 return platform->driver->ops->ioctl(substream, cmd, arg); 1669 return snd_pcm_lib_ioctl(substream, cmd, arg); 1670 } 1671 1672 static int dpcm_run_update_shutdown(struct snd_soc_pcm_runtime *fe, int stream) 1673 { 1674 struct snd_pcm_substream *substream = 1675 snd_soc_dpcm_get_substream(fe, stream); 1676 enum snd_soc_dpcm_trigger trigger = fe->dai_link->trigger[stream]; 1677 int err; 1678 1679 dev_dbg(fe->dev, "ASoC: runtime %s close on FE %s\n", 1680 stream ? "capture" : "playback", fe->dai_link->name); 1681 1682 if (trigger == SND_SOC_DPCM_TRIGGER_BESPOKE) { 1683 /* call bespoke trigger - FE takes care of all BE triggers */ 1684 dev_dbg(fe->dev, "ASoC: bespoke trigger FE %s cmd stop\n", 1685 fe->dai_link->name); 1686 1687 err = soc_pcm_bespoke_trigger(substream, SNDRV_PCM_TRIGGER_STOP); 1688 if (err < 0) 1689 dev_err(fe->dev,"ASoC: trigger FE failed %d\n", err); 1690 } else { 1691 dev_dbg(fe->dev, "ASoC: trigger FE %s cmd stop\n", 1692 fe->dai_link->name); 1693 1694 err = dpcm_be_dai_trigger(fe, stream, SNDRV_PCM_TRIGGER_STOP); 1695 if (err < 0) 1696 dev_err(fe->dev,"ASoC: trigger FE failed %d\n", err); 1697 } 1698 1699 err = dpcm_be_dai_hw_free(fe, stream); 1700 if (err < 0) 1701 dev_err(fe->dev,"ASoC: hw_free FE failed %d\n", err); 1702 1703 err = dpcm_be_dai_shutdown(fe, stream); 1704 if (err < 0) 1705 dev_err(fe->dev,"ASoC: shutdown FE failed %d\n", err); 1706 1707 /* run the stream event for each BE */ 1708 dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_NOP); 1709 1710 return 0; 1711 } 1712 1713 static int dpcm_run_update_startup(struct snd_soc_pcm_runtime *fe, int stream) 1714 { 1715 struct snd_pcm_substream *substream = 1716 snd_soc_dpcm_get_substream(fe, stream); 1717 struct snd_soc_dpcm *dpcm; 1718 enum snd_soc_dpcm_trigger trigger = fe->dai_link->trigger[stream]; 1719 int ret; 1720 1721 dev_dbg(fe->dev, "ASoC: runtime %s open on FE %s\n", 1722 stream ? "capture" : "playback", fe->dai_link->name); 1723 1724 /* Only start the BE if the FE is ready */ 1725 if (fe->dpcm[stream].state == SND_SOC_DPCM_STATE_HW_FREE || 1726 fe->dpcm[stream].state == SND_SOC_DPCM_STATE_CLOSE) 1727 return -EINVAL; 1728 1729 /* startup must always be called for new BEs */ 1730 ret = dpcm_be_dai_startup(fe, stream); 1731 if (ret < 0) { 1732 goto disconnect; 1733 return ret; 1734 } 1735 1736 /* keep going if FE state is > open */ 1737 if (fe->dpcm[stream].state == SND_SOC_DPCM_STATE_OPEN) 1738 return 0; 1739 1740 ret = dpcm_be_dai_hw_params(fe, stream); 1741 if (ret < 0) { 1742 goto close; 1743 return ret; 1744 } 1745 1746 /* keep going if FE state is > hw_params */ 1747 if (fe->dpcm[stream].state == SND_SOC_DPCM_STATE_HW_PARAMS) 1748 return 0; 1749 1750 1751 ret = dpcm_be_dai_prepare(fe, stream); 1752 if (ret < 0) { 1753 goto hw_free; 1754 return ret; 1755 } 1756 1757 /* run the stream event for each BE */ 1758 dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_NOP); 1759 1760 /* keep going if FE state is > prepare */ 1761 if (fe->dpcm[stream].state == SND_SOC_DPCM_STATE_PREPARE || 1762 fe->dpcm[stream].state == SND_SOC_DPCM_STATE_STOP) 1763 return 0; 1764 1765 if (trigger == SND_SOC_DPCM_TRIGGER_BESPOKE) { 1766 /* call trigger on the frontend - FE takes care of all BE triggers */ 1767 dev_dbg(fe->dev, "ASoC: bespoke trigger FE %s cmd start\n", 1768 fe->dai_link->name); 1769 1770 ret = soc_pcm_bespoke_trigger(substream, SNDRV_PCM_TRIGGER_START); 1771 if (ret < 0) { 1772 dev_err(fe->dev,"ASoC: bespoke trigger FE failed %d\n", ret); 1773 goto hw_free; 1774 } 1775 } else { 1776 dev_dbg(fe->dev, "ASoC: trigger FE %s cmd start\n", 1777 fe->dai_link->name); 1778 1779 ret = dpcm_be_dai_trigger(fe, stream, 1780 SNDRV_PCM_TRIGGER_START); 1781 if (ret < 0) { 1782 dev_err(fe->dev,"ASoC: trigger FE failed %d\n", ret); 1783 goto hw_free; 1784 } 1785 } 1786 1787 return 0; 1788 1789 hw_free: 1790 dpcm_be_dai_hw_free(fe, stream); 1791 close: 1792 dpcm_be_dai_shutdown(fe, stream); 1793 disconnect: 1794 /* disconnect any non started BEs */ 1795 list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be) { 1796 struct snd_soc_pcm_runtime *be = dpcm->be; 1797 if (be->dpcm[stream].state != SND_SOC_DPCM_STATE_START) 1798 dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE; 1799 } 1800 1801 return ret; 1802 } 1803 1804 static int dpcm_run_new_update(struct snd_soc_pcm_runtime *fe, int stream) 1805 { 1806 int ret; 1807 1808 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_BE; 1809 ret = dpcm_run_update_startup(fe, stream); 1810 if (ret < 0) 1811 dev_err(fe->dev, "ASoC: failed to startup some BEs\n"); 1812 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO; 1813 1814 return ret; 1815 } 1816 1817 static int dpcm_run_old_update(struct snd_soc_pcm_runtime *fe, int stream) 1818 { 1819 int ret; 1820 1821 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_BE; 1822 ret = dpcm_run_update_shutdown(fe, stream); 1823 if (ret < 0) 1824 dev_err(fe->dev, "ASoC: failed to shutdown some BEs\n"); 1825 fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO; 1826 1827 return ret; 1828 } 1829 1830 /* Called by DAPM mixer/mux changes to update audio routing between PCMs and 1831 * any DAI links. 1832 */ 1833 int soc_dpcm_runtime_update(struct snd_soc_dapm_widget *widget) 1834 { 1835 struct snd_soc_card *card; 1836 int i, old, new, paths; 1837 1838 if (widget->codec) 1839 card = widget->codec->card; 1840 else if (widget->platform) 1841 card = widget->platform->card; 1842 else 1843 return -EINVAL; 1844 1845 mutex_lock_nested(&card->mutex, SND_SOC_CARD_CLASS_RUNTIME); 1846 for (i = 0; i < card->num_rtd; i++) { 1847 struct snd_soc_dapm_widget_list *list; 1848 struct snd_soc_pcm_runtime *fe = &card->rtd[i]; 1849 1850 /* make sure link is FE */ 1851 if (!fe->dai_link->dynamic) 1852 continue; 1853 1854 /* only check active links */ 1855 if (!fe->cpu_dai->active) 1856 continue; 1857 1858 /* DAPM sync will call this to update DSP paths */ 1859 dev_dbg(fe->dev, "ASoC: DPCM runtime update for FE %s\n", 1860 fe->dai_link->name); 1861 1862 /* skip if FE doesn't have playback capability */ 1863 if (!fe->cpu_dai->driver->playback.channels_min) 1864 goto capture; 1865 1866 paths = dpcm_path_get(fe, SNDRV_PCM_STREAM_PLAYBACK, &list); 1867 if (paths < 0) { 1868 dev_warn(fe->dev, "ASoC: %s no valid %s path\n", 1869 fe->dai_link->name, "playback"); 1870 mutex_unlock(&card->mutex); 1871 return paths; 1872 } 1873 1874 /* update any new playback paths */ 1875 new = dpcm_process_paths(fe, SNDRV_PCM_STREAM_PLAYBACK, &list, 1); 1876 if (new) { 1877 dpcm_run_new_update(fe, SNDRV_PCM_STREAM_PLAYBACK); 1878 dpcm_clear_pending_state(fe, SNDRV_PCM_STREAM_PLAYBACK); 1879 dpcm_be_disconnect(fe, SNDRV_PCM_STREAM_PLAYBACK); 1880 } 1881 1882 /* update any old playback paths */ 1883 old = dpcm_process_paths(fe, SNDRV_PCM_STREAM_PLAYBACK, &list, 0); 1884 if (old) { 1885 dpcm_run_old_update(fe, SNDRV_PCM_STREAM_PLAYBACK); 1886 dpcm_clear_pending_state(fe, SNDRV_PCM_STREAM_PLAYBACK); 1887 dpcm_be_disconnect(fe, SNDRV_PCM_STREAM_PLAYBACK); 1888 } 1889 1890 capture: 1891 /* skip if FE doesn't have capture capability */ 1892 if (!fe->cpu_dai->driver->capture.channels_min) 1893 continue; 1894 1895 paths = dpcm_path_get(fe, SNDRV_PCM_STREAM_CAPTURE, &list); 1896 if (paths < 0) { 1897 dev_warn(fe->dev, "ASoC: %s no valid %s path\n", 1898 fe->dai_link->name, "capture"); 1899 mutex_unlock(&card->mutex); 1900 return paths; 1901 } 1902 1903 /* update any new capture paths */ 1904 new = dpcm_process_paths(fe, SNDRV_PCM_STREAM_CAPTURE, &list, 1); 1905 if (new) { 1906 dpcm_run_new_update(fe, SNDRV_PCM_STREAM_CAPTURE); 1907 dpcm_clear_pending_state(fe, SNDRV_PCM_STREAM_CAPTURE); 1908 dpcm_be_disconnect(fe, SNDRV_PCM_STREAM_CAPTURE); 1909 } 1910 1911 /* update any old capture paths */ 1912 old = dpcm_process_paths(fe, SNDRV_PCM_STREAM_CAPTURE, &list, 0); 1913 if (old) { 1914 dpcm_run_old_update(fe, SNDRV_PCM_STREAM_CAPTURE); 1915 dpcm_clear_pending_state(fe, SNDRV_PCM_STREAM_CAPTURE); 1916 dpcm_be_disconnect(fe, SNDRV_PCM_STREAM_CAPTURE); 1917 } 1918 1919 dpcm_path_put(&list); 1920 } 1921 1922 mutex_unlock(&card->mutex); 1923 return 0; 1924 } 1925 int soc_dpcm_be_digital_mute(struct snd_soc_pcm_runtime *fe, int mute) 1926 { 1927 struct snd_soc_dpcm *dpcm; 1928 struct list_head *clients = 1929 &fe->dpcm[SNDRV_PCM_STREAM_PLAYBACK].be_clients; 1930 1931 list_for_each_entry(dpcm, clients, list_be) { 1932 1933 struct snd_soc_pcm_runtime *be = dpcm->be; 1934 struct snd_soc_dai *dai = be->codec_dai; 1935 struct snd_soc_dai_driver *drv = dai->driver; 1936 1937 if (be->dai_link->ignore_suspend) 1938 continue; 1939 1940 dev_dbg(be->dev, "ASoC: BE digital mute %s\n", be->dai_link->name); 1941 1942 if (drv->ops->digital_mute && dai->playback_active) 1943 drv->ops->digital_mute(dai, mute); 1944 } 1945 1946 return 0; 1947 } 1948 1949 static int dpcm_fe_dai_open(struct snd_pcm_substream *fe_substream) 1950 { 1951 struct snd_soc_pcm_runtime *fe = fe_substream->private_data; 1952 struct snd_soc_dpcm *dpcm; 1953 struct snd_soc_dapm_widget_list *list; 1954 int ret; 1955 int stream = fe_substream->stream; 1956 1957 mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME); 1958 fe->dpcm[stream].runtime = fe_substream->runtime; 1959 1960 if (dpcm_path_get(fe, stream, &list) <= 0) { 1961 dev_dbg(fe->dev, "ASoC: %s no valid %s route\n", 1962 fe->dai_link->name, stream ? "capture" : "playback"); 1963 } 1964 1965 /* calculate valid and active FE <-> BE dpcms */ 1966 dpcm_process_paths(fe, stream, &list, 1); 1967 1968 ret = dpcm_fe_dai_startup(fe_substream); 1969 if (ret < 0) { 1970 /* clean up all links */ 1971 list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be) 1972 dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE; 1973 1974 dpcm_be_disconnect(fe, stream); 1975 fe->dpcm[stream].runtime = NULL; 1976 } 1977 1978 dpcm_clear_pending_state(fe, stream); 1979 dpcm_path_put(&list); 1980 mutex_unlock(&fe->card->mutex); 1981 return ret; 1982 } 1983 1984 static int dpcm_fe_dai_close(struct snd_pcm_substream *fe_substream) 1985 { 1986 struct snd_soc_pcm_runtime *fe = fe_substream->private_data; 1987 struct snd_soc_dpcm *dpcm; 1988 int stream = fe_substream->stream, ret; 1989 1990 mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME); 1991 ret = dpcm_fe_dai_shutdown(fe_substream); 1992 1993 /* mark FE's links ready to prune */ 1994 list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be) 1995 dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE; 1996 1997 dpcm_be_disconnect(fe, stream); 1998 1999 fe->dpcm[stream].runtime = NULL; 2000 mutex_unlock(&fe->card->mutex); 2001 return ret; 2002 } 2003 2004 /* create a new pcm */ 2005 int soc_new_pcm(struct snd_soc_pcm_runtime *rtd, int num) 2006 { 2007 struct snd_soc_platform *platform = rtd->platform; 2008 struct snd_soc_dai *codec_dai = rtd->codec_dai; 2009 struct snd_soc_dai *cpu_dai = rtd->cpu_dai; 2010 struct snd_pcm *pcm; 2011 char new_name[64]; 2012 int ret = 0, playback = 0, capture = 0; 2013 2014 if (rtd->dai_link->dynamic || rtd->dai_link->no_pcm) { 2015 if (cpu_dai->driver->playback.channels_min) 2016 playback = 1; 2017 if (cpu_dai->driver->capture.channels_min) 2018 capture = 1; 2019 } else { 2020 if (codec_dai->driver->playback.channels_min) 2021 playback = 1; 2022 if (codec_dai->driver->capture.channels_min) 2023 capture = 1; 2024 } 2025 2026 /* create the PCM */ 2027 if (rtd->dai_link->no_pcm) { 2028 snprintf(new_name, sizeof(new_name), "(%s)", 2029 rtd->dai_link->stream_name); 2030 2031 ret = snd_pcm_new_internal(rtd->card->snd_card, new_name, num, 2032 playback, capture, &pcm); 2033 } else { 2034 if (rtd->dai_link->dynamic) 2035 snprintf(new_name, sizeof(new_name), "%s (*)", 2036 rtd->dai_link->stream_name); 2037 else 2038 snprintf(new_name, sizeof(new_name), "%s %s-%d", 2039 rtd->dai_link->stream_name, codec_dai->name, num); 2040 2041 ret = snd_pcm_new(rtd->card->snd_card, new_name, num, playback, 2042 capture, &pcm); 2043 } 2044 if (ret < 0) { 2045 dev_err(rtd->card->dev, "ASoC: can't create pcm for %s\n", 2046 rtd->dai_link->name); 2047 return ret; 2048 } 2049 dev_dbg(rtd->card->dev, "ASoC: registered pcm #%d %s\n",num, new_name); 2050 2051 /* DAPM dai link stream work */ 2052 INIT_DELAYED_WORK(&rtd->delayed_work, close_delayed_work); 2053 2054 rtd->pcm = pcm; 2055 pcm->private_data = rtd; 2056 2057 if (rtd->dai_link->no_pcm) { 2058 if (playback) 2059 pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream->private_data = rtd; 2060 if (capture) 2061 pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream->private_data = rtd; 2062 goto out; 2063 } 2064 2065 /* ASoC PCM operations */ 2066 if (rtd->dai_link->dynamic) { 2067 rtd->ops.open = dpcm_fe_dai_open; 2068 rtd->ops.hw_params = dpcm_fe_dai_hw_params; 2069 rtd->ops.prepare = dpcm_fe_dai_prepare; 2070 rtd->ops.trigger = dpcm_fe_dai_trigger; 2071 rtd->ops.hw_free = dpcm_fe_dai_hw_free; 2072 rtd->ops.close = dpcm_fe_dai_close; 2073 rtd->ops.pointer = soc_pcm_pointer; 2074 rtd->ops.ioctl = soc_pcm_ioctl; 2075 } else { 2076 rtd->ops.open = soc_pcm_open; 2077 rtd->ops.hw_params = soc_pcm_hw_params; 2078 rtd->ops.prepare = soc_pcm_prepare; 2079 rtd->ops.trigger = soc_pcm_trigger; 2080 rtd->ops.hw_free = soc_pcm_hw_free; 2081 rtd->ops.close = soc_pcm_close; 2082 rtd->ops.pointer = soc_pcm_pointer; 2083 rtd->ops.ioctl = soc_pcm_ioctl; 2084 } 2085 2086 if (platform->driver->ops) { 2087 rtd->ops.ack = platform->driver->ops->ack; 2088 rtd->ops.copy = platform->driver->ops->copy; 2089 rtd->ops.silence = platform->driver->ops->silence; 2090 rtd->ops.page = platform->driver->ops->page; 2091 rtd->ops.mmap = platform->driver->ops->mmap; 2092 } 2093 2094 if (playback) 2095 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &rtd->ops); 2096 2097 if (capture) 2098 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &rtd->ops); 2099 2100 if (platform->driver->pcm_new) { 2101 ret = platform->driver->pcm_new(rtd); 2102 if (ret < 0) { 2103 dev_err(platform->dev, 2104 "ASoC: pcm constructor failed: %d\n", 2105 ret); 2106 return ret; 2107 } 2108 } 2109 2110 pcm->private_free = platform->driver->pcm_free; 2111 out: 2112 dev_info(rtd->card->dev, " %s <-> %s mapping ok\n", codec_dai->name, 2113 cpu_dai->name); 2114 return ret; 2115 } 2116 2117 /* is the current PCM operation for this FE ? */ 2118 int snd_soc_dpcm_fe_can_update(struct snd_soc_pcm_runtime *fe, int stream) 2119 { 2120 if (fe->dpcm[stream].runtime_update == SND_SOC_DPCM_UPDATE_FE) 2121 return 1; 2122 return 0; 2123 } 2124 EXPORT_SYMBOL_GPL(snd_soc_dpcm_fe_can_update); 2125 2126 /* is the current PCM operation for this BE ? */ 2127 int snd_soc_dpcm_be_can_update(struct snd_soc_pcm_runtime *fe, 2128 struct snd_soc_pcm_runtime *be, int stream) 2129 { 2130 if ((fe->dpcm[stream].runtime_update == SND_SOC_DPCM_UPDATE_FE) || 2131 ((fe->dpcm[stream].runtime_update == SND_SOC_DPCM_UPDATE_BE) && 2132 be->dpcm[stream].runtime_update)) 2133 return 1; 2134 return 0; 2135 } 2136 EXPORT_SYMBOL_GPL(snd_soc_dpcm_be_can_update); 2137 2138 /* get the substream for this BE */ 2139 struct snd_pcm_substream * 2140 snd_soc_dpcm_get_substream(struct snd_soc_pcm_runtime *be, int stream) 2141 { 2142 return be->pcm->streams[stream].substream; 2143 } 2144 EXPORT_SYMBOL_GPL(snd_soc_dpcm_get_substream); 2145 2146 /* get the BE runtime state */ 2147 enum snd_soc_dpcm_state 2148 snd_soc_dpcm_be_get_state(struct snd_soc_pcm_runtime *be, int stream) 2149 { 2150 return be->dpcm[stream].state; 2151 } 2152 EXPORT_SYMBOL_GPL(snd_soc_dpcm_be_get_state); 2153 2154 /* set the BE runtime state */ 2155 void snd_soc_dpcm_be_set_state(struct snd_soc_pcm_runtime *be, 2156 int stream, enum snd_soc_dpcm_state state) 2157 { 2158 be->dpcm[stream].state = state; 2159 } 2160 EXPORT_SYMBOL_GPL(snd_soc_dpcm_be_set_state); 2161 2162 /* 2163 * We can only hw_free, stop, pause or suspend a BE DAI if any of it's FE 2164 * are not running, paused or suspended for the specified stream direction. 2165 */ 2166 int snd_soc_dpcm_can_be_free_stop(struct snd_soc_pcm_runtime *fe, 2167 struct snd_soc_pcm_runtime *be, int stream) 2168 { 2169 struct snd_soc_dpcm *dpcm; 2170 int state; 2171 2172 list_for_each_entry(dpcm, &be->dpcm[stream].fe_clients, list_fe) { 2173 2174 if (dpcm->fe == fe) 2175 continue; 2176 2177 state = dpcm->fe->dpcm[stream].state; 2178 if (state == SND_SOC_DPCM_STATE_START || 2179 state == SND_SOC_DPCM_STATE_PAUSED || 2180 state == SND_SOC_DPCM_STATE_SUSPEND) 2181 return 0; 2182 } 2183 2184 /* it's safe to free/stop this BE DAI */ 2185 return 1; 2186 } 2187 EXPORT_SYMBOL_GPL(snd_soc_dpcm_can_be_free_stop); 2188 2189 /* 2190 * We can only change hw params a BE DAI if any of it's FE are not prepared, 2191 * running, paused or suspended for the specified stream direction. 2192 */ 2193 int snd_soc_dpcm_can_be_params(struct snd_soc_pcm_runtime *fe, 2194 struct snd_soc_pcm_runtime *be, int stream) 2195 { 2196 struct snd_soc_dpcm *dpcm; 2197 int state; 2198 2199 list_for_each_entry(dpcm, &be->dpcm[stream].fe_clients, list_fe) { 2200 2201 if (dpcm->fe == fe) 2202 continue; 2203 2204 state = dpcm->fe->dpcm[stream].state; 2205 if (state == SND_SOC_DPCM_STATE_START || 2206 state == SND_SOC_DPCM_STATE_PAUSED || 2207 state == SND_SOC_DPCM_STATE_SUSPEND || 2208 state == SND_SOC_DPCM_STATE_PREPARE) 2209 return 0; 2210 } 2211 2212 /* it's safe to change hw_params */ 2213 return 1; 2214 } 2215 EXPORT_SYMBOL_GPL(snd_soc_dpcm_can_be_params); 2216 2217 int snd_soc_platform_trigger(struct snd_pcm_substream *substream, 2218 int cmd, struct snd_soc_platform *platform) 2219 { 2220 if (platform->driver->ops->trigger) 2221 return platform->driver->ops->trigger(substream, cmd); 2222 return 0; 2223 } 2224 EXPORT_SYMBOL_GPL(snd_soc_platform_trigger); 2225 2226 #ifdef CONFIG_DEBUG_FS 2227 static char *dpcm_state_string(enum snd_soc_dpcm_state state) 2228 { 2229 switch (state) { 2230 case SND_SOC_DPCM_STATE_NEW: 2231 return "new"; 2232 case SND_SOC_DPCM_STATE_OPEN: 2233 return "open"; 2234 case SND_SOC_DPCM_STATE_HW_PARAMS: 2235 return "hw_params"; 2236 case SND_SOC_DPCM_STATE_PREPARE: 2237 return "prepare"; 2238 case SND_SOC_DPCM_STATE_START: 2239 return "start"; 2240 case SND_SOC_DPCM_STATE_STOP: 2241 return "stop"; 2242 case SND_SOC_DPCM_STATE_SUSPEND: 2243 return "suspend"; 2244 case SND_SOC_DPCM_STATE_PAUSED: 2245 return "paused"; 2246 case SND_SOC_DPCM_STATE_HW_FREE: 2247 return "hw_free"; 2248 case SND_SOC_DPCM_STATE_CLOSE: 2249 return "close"; 2250 } 2251 2252 return "unknown"; 2253 } 2254 2255 static ssize_t dpcm_show_state(struct snd_soc_pcm_runtime *fe, 2256 int stream, char *buf, size_t size) 2257 { 2258 struct snd_pcm_hw_params *params = &fe->dpcm[stream].hw_params; 2259 struct snd_soc_dpcm *dpcm; 2260 ssize_t offset = 0; 2261 2262 /* FE state */ 2263 offset += snprintf(buf + offset, size - offset, 2264 "[%s - %s]\n", fe->dai_link->name, 2265 stream ? "Capture" : "Playback"); 2266 2267 offset += snprintf(buf + offset, size - offset, "State: %s\n", 2268 dpcm_state_string(fe->dpcm[stream].state)); 2269 2270 if ((fe->dpcm[stream].state >= SND_SOC_DPCM_STATE_HW_PARAMS) && 2271 (fe->dpcm[stream].state <= SND_SOC_DPCM_STATE_STOP)) 2272 offset += snprintf(buf + offset, size - offset, 2273 "Hardware Params: " 2274 "Format = %s, Channels = %d, Rate = %d\n", 2275 snd_pcm_format_name(params_format(params)), 2276 params_channels(params), 2277 params_rate(params)); 2278 2279 /* BEs state */ 2280 offset += snprintf(buf + offset, size - offset, "Backends:\n"); 2281 2282 if (list_empty(&fe->dpcm[stream].be_clients)) { 2283 offset += snprintf(buf + offset, size - offset, 2284 " No active DSP links\n"); 2285 goto out; 2286 } 2287 2288 list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be) { 2289 struct snd_soc_pcm_runtime *be = dpcm->be; 2290 params = &dpcm->hw_params; 2291 2292 offset += snprintf(buf + offset, size - offset, 2293 "- %s\n", be->dai_link->name); 2294 2295 offset += snprintf(buf + offset, size - offset, 2296 " State: %s\n", 2297 dpcm_state_string(be->dpcm[stream].state)); 2298 2299 if ((be->dpcm[stream].state >= SND_SOC_DPCM_STATE_HW_PARAMS) && 2300 (be->dpcm[stream].state <= SND_SOC_DPCM_STATE_STOP)) 2301 offset += snprintf(buf + offset, size - offset, 2302 " Hardware Params: " 2303 "Format = %s, Channels = %d, Rate = %d\n", 2304 snd_pcm_format_name(params_format(params)), 2305 params_channels(params), 2306 params_rate(params)); 2307 } 2308 2309 out: 2310 return offset; 2311 } 2312 2313 static ssize_t dpcm_state_read_file(struct file *file, char __user *user_buf, 2314 size_t count, loff_t *ppos) 2315 { 2316 struct snd_soc_pcm_runtime *fe = file->private_data; 2317 ssize_t out_count = PAGE_SIZE, offset = 0, ret = 0; 2318 char *buf; 2319 2320 buf = kmalloc(out_count, GFP_KERNEL); 2321 if (!buf) 2322 return -ENOMEM; 2323 2324 if (fe->cpu_dai->driver->playback.channels_min) 2325 offset += dpcm_show_state(fe, SNDRV_PCM_STREAM_PLAYBACK, 2326 buf + offset, out_count - offset); 2327 2328 if (fe->cpu_dai->driver->capture.channels_min) 2329 offset += dpcm_show_state(fe, SNDRV_PCM_STREAM_CAPTURE, 2330 buf + offset, out_count - offset); 2331 2332 ret = simple_read_from_buffer(user_buf, count, ppos, buf, offset); 2333 2334 kfree(buf); 2335 return ret; 2336 } 2337 2338 static const struct file_operations dpcm_state_fops = { 2339 .open = simple_open, 2340 .read = dpcm_state_read_file, 2341 .llseek = default_llseek, 2342 }; 2343 2344 int soc_dpcm_debugfs_add(struct snd_soc_pcm_runtime *rtd) 2345 { 2346 if (!rtd->dai_link) 2347 return 0; 2348 2349 rtd->debugfs_dpcm_root = debugfs_create_dir(rtd->dai_link->name, 2350 rtd->card->debugfs_card_root); 2351 if (!rtd->debugfs_dpcm_root) { 2352 dev_dbg(rtd->dev, 2353 "ASoC: Failed to create dpcm debugfs directory %s\n", 2354 rtd->dai_link->name); 2355 return -EINVAL; 2356 } 2357 2358 rtd->debugfs_dpcm_state = debugfs_create_file("state", 0444, 2359 rtd->debugfs_dpcm_root, 2360 rtd, &dpcm_state_fops); 2361 2362 return 0; 2363 } 2364 #endif 2365