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